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_write_congested, /* The write queue is getting full */ 28 BDI_read_congested, /* The read 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 unsigned long ra_pages; /* max readahead in PAGE_CACHE_SIZE units */ 44 unsigned long state; /* Always use atomic bitops on this */ 45 unsigned int capabilities; /* Device capabilities */ 46 congested_fn *congested_fn; /* Function pointer if device is md/dm */ 47 void *congested_data; /* Pointer to aux data for congested func */ 48 void (*unplug_io_fn)(struct backing_dev_info *, struct page *); 49 void *unplug_io_data; 50 51 struct percpu_counter bdi_stat[NR_BDI_STAT_ITEMS]; 52 53 struct prop_local_percpu completions; 54 int dirty_exceeded; 55 56 unsigned int min_ratio; 57 unsigned int max_ratio, max_prop_frac; 58 59 struct device *dev; 60 61 #ifdef CONFIG_DEBUG_FS 62 struct dentry *debug_dir; 63 struct dentry *debug_stats; 64 #endif 65 }; 66 67 int bdi_init(struct backing_dev_info *bdi); 68 void bdi_destroy(struct backing_dev_info *bdi); 69 70 int bdi_register(struct backing_dev_info *bdi, struct device *parent, 71 const char *fmt, ...); 72 int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev); 73 void bdi_unregister(struct backing_dev_info *bdi); 74 75 static inline void __add_bdi_stat(struct backing_dev_info *bdi, 76 enum bdi_stat_item item, s64 amount) 77 { 78 __percpu_counter_add(&bdi->bdi_stat[item], amount, BDI_STAT_BATCH); 79 } 80 81 static inline void __inc_bdi_stat(struct backing_dev_info *bdi, 82 enum bdi_stat_item item) 83 { 84 __add_bdi_stat(bdi, item, 1); 85 } 86 87 static inline void inc_bdi_stat(struct backing_dev_info *bdi, 88 enum bdi_stat_item item) 89 { 90 unsigned long flags; 91 92 local_irq_save(flags); 93 __inc_bdi_stat(bdi, item); 94 local_irq_restore(flags); 95 } 96 97 static inline void __dec_bdi_stat(struct backing_dev_info *bdi, 98 enum bdi_stat_item item) 99 { 100 __add_bdi_stat(bdi, item, -1); 101 } 102 103 static inline void dec_bdi_stat(struct backing_dev_info *bdi, 104 enum bdi_stat_item item) 105 { 106 unsigned long flags; 107 108 local_irq_save(flags); 109 __dec_bdi_stat(bdi, item); 110 local_irq_restore(flags); 111 } 112 113 static inline s64 bdi_stat(struct backing_dev_info *bdi, 114 enum bdi_stat_item item) 115 { 116 return percpu_counter_read_positive(&bdi->bdi_stat[item]); 117 } 118 119 static inline s64 __bdi_stat_sum(struct backing_dev_info *bdi, 120 enum bdi_stat_item item) 121 { 122 return percpu_counter_sum_positive(&bdi->bdi_stat[item]); 123 } 124 125 static inline s64 bdi_stat_sum(struct backing_dev_info *bdi, 126 enum bdi_stat_item item) 127 { 128 s64 sum; 129 unsigned long flags; 130 131 local_irq_save(flags); 132 sum = __bdi_stat_sum(bdi, item); 133 local_irq_restore(flags); 134 135 return sum; 136 } 137 138 extern void bdi_writeout_inc(struct backing_dev_info *bdi); 139 140 /* 141 * maximal error of a stat counter. 142 */ 143 static inline unsigned long bdi_stat_error(struct backing_dev_info *bdi) 144 { 145 #ifdef CONFIG_SMP 146 return nr_cpu_ids * BDI_STAT_BATCH; 147 #else 148 return 1; 149 #endif 150 } 151 152 int bdi_set_min_ratio(struct backing_dev_info *bdi, unsigned int min_ratio); 153 int bdi_set_max_ratio(struct backing_dev_info *bdi, unsigned int max_ratio); 154 155 /* 156 * Flags in backing_dev_info::capability 157 * 158 * The first three flags control whether dirty pages will contribute to the 159 * VM's accounting and whether writepages() should be called for dirty pages 160 * (something that would not, for example, be appropriate for ramfs) 161 * 162 * WARNING: these flags are closely related and should not normally be 163 * used separately. The BDI_CAP_NO_ACCT_AND_WRITEBACK combines these 164 * three flags into a single convenience macro. 165 * 166 * BDI_CAP_NO_ACCT_DIRTY: Dirty pages shouldn't contribute to accounting 167 * BDI_CAP_NO_WRITEBACK: Don't write pages back 168 * BDI_CAP_NO_ACCT_WB: Don't automatically account writeback pages 169 * 170 * These flags let !MMU mmap() govern direct device mapping vs immediate 171 * copying more easily for MAP_PRIVATE, especially for ROM filesystems. 172 * 173 * BDI_CAP_MAP_COPY: Copy can be mapped (MAP_PRIVATE) 174 * BDI_CAP_MAP_DIRECT: Can be mapped directly (MAP_SHARED) 175 * BDI_CAP_READ_MAP: Can be mapped for reading 176 * BDI_CAP_WRITE_MAP: Can be mapped for writing 177 * BDI_CAP_EXEC_MAP: Can be mapped for execution 178 */ 179 #define BDI_CAP_NO_ACCT_DIRTY 0x00000001 180 #define BDI_CAP_NO_WRITEBACK 0x00000002 181 #define BDI_CAP_MAP_COPY 0x00000004 182 #define BDI_CAP_MAP_DIRECT 0x00000008 183 #define BDI_CAP_READ_MAP 0x00000010 184 #define BDI_CAP_WRITE_MAP 0x00000020 185 #define BDI_CAP_EXEC_MAP 0x00000040 186 #define BDI_CAP_NO_ACCT_WB 0x00000080 187 188 #define BDI_CAP_VMFLAGS \ 189 (BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP) 190 191 #define BDI_CAP_NO_ACCT_AND_WRITEBACK \ 192 (BDI_CAP_NO_WRITEBACK | BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_ACCT_WB) 193 194 #if defined(VM_MAYREAD) && \ 195 (BDI_CAP_READ_MAP != VM_MAYREAD || \ 196 BDI_CAP_WRITE_MAP != VM_MAYWRITE || \ 197 BDI_CAP_EXEC_MAP != VM_MAYEXEC) 198 #error please change backing_dev_info::capabilities flags 199 #endif 200 201 extern struct backing_dev_info default_backing_dev_info; 202 void default_unplug_io_fn(struct backing_dev_info *bdi, struct page *page); 203 204 int writeback_in_progress(struct backing_dev_info *bdi); 205 206 static inline int bdi_congested(struct backing_dev_info *bdi, int bdi_bits) 207 { 208 if (bdi->congested_fn) 209 return bdi->congested_fn(bdi->congested_data, bdi_bits); 210 return (bdi->state & bdi_bits); 211 } 212 213 static inline int bdi_read_congested(struct backing_dev_info *bdi) 214 { 215 return bdi_congested(bdi, 1 << BDI_read_congested); 216 } 217 218 static inline int bdi_write_congested(struct backing_dev_info *bdi) 219 { 220 return bdi_congested(bdi, 1 << BDI_write_congested); 221 } 222 223 static inline int bdi_rw_congested(struct backing_dev_info *bdi) 224 { 225 return bdi_congested(bdi, (1 << BDI_read_congested)| 226 (1 << BDI_write_congested)); 227 } 228 229 void clear_bdi_congested(struct backing_dev_info *bdi, int rw); 230 void set_bdi_congested(struct backing_dev_info *bdi, int rw); 231 long congestion_wait(int rw, long timeout); 232 233 234 static inline bool bdi_cap_writeback_dirty(struct backing_dev_info *bdi) 235 { 236 return !(bdi->capabilities & BDI_CAP_NO_WRITEBACK); 237 } 238 239 static inline bool bdi_cap_account_dirty(struct backing_dev_info *bdi) 240 { 241 return !(bdi->capabilities & BDI_CAP_NO_ACCT_DIRTY); 242 } 243 244 static inline bool bdi_cap_account_writeback(struct backing_dev_info *bdi) 245 { 246 /* Paranoia: BDI_CAP_NO_WRITEBACK implies BDI_CAP_NO_ACCT_WB */ 247 return !(bdi->capabilities & (BDI_CAP_NO_ACCT_WB | 248 BDI_CAP_NO_WRITEBACK)); 249 } 250 251 static inline bool mapping_cap_writeback_dirty(struct address_space *mapping) 252 { 253 return bdi_cap_writeback_dirty(mapping->backing_dev_info); 254 } 255 256 static inline bool mapping_cap_account_dirty(struct address_space *mapping) 257 { 258 return bdi_cap_account_dirty(mapping->backing_dev_info); 259 } 260 261 #endif /* _LINUX_BACKING_DEV_H */ 262