From 189d3c4a94ef19fca2a71a6a336e9fda900e25e7 Mon Sep 17 00:00:00 2001 From: Peter Zijlstra Date: Wed, 30 Apr 2008 00:54:35 -0700 Subject: [PATCH] mm: bdi: allow setting a minimum for the bdi dirty limit Under normal circumstances each device is given a part of the total write-back cache that relates to its current avg writeout speed in relation to the other devices. min_ratio - allows one to assign a minimum portion of the write-back cache to a particular device. This is useful in situations where you might want to provide a minimum QoS. (One request for this feature came from flash based storage people who wanted to avoid writing out at all costs - they of course needed some pdflush hacks as well) max_ratio - allows one to assign a maximum portion of the dirty limit to a particular device. This is useful in situations where you want to avoid one device taking all or most of the write-back cache. Eg. an NFS mount that is prone to get stuck, or a FUSE mount which you don't trust to play fair. Add "min_ratio" to /sys/class/bdi. This indicates the minimum percentage of the global dirty threshold allocated to this bdi. [mszeredi@suse.cz] - fix parsing in min_ratio_store() - document new sysfs attribute Signed-off-by: Peter Zijlstra Signed-off-by: Miklos Szeredi Signed-off-by: Andrew Morton Signed-off-by: Linus Torvalds --- Documentation/ABI/testing/sysfs-class-bdi | 6 ++++++ include/linux/backing-dev.h | 4 ++++ mm/backing-dev.c | 21 +++++++++++++++++++++ mm/page-writeback.c | 27 ++++++++++++++++++++++++++- 4 files changed, 57 insertions(+), 1 deletion(-) diff --git a/Documentation/ABI/testing/sysfs-class-bdi b/Documentation/ABI/testing/sysfs-class-bdi index b800cdd..b9e8a93 100644 --- a/Documentation/ABI/testing/sysfs-class-bdi +++ b/Documentation/ABI/testing/sysfs-class-bdi @@ -44,3 +44,9 @@ bdi_dirty_kb (read-only) Current threshold on this BDI for reclaimable + writeback memory +min_ratio (read-write) + + Minimal percentage of global dirty threshold allocated to this + bdi. If the value written to this file would make the the sum + of all min_ratio values exceed 100, then EINVAL is returned. + The default is zero diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h index 6d51366..9a89655 100644 --- a/include/linux/backing-dev.h +++ b/include/linux/backing-dev.h @@ -51,6 +51,8 @@ struct backing_dev_info { struct prop_local_percpu completions; int dirty_exceeded; + unsigned int min_ratio; + struct device *dev; }; @@ -137,6 +139,8 @@ static inline unsigned long bdi_stat_error(struct backing_dev_info *bdi) #endif } +int bdi_set_min_ratio(struct backing_dev_info *bdi, unsigned int min_ratio); + /* * Flags in backing_dev_info::capability * - The first two flags control whether dirty pages will contribute to the diff --git a/mm/backing-dev.c b/mm/backing-dev.c index 847eabe..4967fb1 100644 --- a/mm/backing-dev.c +++ b/mm/backing-dev.c @@ -55,6 +55,24 @@ static inline unsigned long get_dirty(struct backing_dev_info *bdi, int i) BDI_SHOW(dirty_kb, K(get_dirty(bdi, 1))) BDI_SHOW(bdi_dirty_kb, K(get_dirty(bdi, 2))) +static ssize_t min_ratio_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + struct backing_dev_info *bdi = dev_get_drvdata(dev); + char *end; + unsigned int ratio; + ssize_t ret = -EINVAL; + + ratio = simple_strtoul(buf, &end, 10); + if (*buf && (end[0] == '\0' || (end[0] == '\n' && end[1] == '\0'))) { + ret = bdi_set_min_ratio(bdi, ratio); + if (!ret) + ret = count; + } + return ret; +} +BDI_SHOW(min_ratio, bdi->min_ratio) + #define __ATTR_RW(attr) __ATTR(attr, 0644, attr##_show, attr##_store) static struct device_attribute bdi_dev_attrs[] = { @@ -63,6 +81,7 @@ static struct device_attribute bdi_dev_attrs[] = { __ATTR_RO(writeback_kb), __ATTR_RO(dirty_kb), __ATTR_RO(bdi_dirty_kb), + __ATTR_RW(min_ratio), __ATTR_NULL, }; @@ -127,6 +146,8 @@ int bdi_init(struct backing_dev_info *bdi) bdi->dev = NULL; + bdi->min_ratio = 0; + for (i = 0; i < NR_BDI_STAT_ITEMS; i++) { err = percpu_counter_init_irq(&bdi->bdi_stat[i], 0); if (err) diff --git a/mm/page-writeback.c b/mm/page-writeback.c index e5b6b11..4ac077f 100644 --- a/mm/page-writeback.c +++ b/mm/page-writeback.c @@ -243,6 +243,29 @@ static void task_dirty_limit(struct task_struct *tsk, long *pdirty) } /* + * + */ +static DEFINE_SPINLOCK(bdi_lock); +static unsigned int bdi_min_ratio; + +int bdi_set_min_ratio(struct backing_dev_info *bdi, unsigned int min_ratio) +{ + int ret = 0; + unsigned long flags; + + spin_lock_irqsave(&bdi_lock, flags); + min_ratio -= bdi->min_ratio; + if (bdi_min_ratio + min_ratio < 100) { + bdi_min_ratio += min_ratio; + bdi->min_ratio += min_ratio; + } else + ret = -EINVAL; + spin_unlock_irqrestore(&bdi_lock, flags); + + return ret; +} + +/* * Work out the current dirty-memory clamping and background writeout * thresholds. * @@ -330,7 +353,7 @@ get_dirty_limits(long *pbackground, long *pdirty, long *pbdi_dirty, *pdirty = dirty; if (bdi) { - u64 bdi_dirty = dirty; + u64 bdi_dirty; long numerator, denominator; /* @@ -338,8 +361,10 @@ get_dirty_limits(long *pbackground, long *pdirty, long *pbdi_dirty, */ bdi_writeout_fraction(bdi, &numerator, &denominator); + bdi_dirty = (dirty * (100 - bdi_min_ratio)) / 100; bdi_dirty *= numerator; do_div(bdi_dirty, denominator); + bdi_dirty += (dirty * bdi->min_ratio) / 100; *pbdi_dirty = bdi_dirty; clip_bdi_dirty_limit(bdi, dirty, pbdi_dirty); -- 1.8.2.3