2 * include/linux/backing-dev.h
4 * low-level device information and state which is propagated up through
8 #ifndef _LINUX_BACKING_DEV_H
9 #define _LINUX_BACKING_DEV_H
11 #include <linux/percpu_counter.h>
12 #include <linux/log2.h>
13 #include <linux/flex_proportions.h>
14 #include <linux/kernel.h>
16 #include <linux/sched.h>
17 #include <linux/timer.h>
18 #include <linux/writeback.h>
19 #include <linux/atomic.h>
20 #include <linux/sysctl.h>
21 #include <linux/mutex.h>
28 * Bits in backing_dev_info.state
31 BDI_pending
, /* On its way to being activated */
32 BDI_wb_alloc
, /* Default embedded wb allocated */
33 BDI_async_congested
, /* The async (write) queue is getting full */
34 BDI_sync_congested
, /* The sync queue is getting full */
35 BDI_registered
, /* bdi_register() was done */
36 BDI_writeback_running
, /* Writeback is in progress */
37 BDI_unused
, /* Available bits start here */
40 typedef int (congested_fn
)(void *, int);
50 #define BDI_STAT_BATCH (8*(1+ilog2(nr_cpu_ids)))
52 struct bdi_writeback
{
53 struct backing_dev_info
*bdi
; /* our parent bdi */
56 unsigned long last_old_flush
; /* last old data flush */
57 unsigned long last_active
; /* last time bdi thread was active */
59 struct task_struct
*task
; /* writeback thread */
60 struct timer_list wakeup_timer
; /* used for delayed bdi thread wakeup */
61 struct list_head b_dirty
; /* dirty inodes */
62 struct list_head b_io
; /* parked for writeback */
63 struct list_head b_more_io
; /* parked for more writeback */
64 spinlock_t list_lock
; /* protects the b_* lists */
67 struct backing_dev_info
{
68 struct list_head bdi_list
;
69 unsigned long ra_pages
; /* max readahead in PAGE_CACHE_SIZE units */
70 unsigned long state
; /* Always use atomic bitops on this */
71 unsigned int capabilities
; /* Device capabilities */
72 congested_fn
*congested_fn
; /* Function pointer if device is md/dm */
73 void *congested_data
; /* Pointer to aux data for congested func */
77 struct percpu_counter bdi_stat
[NR_BDI_STAT_ITEMS
];
79 unsigned long bw_time_stamp
; /* last time write bw is updated */
80 unsigned long dirtied_stamp
;
81 unsigned long written_stamp
; /* pages written at bw_time_stamp */
82 unsigned long write_bandwidth
; /* the estimated write bandwidth */
83 unsigned long avg_write_bandwidth
; /* further smoothed write bw */
86 * The base dirty throttle rate, re-calculated on every 200ms.
87 * All the bdi tasks' dirty rate will be curbed under it.
88 * @dirty_ratelimit tracks the estimated @balanced_dirty_ratelimit
89 * in small steps and is much more smooth/stable than the latter.
91 unsigned long dirty_ratelimit
;
92 unsigned long balanced_dirty_ratelimit
;
94 struct fprop_local_percpu completions
;
97 unsigned int min_ratio
;
98 unsigned int max_ratio
, max_prop_frac
;
100 struct bdi_writeback wb
; /* default writeback info for this bdi */
101 spinlock_t wb_lock
; /* protects work_list */
103 struct list_head work_list
;
107 struct timer_list laptop_mode_wb_timer
;
109 cpumask_t
*flusher_cpumask
; /* used for writeback thread scheduling */
110 struct mutex flusher_cpumask_lock
;
112 #ifdef CONFIG_DEBUG_FS
113 struct dentry
*debug_dir
;
114 struct dentry
*debug_stats
;
118 int bdi_init(struct backing_dev_info
*bdi
);
119 void bdi_destroy(struct backing_dev_info
*bdi
);
121 int bdi_register(struct backing_dev_info
*bdi
, struct device
*parent
,
122 const char *fmt
, ...);
123 int bdi_register_dev(struct backing_dev_info
*bdi
, dev_t dev
);
124 void bdi_unregister(struct backing_dev_info
*bdi
);
125 int bdi_setup_and_register(struct backing_dev_info
*, char *, unsigned int);
126 void bdi_start_writeback(struct backing_dev_info
*bdi
, long nr_pages
,
127 enum wb_reason reason
);
128 void bdi_start_background_writeback(struct backing_dev_info
*bdi
);
129 int bdi_writeback_thread(void *data
);
130 int bdi_has_dirty_io(struct backing_dev_info
*bdi
);
131 void bdi_wakeup_thread_delayed(struct backing_dev_info
*bdi
);
132 void bdi_lock_two(struct bdi_writeback
*wb1
, struct bdi_writeback
*wb2
);
134 extern spinlock_t bdi_lock
;
135 extern struct list_head bdi_list
;
136 extern struct list_head bdi_pending_list
;
138 static inline int wb_has_dirty_io(struct bdi_writeback
*wb
)
140 return !list_empty(&wb
->b_dirty
) ||
141 !list_empty(&wb
->b_io
) ||
142 !list_empty(&wb
->b_more_io
);
145 static inline void __add_bdi_stat(struct backing_dev_info
*bdi
,
146 enum bdi_stat_item item
, s64 amount
)
148 __percpu_counter_add(&bdi
->bdi_stat
[item
], amount
, BDI_STAT_BATCH
);
151 static inline void __inc_bdi_stat(struct backing_dev_info
*bdi
,
152 enum bdi_stat_item item
)
154 __add_bdi_stat(bdi
, item
, 1);
157 static inline void inc_bdi_stat(struct backing_dev_info
*bdi
,
158 enum bdi_stat_item item
)
162 local_irq_save(flags
);
163 __inc_bdi_stat(bdi
, item
);
164 local_irq_restore(flags
);
167 static inline void __dec_bdi_stat(struct backing_dev_info
*bdi
,
168 enum bdi_stat_item item
)
170 __add_bdi_stat(bdi
, item
, -1);
173 static inline void dec_bdi_stat(struct backing_dev_info
*bdi
,
174 enum bdi_stat_item item
)
178 local_irq_save(flags
);
179 __dec_bdi_stat(bdi
, item
);
180 local_irq_restore(flags
);
183 static inline s64
bdi_stat(struct backing_dev_info
*bdi
,
184 enum bdi_stat_item item
)
186 return percpu_counter_read_positive(&bdi
->bdi_stat
[item
]);
189 static inline s64
__bdi_stat_sum(struct backing_dev_info
*bdi
,
190 enum bdi_stat_item item
)
192 return percpu_counter_sum_positive(&bdi
->bdi_stat
[item
]);
195 static inline s64
bdi_stat_sum(struct backing_dev_info
*bdi
,
196 enum bdi_stat_item item
)
201 local_irq_save(flags
);
202 sum
= __bdi_stat_sum(bdi
, item
);
203 local_irq_restore(flags
);
208 extern void bdi_writeout_inc(struct backing_dev_info
*bdi
);
211 * maximal error of a stat counter.
213 static inline unsigned long bdi_stat_error(struct backing_dev_info
*bdi
)
216 return nr_cpu_ids
* BDI_STAT_BATCH
;
222 int bdi_set_min_ratio(struct backing_dev_info
*bdi
, unsigned int min_ratio
);
223 int bdi_set_max_ratio(struct backing_dev_info
*bdi
, unsigned int max_ratio
);
226 * Flags in backing_dev_info::capability
228 * The first three flags control whether dirty pages will contribute to the
229 * VM's accounting and whether writepages() should be called for dirty pages
230 * (something that would not, for example, be appropriate for ramfs)
232 * WARNING: these flags are closely related and should not normally be
233 * used separately. The BDI_CAP_NO_ACCT_AND_WRITEBACK combines these
234 * three flags into a single convenience macro.
236 * BDI_CAP_NO_ACCT_DIRTY: Dirty pages shouldn't contribute to accounting
237 * BDI_CAP_NO_WRITEBACK: Don't write pages back
238 * BDI_CAP_NO_ACCT_WB: Don't automatically account writeback pages
240 * These flags let !MMU mmap() govern direct device mapping vs immediate
241 * copying more easily for MAP_PRIVATE, especially for ROM filesystems.
243 * BDI_CAP_MAP_COPY: Copy can be mapped (MAP_PRIVATE)
244 * BDI_CAP_MAP_DIRECT: Can be mapped directly (MAP_SHARED)
245 * BDI_CAP_READ_MAP: Can be mapped for reading
246 * BDI_CAP_WRITE_MAP: Can be mapped for writing
247 * BDI_CAP_EXEC_MAP: Can be mapped for execution
249 * BDI_CAP_SWAP_BACKED: Count shmem/tmpfs objects as swap-backed.
251 #define BDI_CAP_NO_ACCT_DIRTY 0x00000001
252 #define BDI_CAP_NO_WRITEBACK 0x00000002
253 #define BDI_CAP_MAP_COPY 0x00000004
254 #define BDI_CAP_MAP_DIRECT 0x00000008
255 #define BDI_CAP_READ_MAP 0x00000010
256 #define BDI_CAP_WRITE_MAP 0x00000020
257 #define BDI_CAP_EXEC_MAP 0x00000040
258 #define BDI_CAP_NO_ACCT_WB 0x00000080
259 #define BDI_CAP_SWAP_BACKED 0x00000100
261 #define BDI_CAP_VMFLAGS \
262 (BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP)
264 #define BDI_CAP_NO_ACCT_AND_WRITEBACK \
265 (BDI_CAP_NO_WRITEBACK | BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_ACCT_WB)
267 #if defined(VM_MAYREAD) && \
268 (BDI_CAP_READ_MAP != VM_MAYREAD || \
269 BDI_CAP_WRITE_MAP != VM_MAYWRITE || \
270 BDI_CAP_EXEC_MAP != VM_MAYEXEC)
271 #error please change backing_dev_info::capabilities flags
274 extern struct backing_dev_info default_backing_dev_info
;
275 extern struct backing_dev_info noop_backing_dev_info
;
277 int writeback_in_progress(struct backing_dev_info
*bdi
);
279 static inline int bdi_congested(struct backing_dev_info
*bdi
, int bdi_bits
)
281 if (bdi
->congested_fn
)
282 return bdi
->congested_fn(bdi
->congested_data
, bdi_bits
);
283 return (bdi
->state
& bdi_bits
);
286 static inline int bdi_read_congested(struct backing_dev_info
*bdi
)
288 return bdi_congested(bdi
, 1 << BDI_sync_congested
);
291 static inline int bdi_write_congested(struct backing_dev_info
*bdi
)
293 return bdi_congested(bdi
, 1 << BDI_async_congested
);
296 static inline int bdi_rw_congested(struct backing_dev_info
*bdi
)
298 return bdi_congested(bdi
, (1 << BDI_sync_congested
) |
299 (1 << BDI_async_congested
));
307 void clear_bdi_congested(struct backing_dev_info
*bdi
, int sync
);
308 void set_bdi_congested(struct backing_dev_info
*bdi
, int sync
);
309 long congestion_wait(int sync
, long timeout
);
310 long wait_iff_congested(struct zone
*zone
, int sync
, long timeout
);
311 int pdflush_proc_obsolete(struct ctl_table
*table
, int write
,
312 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
);
314 static inline bool bdi_cap_writeback_dirty(struct backing_dev_info
*bdi
)
316 return !(bdi
->capabilities
& BDI_CAP_NO_WRITEBACK
);
319 static inline bool bdi_cap_account_dirty(struct backing_dev_info
*bdi
)
321 return !(bdi
->capabilities
& BDI_CAP_NO_ACCT_DIRTY
);
324 static inline bool bdi_cap_account_writeback(struct backing_dev_info
*bdi
)
326 /* Paranoia: BDI_CAP_NO_WRITEBACK implies BDI_CAP_NO_ACCT_WB */
327 return !(bdi
->capabilities
& (BDI_CAP_NO_ACCT_WB
|
328 BDI_CAP_NO_WRITEBACK
));
331 static inline bool bdi_cap_swap_backed(struct backing_dev_info
*bdi
)
333 return bdi
->capabilities
& BDI_CAP_SWAP_BACKED
;
336 static inline bool bdi_cap_flush_forker(struct backing_dev_info
*bdi
)
338 return bdi
== &default_backing_dev_info
;
341 static inline bool mapping_cap_writeback_dirty(struct address_space
*mapping
)
343 return bdi_cap_writeback_dirty(mapping
->backing_dev_info
);
346 static inline bool mapping_cap_account_dirty(struct address_space
*mapping
)
348 return bdi_cap_account_dirty(mapping
->backing_dev_info
);
351 static inline bool mapping_cap_swap_backed(struct address_space
*mapping
)
353 return bdi_cap_swap_backed(mapping
->backing_dev_info
);
356 static inline int bdi_sched_wait(void *word
)
362 #endif /* _LINUX_BACKING_DEV_H */