include/linux/backing-dev.h

   1 /*
   2  * include/linux/backing-dev.h
   3  *
   4  * low-level device information and state which is propagated up through
   5  * to high-level code.
   6  */
   7
   8 #ifndef _LINUX_BACKING_DEV_H
   9 #define _LINUX_BACKING_DEV_H
  10
  11 #include <linux/percpu_counter.h>
  12 #include <linux/log2.h>
  13 #include <linux/proportions.h>
  14 #include <linux/kernel.h>
  15 #include <linux/fs.h>
  16 #include <asm/atomic.h>
  17
  18 struct page;
  19 struct device;
  20 struct dentry;
  21
  22 /*
  23  * Bits in backing_dev_info.state
  24  */
  25 enum bdi_state {
  26         BDI_pdflush,            /* A pdflush thread is working this device */
  27         BDI_async_congested,    /* The async (write) queue is getting full */
  28         BDI_sync_congested,     /* The sync queue is getting full */
  29         BDI_unused,             /* Available bits start here */
  30 };
  31
  32 typedef int (congested_fn)(void *, int);
  33
  34 enum bdi_stat_item {
  35         BDI_RECLAIMABLE,
  36         BDI_WRITEBACK,
  37         NR_BDI_STAT_ITEMS
  38 };
  39
  40 #define BDI_STAT_BATCH (8*(1+ilog2(nr_cpu_ids)))
  41
  42 struct backing_dev_info {
  43         struct list_head bdi_list;
  44
  45         unsigned long ra_pages; /* max readahead in PAGE_CACHE_SIZE units */
  46         unsigned long state;    /* Always use atomic bitops on this */
  47         unsigned int capabilities; /* Device capabilities */
  48         congested_fn *congested_fn; /* Function pointer if device is md/dm */
  49         void *congested_data;   /* Pointer to aux data for congested func */
  50         void (*unplug_io_fn)(struct backing_dev_info *, struct page *);
  51         void *unplug_io_data;
  52
  53         struct percpu_counter bdi_stat[NR_BDI_STAT_ITEMS];
  54
  55         struct prop_local_percpu completions;
  56         int dirty_exceeded;
  57
  58         unsigned int min_ratio;
  59         unsigned int max_ratio, max_prop_frac;
  60
  61         struct device *dev;
  62
  63         struct list_head        b_dirty;        /* dirty inodes */
  64         struct list_head        b_io;           /* parked for writeback */
  65         struct list_head        b_more_io;      /* parked for more writeback */
  66
  67 #ifdef CONFIG_DEBUG_FS
  68         struct dentry *debug_dir;
  69         struct dentry *debug_stats;
  70 #endif
  71 };
  72
  73 int bdi_init(struct backing_dev_info *bdi);
  74 void bdi_destroy(struct backing_dev_info *bdi);
  75
  76 int bdi_register(struct backing_dev_info *bdi, struct device *parent,
  77                 const char *fmt, ...);
  78 int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);
  79 void bdi_unregister(struct backing_dev_info *bdi);
  80
  81 extern struct mutex bdi_lock;
  82 extern struct list_head bdi_list;
  83
  84 static inline void __add_bdi_stat(struct backing_dev_info *bdi,
  85                 enum bdi_stat_item item, s64 amount)
  86 {
  87         __percpu_counter_add(&bdi->bdi_stat[item], amount, BDI_STAT_BATCH);
  88 }
  89
  90 static inline void __inc_bdi_stat(struct backing_dev_info *bdi,
  91                 enum bdi_stat_item item)
  92 {
  93         __add_bdi_stat(bdi, item, 1);
  94 }
  95
  96 static inline void inc_bdi_stat(struct backing_dev_info *bdi,
  97                 enum bdi_stat_item item)
  98 {
  99         unsigned long flags;
 100
 101         local_irq_save(flags);
 102         __inc_bdi_stat(bdi, item);
 103         local_irq_restore(flags);
 104 }
 105
 106 static inline void __dec_bdi_stat(struct backing_dev_info *bdi,
 107                 enum bdi_stat_item item)
 108 {
 109         __add_bdi_stat(bdi, item, -1);
 110 }
 111
 112 static inline void dec_bdi_stat(struct backing_dev_info *bdi,
 113                 enum bdi_stat_item item)
 114 {
 115         unsigned long flags;
 116
 117         local_irq_save(flags);
 118         __dec_bdi_stat(bdi, item);
 119         local_irq_restore(flags);
 120 }
 121
 122 static inline s64 bdi_stat(struct backing_dev_info *bdi,
 123                 enum bdi_stat_item item)
 124 {
 125         return percpu_counter_read_positive(&bdi->bdi_stat[item]);
 126 }
 127
 128 static inline s64 __bdi_stat_sum(struct backing_dev_info *bdi,
 129                 enum bdi_stat_item item)
 130 {
 131         return percpu_counter_sum_positive(&bdi->bdi_stat[item]);
 132 }
 133
 134 static inline s64 bdi_stat_sum(struct backing_dev_info *bdi,
 135                 enum bdi_stat_item item)
 136 {
 137         s64 sum;
 138         unsigned long flags;
 139
 140         local_irq_save(flags);
 141         sum = __bdi_stat_sum(bdi, item);
 142         local_irq_restore(flags);
 143
 144         return sum;
 145 }
 146
 147 extern void bdi_writeout_inc(struct backing_dev_info *bdi);
 148
 149 /*
 150  * maximal error of a stat counter.
 151  */
 152 static inline unsigned long bdi_stat_error(struct backing_dev_info *bdi)
 153 {
 154 #ifdef CONFIG_SMP
 155         return nr_cpu_ids * BDI_STAT_BATCH;
 156 #else
 157         return 1;
 158 #endif
 159 }
 160
 161 int bdi_set_min_ratio(struct backing_dev_info *bdi, unsigned int min_ratio);
 162 int bdi_set_max_ratio(struct backing_dev_info *bdi, unsigned int max_ratio);
 163
 164 /*
 165  * Flags in backing_dev_info::capability
 166  *
 167  * The first three flags control whether dirty pages will contribute to the
 168  * VM's accounting and whether writepages() should be called for dirty pages
 169  * (something that would not, for example, be appropriate for ramfs)
 170  *
 171  * WARNING: these flags are closely related and should not normally be
 172  * used separately.  The BDI_CAP_NO_ACCT_AND_WRITEBACK combines these
 173  * three flags into a single convenience macro.
 174  *
 175  * BDI_CAP_NO_ACCT_DIRTY:  Dirty pages shouldn't contribute to accounting
 176  * BDI_CAP_NO_WRITEBACK:   Don't write pages back
 177  * BDI_CAP_NO_ACCT_WB:     Don't automatically account writeback pages
 178  *
 179  * These flags let !MMU mmap() govern direct device mapping vs immediate
 180  * copying more easily for MAP_PRIVATE, especially for ROM filesystems.
 181  *
 182  * BDI_CAP_MAP_COPY:       Copy can be mapped (MAP_PRIVATE)
 183  * BDI_CAP_MAP_DIRECT:     Can be mapped directly (MAP_SHARED)
 184  * BDI_CAP_READ_MAP:       Can be mapped for reading
 185  * BDI_CAP_WRITE_MAP:      Can be mapped for writing
 186  * BDI_CAP_EXEC_MAP:       Can be mapped for execution
 187  *
 188  * BDI_CAP_SWAP_BACKED:    Count shmem/tmpfs objects as swap-backed.
 189  */
 190 #define BDI_CAP_NO_ACCT_DIRTY   0x00000001
 191 #define BDI_CAP_NO_WRITEBACK    0x00000002
 192 #define BDI_CAP_MAP_COPY        0x00000004
 193 #define BDI_CAP_MAP_DIRECT      0x00000008
 194 #define BDI_CAP_READ_MAP        0x00000010
 195 #define BDI_CAP_WRITE_MAP       0x00000020
 196 #define BDI_CAP_EXEC_MAP        0x00000040
 197 #define BDI_CAP_NO_ACCT_WB      0x00000080
 198 #define BDI_CAP_SWAP_BACKED     0x00000100
 199
 200 #define BDI_CAP_VMFLAGS \
 201         (BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP)
 202
 203 #define BDI_CAP_NO_ACCT_AND_WRITEBACK \
 204         (BDI_CAP_NO_WRITEBACK | BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_ACCT_WB)
 205
 206 #if defined(VM_MAYREAD) && \
 207         (BDI_CAP_READ_MAP != VM_MAYREAD || \
 208          BDI_CAP_WRITE_MAP != VM_MAYWRITE || \
 209          BDI_CAP_EXEC_MAP != VM_MAYEXEC)
 210 #error please change backing_dev_info::capabilities flags
 211 #endif
 212
 213 extern struct backing_dev_info default_backing_dev_info;
 214 void default_unplug_io_fn(struct backing_dev_info *bdi, struct page *page);
 215
 216 int writeback_in_progress(struct backing_dev_info *bdi);
 217
 218 static inline int bdi_congested(struct backing_dev_info *bdi, int bdi_bits)
 219 {
 220         if (bdi->congested_fn)
 221                 return bdi->congested_fn(bdi->congested_data, bdi_bits);
 222         return (bdi->state & bdi_bits);
 223 }
 224
 225 static inline int bdi_read_congested(struct backing_dev_info *bdi)
 226 {
 227         return bdi_congested(bdi, 1 << BDI_sync_congested);
 228 }
 229
 230 static inline int bdi_write_congested(struct backing_dev_info *bdi)
 231 {
 232         return bdi_congested(bdi, 1 << BDI_async_congested);
 233 }
 234
 235 static inline int bdi_rw_congested(struct backing_dev_info *bdi)
 236 {
 237         return bdi_congested(bdi, (1 << BDI_sync_congested) |
 238                                   (1 << BDI_async_congested));
 239 }
 240
 241 enum {
 242         BLK_RW_ASYNC    = 0,
 243         BLK_RW_SYNC     = 1,
 244 };
 245
 246 void clear_bdi_congested(struct backing_dev_info *bdi, int sync);
 247 void set_bdi_congested(struct backing_dev_info *bdi, int sync);
 248 long congestion_wait(int sync, long timeout);
 249
 250
 251 static inline bool bdi_cap_writeback_dirty(struct backing_dev_info *bdi)
 252 {
 253         return !(bdi->capabilities & BDI_CAP_NO_WRITEBACK);
 254 }
 255
 256 static inline bool bdi_cap_account_dirty(struct backing_dev_info *bdi)
 257 {
 258         return !(bdi->capabilities & BDI_CAP_NO_ACCT_DIRTY);
 259 }
 260
 261 static inline bool bdi_cap_account_writeback(struct backing_dev_info *bdi)
 262 {
 263         /* Paranoia: BDI_CAP_NO_WRITEBACK implies BDI_CAP_NO_ACCT_WB */
 264         return !(bdi->capabilities & (BDI_CAP_NO_ACCT_WB |
 265                                       BDI_CAP_NO_WRITEBACK));
 266 }
 267
 268 static inline bool bdi_cap_swap_backed(struct backing_dev_info *bdi)
 269 {
 270         return bdi->capabilities & BDI_CAP_SWAP_BACKED;
 271 }
 272
 273 static inline bool mapping_cap_writeback_dirty(struct address_space *mapping)
 274 {
 275         return bdi_cap_writeback_dirty(mapping->backing_dev_info);
 276 }
 277
 278 static inline bool mapping_cap_account_dirty(struct address_space *mapping)
 279 {
 280         return bdi_cap_account_dirty(mapping->backing_dev_info);
 281 }
 282
 283 static inline bool mapping_cap_swap_backed(struct address_space *mapping)
 284 {
 285         return bdi_cap_swap_backed(mapping->backing_dev_info);
 286 }
 287
 288 #endif          /* _LINUX_BACKING_DEV_H */