mm/backing-dev.c

   1
   2 #include <linux/wait.h>
   3 #include <linux/backing-dev.h>
   4 #include <linux/fs.h>
   5 #include <linux/sched.h>
   6 #include <linux/module.h>
   7 #include <linux/writeback.h>
   8 #include <linux/device.h>
   9
  10
  11 static struct class *bdi_class;
  12
  13 static ssize_t read_ahead_kb_store(struct device *dev,
  14                                   struct device_attribute *attr,
  15                                   const char *buf, size_t count)
  16 {
  17         struct backing_dev_info *bdi = dev_get_drvdata(dev);
  18         char *end;
  19         unsigned long read_ahead_kb;
  20         ssize_t ret = -EINVAL;
  21
  22         read_ahead_kb = simple_strtoul(buf, &end, 10);
  23         if (*buf && (end[0] == '\0' || (end[0] == '\n' && end[1] == '\0'))) {
  24                 bdi->ra_pages = read_ahead_kb >> (PAGE_SHIFT - 10);
  25                 ret = count;
  26         }
  27         return ret;
  28 }
  29
  30 #define K(pages) ((pages) << (PAGE_SHIFT - 10))
  31
  32 #define BDI_SHOW(name, expr)                                            \
  33 static ssize_t name##_show(struct device *dev,                          \
  34                            struct device_attribute *attr, char *page)   \
  35 {                                                                       \
  36         struct backing_dev_info *bdi = dev_get_drvdata(dev);            \
  37                                                                         \
  38         return snprintf(page, PAGE_SIZE-1, "%lld\n", (long long)expr);  \
  39 }
  40
  41 BDI_SHOW(read_ahead_kb, K(bdi->ra_pages))
  42
  43 BDI_SHOW(reclaimable_kb, K(bdi_stat(bdi, BDI_RECLAIMABLE)))
  44 BDI_SHOW(writeback_kb, K(bdi_stat(bdi, BDI_WRITEBACK)))
  45
  46 static inline unsigned long get_dirty(struct backing_dev_info *bdi, int i)
  47 {
  48         unsigned long thresh[3];
  49
  50         get_dirty_limits(&thresh[0], &thresh[1], &thresh[2], bdi);
  51
  52         return thresh[i];
  53 }
  54
  55 BDI_SHOW(dirty_kb, K(get_dirty(bdi, 1)))
  56 BDI_SHOW(bdi_dirty_kb, K(get_dirty(bdi, 2)))
  57
  58 #define __ATTR_RW(attr) __ATTR(attr, 0644, attr##_show, attr##_store)
  59
  60 static struct device_attribute bdi_dev_attrs[] = {
  61         __ATTR_RW(read_ahead_kb),
  62         __ATTR_RO(reclaimable_kb),
  63         __ATTR_RO(writeback_kb),
  64         __ATTR_RO(dirty_kb),
  65         __ATTR_RO(bdi_dirty_kb),
  66         __ATTR_NULL,
  67 };
  68
  69 static __init int bdi_class_init(void)
  70 {
  71         bdi_class = class_create(THIS_MODULE, "bdi");
  72         bdi_class->dev_attrs = bdi_dev_attrs;
  73         return 0;
  74 }
  75
  76 core_initcall(bdi_class_init);
  77
  78 int bdi_register(struct backing_dev_info *bdi, struct device *parent,
  79                 const char *fmt, ...)
  80 {
  81         char *name;
  82         va_list args;
  83         int ret = 0;
  84         struct device *dev;
  85
  86         va_start(args, fmt);
  87         name = kvasprintf(GFP_KERNEL, fmt, args);
  88         va_end(args);
  89
  90         if (!name)
  91                 return -ENOMEM;
  92
  93         dev = device_create(bdi_class, parent, MKDEV(0, 0), name);
  94         if (IS_ERR(dev)) {
  95                 ret = PTR_ERR(dev);
  96                 goto exit;
  97         }
  98
  99         bdi->dev = dev;
 100         dev_set_drvdata(bdi->dev, bdi);
 101
 102 exit:
 103         kfree(name);
 104         return ret;
 105 }
 106 EXPORT_SYMBOL(bdi_register);
 107
 108 int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev)
 109 {
 110         return bdi_register(bdi, NULL, "%u:%u", MAJOR(dev), MINOR(dev));
 111 }
 112 EXPORT_SYMBOL(bdi_register_dev);
 113
 114 void bdi_unregister(struct backing_dev_info *bdi)
 115 {
 116         if (bdi->dev) {
 117                 device_unregister(bdi->dev);
 118                 bdi->dev = NULL;
 119         }
 120 }
 121 EXPORT_SYMBOL(bdi_unregister);
 122
 123 int bdi_init(struct backing_dev_info *bdi)
 124 {
 125         int i;
 126         int err;
 127
 128         bdi->dev = NULL;
 129
 130         for (i = 0; i < NR_BDI_STAT_ITEMS; i++) {
 131                 err = percpu_counter_init_irq(&bdi->bdi_stat[i], 0);
 132                 if (err)
 133                         goto err;
 134         }
 135
 136         bdi->dirty_exceeded = 0;
 137         err = prop_local_init_percpu(&bdi->completions);
 138
 139         if (err) {
 140 err:
 141                 while (i--)
 142                         percpu_counter_destroy(&bdi->bdi_stat[i]);
 143         }
 144
 145         return err;
 146 }
 147 EXPORT_SYMBOL(bdi_init);
 148
 149 void bdi_destroy(struct backing_dev_info *bdi)
 150 {
 151         int i;
 152
 153         bdi_unregister(bdi);
 154
 155         for (i = 0; i < NR_BDI_STAT_ITEMS; i++)
 156                 percpu_counter_destroy(&bdi->bdi_stat[i]);
 157
 158         prop_local_destroy_percpu(&bdi->completions);
 159 }
 160 EXPORT_SYMBOL(bdi_destroy);
 161
 162 static wait_queue_head_t congestion_wqh[2] = {
 163                 __WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[0]),
 164                 __WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[1])
 165         };
 166
 167
 168 void clear_bdi_congested(struct backing_dev_info *bdi, int rw)
 169 {
 170         enum bdi_state bit;
 171         wait_queue_head_t *wqh = &congestion_wqh[rw];
 172
 173         bit = (rw == WRITE) ? BDI_write_congested : BDI_read_congested;
 174         clear_bit(bit, &bdi->state);
 175         smp_mb__after_clear_bit();
 176         if (waitqueue_active(wqh))
 177                 wake_up(wqh);
 178 }
 179 EXPORT_SYMBOL(clear_bdi_congested);
 180
 181 void set_bdi_congested(struct backing_dev_info *bdi, int rw)
 182 {
 183         enum bdi_state bit;
 184
 185         bit = (rw == WRITE) ? BDI_write_congested : BDI_read_congested;
 186         set_bit(bit, &bdi->state);
 187 }
 188 EXPORT_SYMBOL(set_bdi_congested);
 189
 190 /**
 191  * congestion_wait - wait for a backing_dev to become uncongested
 192  * @rw: READ or WRITE
 193  * @timeout: timeout in jiffies
 194  *
 195  * Waits for up to @timeout jiffies for a backing_dev (any backing_dev) to exit
 196  * write congestion.  If no backing_devs are congested then just wait for the
 197  * next write to be completed.
 198  */
 199 long congestion_wait(int rw, long timeout)
 200 {
 201         long ret;
 202         DEFINE_WAIT(wait);
 203         wait_queue_head_t *wqh = &congestion_wqh[rw];
 204
 205         prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);
 206         ret = io_schedule_timeout(timeout);
 207         finish_wait(wqh, &wait);
 208         return ret;
 209 }
 210 EXPORT_SYMBOL(congestion_wait);
 211