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