1
2
3
4
5#ifndef WRITEBACK_H
6#define WRITEBACK_H
7
8#include <linux/sched.h>
9#include <linux/workqueue.h>
10#include <linux/fs.h>
11#include <linux/flex_proportions.h>
12#include <linux/backing-dev-defs.h>
13#include <linux/blk_types.h>
14
15struct bio;
16
17DECLARE_PER_CPU(int, dirty_throttle_leaks);
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32#define DIRTY_SCOPE 8
33#define DIRTY_FULL_SCOPE (DIRTY_SCOPE / 2)
34
35struct backing_dev_info;
36
37
38
39
40enum writeback_sync_modes {
41 WB_SYNC_NONE,
42 WB_SYNC_ALL,
43};
44
45
46
47
48
49
50struct writeback_control {
51 long nr_to_write;
52
53 long pages_skipped;
54
55
56
57
58
59
60 loff_t range_start;
61 loff_t range_end;
62
63 enum writeback_sync_modes sync_mode;
64
65 unsigned for_kupdate:1;
66 unsigned for_background:1;
67 unsigned tagged_writepages:1;
68 unsigned for_reclaim:1;
69 unsigned range_cyclic:1;
70 unsigned for_sync:1;
71#ifdef CONFIG_CGROUP_WRITEBACK
72 struct bdi_writeback *wb;
73 struct inode *inode;
74
75
76 int wb_id;
77 int wb_lcand_id;
78 int wb_tcand_id;
79 size_t wb_bytes;
80 size_t wb_lcand_bytes;
81 size_t wb_tcand_bytes;
82#endif
83};
84
85static inline int wbc_to_write_flags(struct writeback_control *wbc)
86{
87 if (wbc->sync_mode == WB_SYNC_ALL)
88 return REQ_SYNC;
89 else if (wbc->for_kupdate || wbc->for_background)
90 return REQ_BACKGROUND;
91
92 return 0;
93}
94
95
96
97
98
99
100
101
102struct wb_domain {
103 spinlock_t lock;
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122 struct fprop_global completions;
123 struct timer_list period_timer;
124 unsigned long period_time;
125
126
127
128
129
130
131
132
133
134
135
136 unsigned long dirty_limit_tstamp;
137 unsigned long dirty_limit;
138};
139
140
141
142
143
144
145
146
147
148
149
150
151
152static inline void wb_domain_size_changed(struct wb_domain *dom)
153{
154 spin_lock(&dom->lock);
155 dom->dirty_limit_tstamp = jiffies;
156 dom->dirty_limit = 0;
157 spin_unlock(&dom->lock);
158}
159
160
161
162
163struct bdi_writeback;
164void writeback_inodes_sb(struct super_block *, enum wb_reason reason);
165void writeback_inodes_sb_nr(struct super_block *, unsigned long nr,
166 enum wb_reason reason);
167void try_to_writeback_inodes_sb(struct super_block *sb, enum wb_reason reason);
168void sync_inodes_sb(struct super_block *);
169void wakeup_flusher_threads(enum wb_reason reason);
170void wakeup_flusher_threads_bdi(struct backing_dev_info *bdi,
171 enum wb_reason reason);
172void inode_wait_for_writeback(struct inode *inode);
173
174
175static inline void wait_on_inode(struct inode *inode)
176{
177 might_sleep();
178 wait_on_bit(&inode->i_state, __I_NEW, TASK_UNINTERRUPTIBLE);
179}
180
181#ifdef CONFIG_CGROUP_WRITEBACK
182
183#include <linux/cgroup.h>
184#include <linux/bio.h>
185
186void __inode_attach_wb(struct inode *inode, struct page *page);
187void wbc_attach_and_unlock_inode(struct writeback_control *wbc,
188 struct inode *inode)
189 __releases(&inode->i_lock);
190void wbc_detach_inode(struct writeback_control *wbc);
191void wbc_account_io(struct writeback_control *wbc, struct page *page,
192 size_t bytes);
193void cgroup_writeback_umount(void);
194
195
196
197
198
199
200
201
202
203
204static inline void inode_attach_wb(struct inode *inode, struct page *page)
205{
206 if (!inode->i_wb)
207 __inode_attach_wb(inode, page);
208}
209
210
211
212
213
214
215
216static inline void inode_detach_wb(struct inode *inode)
217{
218 if (inode->i_wb) {
219 WARN_ON_ONCE(!(inode->i_state & I_CLEAR));
220 wb_put(inode->i_wb);
221 inode->i_wb = NULL;
222 }
223}
224
225
226
227
228
229
230
231
232
233
234static inline void wbc_attach_fdatawrite_inode(struct writeback_control *wbc,
235 struct inode *inode)
236{
237 spin_lock(&inode->i_lock);
238 inode_attach_wb(inode, NULL);
239 wbc_attach_and_unlock_inode(wbc, inode);
240}
241
242
243
244
245
246
247
248
249
250
251static inline void wbc_init_bio(struct writeback_control *wbc, struct bio *bio)
252{
253
254
255
256
257
258
259 if (wbc->wb)
260 bio_associate_blkcg(bio, wbc->wb->blkcg_css);
261}
262
263#else
264
265static inline void inode_attach_wb(struct inode *inode, struct page *page)
266{
267}
268
269static inline void inode_detach_wb(struct inode *inode)
270{
271}
272
273static inline void wbc_attach_and_unlock_inode(struct writeback_control *wbc,
274 struct inode *inode)
275 __releases(&inode->i_lock)
276{
277 spin_unlock(&inode->i_lock);
278}
279
280static inline void wbc_attach_fdatawrite_inode(struct writeback_control *wbc,
281 struct inode *inode)
282{
283}
284
285static inline void wbc_detach_inode(struct writeback_control *wbc)
286{
287}
288
289static inline void wbc_init_bio(struct writeback_control *wbc, struct bio *bio)
290{
291}
292
293static inline void wbc_account_io(struct writeback_control *wbc,
294 struct page *page, size_t bytes)
295{
296}
297
298static inline void cgroup_writeback_umount(void)
299{
300}
301
302#endif
303
304
305
306
307#ifdef CONFIG_BLOCK
308void laptop_io_completion(struct backing_dev_info *info);
309void laptop_sync_completion(void);
310void laptop_mode_sync(struct work_struct *work);
311void laptop_mode_timer_fn(struct timer_list *t);
312#else
313static inline void laptop_sync_completion(void) { }
314#endif
315bool node_dirty_ok(struct pglist_data *pgdat);
316int wb_domain_init(struct wb_domain *dom, gfp_t gfp);
317#ifdef CONFIG_CGROUP_WRITEBACK
318void wb_domain_exit(struct wb_domain *dom);
319#endif
320
321extern struct wb_domain global_wb_domain;
322
323
324extern int dirty_background_ratio;
325extern unsigned long dirty_background_bytes;
326extern int vm_dirty_ratio;
327extern unsigned long vm_dirty_bytes;
328extern unsigned int dirty_writeback_interval;
329extern unsigned int dirty_expire_interval;
330extern unsigned int dirtytime_expire_interval;
331extern int vm_highmem_is_dirtyable;
332extern int block_dump;
333extern int laptop_mode;
334
335extern int dirty_background_ratio_handler(struct ctl_table *table, int write,
336 void __user *buffer, size_t *lenp,
337 loff_t *ppos);
338extern int dirty_background_bytes_handler(struct ctl_table *table, int write,
339 void __user *buffer, size_t *lenp,
340 loff_t *ppos);
341extern int dirty_ratio_handler(struct ctl_table *table, int write,
342 void __user *buffer, size_t *lenp,
343 loff_t *ppos);
344extern int dirty_bytes_handler(struct ctl_table *table, int write,
345 void __user *buffer, size_t *lenp,
346 loff_t *ppos);
347int dirtytime_interval_handler(struct ctl_table *table, int write,
348 void __user *buffer, size_t *lenp, loff_t *ppos);
349
350struct ctl_table;
351int dirty_writeback_centisecs_handler(struct ctl_table *, int,
352 void __user *, size_t *, loff_t *);
353
354void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty);
355unsigned long wb_calc_thresh(struct bdi_writeback *wb, unsigned long thresh);
356
357void wb_update_bandwidth(struct bdi_writeback *wb, unsigned long start_time);
358void balance_dirty_pages_ratelimited(struct address_space *mapping);
359bool wb_over_bg_thresh(struct bdi_writeback *wb);
360
361typedef int (*writepage_t)(struct page *page, struct writeback_control *wbc,
362 void *data);
363
364int generic_writepages(struct address_space *mapping,
365 struct writeback_control *wbc);
366void tag_pages_for_writeback(struct address_space *mapping,
367 pgoff_t start, pgoff_t end);
368int write_cache_pages(struct address_space *mapping,
369 struct writeback_control *wbc, writepage_t writepage,
370 void *data);
371int do_writepages(struct address_space *mapping, struct writeback_control *wbc);
372void writeback_set_ratelimit(void);
373void tag_pages_for_writeback(struct address_space *mapping,
374 pgoff_t start, pgoff_t end);
375
376void account_page_redirty(struct page *page);
377
378void sb_mark_inode_writeback(struct inode *inode);
379void sb_clear_inode_writeback(struct inode *inode);
380
381#endif
382