Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
f30c2269 | 2 | * include/linux/writeback.h |
1da177e4 LT |
3 | */ |
4 | #ifndef WRITEBACK_H | |
5 | #define WRITEBACK_H | |
6 | ||
e8edc6e0 | 7 | #include <linux/sched.h> |
a27bb332 | 8 | #include <linux/workqueue.h> |
f5ff8422 | 9 | #include <linux/fs.h> |
380c27ca | 10 | #include <linux/flex_proportions.h> |
21c6321f | 11 | #include <linux/backing-dev-defs.h> |
e8edc6e0 | 12 | |
2f8b5444 CH |
13 | struct bio; |
14 | ||
54848d73 WF |
15 | DECLARE_PER_CPU(int, dirty_throttle_leaks); |
16 | ||
ffd1f609 | 17 | /* |
1a12d8bd WF |
18 | * The 1/4 region under the global dirty thresh is for smooth dirty throttling: |
19 | * | |
20 | * (thresh - thresh/DIRTY_FULL_SCOPE, thresh) | |
21 | * | |
ffd1f609 WF |
22 | * Further beyond, all dirtier tasks will enter a loop waiting (possibly long |
23 | * time) for the dirty pages to drop, unless written enough pages. | |
24 | * | |
25 | * The global dirty threshold is normally equal to the global dirty limit, | |
26 | * except when the system suddenly allocates a lot of anonymous memory and | |
27 | * knocks down the global dirty threshold quickly, in which case the global | |
28 | * dirty limit will follow down slowly to prevent livelocking all dirtier tasks. | |
29 | */ | |
1a12d8bd WF |
30 | #define DIRTY_SCOPE 8 |
31 | #define DIRTY_FULL_SCOPE (DIRTY_SCOPE / 2) | |
ffd1f609 | 32 | |
1da177e4 LT |
33 | struct backing_dev_info; |
34 | ||
1da177e4 LT |
35 | /* |
36 | * fs/fs-writeback.c | |
37 | */ | |
38 | enum writeback_sync_modes { | |
39 | WB_SYNC_NONE, /* Don't wait on anything */ | |
40 | WB_SYNC_ALL, /* Wait on every mapping */ | |
1da177e4 LT |
41 | }; |
42 | ||
0e175a18 CW |
43 | /* |
44 | * why some writeback work was initiated | |
45 | */ | |
46 | enum wb_reason { | |
47 | WB_REASON_BACKGROUND, | |
48 | WB_REASON_TRY_TO_FREE_PAGES, | |
49 | WB_REASON_SYNC, | |
50 | WB_REASON_PERIODIC, | |
51 | WB_REASON_LAPTOP_TIMER, | |
52 | WB_REASON_FREE_MORE_MEM, | |
53 | WB_REASON_FS_FREE_SPACE, | |
fc6df808 WL |
54 | /* |
55 | * There is no bdi forker thread any more and works are done | |
56 | * by emergency worker, however, this is TPs userland visible | |
57 | * and we'll be exposing exactly the same information, | |
58 | * so it has a mismatch name. | |
59 | */ | |
0e175a18 CW |
60 | WB_REASON_FORKER_THREAD, |
61 | ||
62 | WB_REASON_MAX, | |
63 | }; | |
0e175a18 | 64 | |
1da177e4 LT |
65 | /* |
66 | * A control structure which tells the writeback code what to do. These are | |
67 | * always on the stack, and hence need no locking. They are always initialised | |
68 | * in a manner such that unspecified fields are set to zero. | |
69 | */ | |
70 | struct writeback_control { | |
1da177e4 LT |
71 | long nr_to_write; /* Write this many pages, and decrement |
72 | this for each page written */ | |
73 | long pages_skipped; /* Pages which were not written */ | |
74 | ||
75 | /* | |
95468fd4 | 76 | * For a_ops->writepages(): if start or end are non-zero then this is |
1da177e4 LT |
77 | * a hint that the filesystem need only write out the pages inside that |
78 | * byterange. The byte at `end' is included in the writeout request. | |
79 | */ | |
111ebb6e OH |
80 | loff_t range_start; |
81 | loff_t range_end; | |
1da177e4 | 82 | |
4cd9069a RK |
83 | enum writeback_sync_modes sync_mode; |
84 | ||
22905f77 | 85 | unsigned for_kupdate:1; /* A kupdate writeback */ |
b17621fe | 86 | unsigned for_background:1; /* A background writeback */ |
6e6938b6 | 87 | unsigned tagged_writepages:1; /* tag-and-write to avoid livelock */ |
22905f77 | 88 | unsigned for_reclaim:1; /* Invoked from the page allocator */ |
111ebb6e | 89 | unsigned range_cyclic:1; /* range_start is cyclic */ |
7747bd4b | 90 | unsigned for_sync:1; /* sync(2) WB_SYNC_ALL writeback */ |
b16b1deb TH |
91 | #ifdef CONFIG_CGROUP_WRITEBACK |
92 | struct bdi_writeback *wb; /* wb this writeback is issued under */ | |
2a814908 TH |
93 | struct inode *inode; /* inode being written out */ |
94 | ||
95 | /* foreign inode detection, see wbc_detach_inode() */ | |
96 | int wb_id; /* current wb id */ | |
97 | int wb_lcand_id; /* last foreign candidate wb id */ | |
98 | int wb_tcand_id; /* this foreign candidate wb id */ | |
99 | size_t wb_bytes; /* bytes written by current wb */ | |
100 | size_t wb_lcand_bytes; /* bytes written by last candidate */ | |
101 | size_t wb_tcand_bytes; /* bytes written by this candidate */ | |
b16b1deb | 102 | #endif |
1da177e4 LT |
103 | }; |
104 | ||
380c27ca TH |
105 | /* |
106 | * A wb_domain represents a domain that wb's (bdi_writeback's) belong to | |
107 | * and are measured against each other in. There always is one global | |
108 | * domain, global_wb_domain, that every wb in the system is a member of. | |
109 | * This allows measuring the relative bandwidth of each wb to distribute | |
110 | * dirtyable memory accordingly. | |
111 | */ | |
112 | struct wb_domain { | |
dcc25ae7 TH |
113 | spinlock_t lock; |
114 | ||
380c27ca TH |
115 | /* |
116 | * Scale the writeback cache size proportional to the relative | |
117 | * writeout speed. | |
118 | * | |
119 | * We do this by keeping a floating proportion between BDIs, based | |
120 | * on page writeback completions [end_page_writeback()]. Those | |
121 | * devices that write out pages fastest will get the larger share, | |
122 | * while the slower will get a smaller share. | |
123 | * | |
124 | * We use page writeout completions because we are interested in | |
125 | * getting rid of dirty pages. Having them written out is the | |
126 | * primary goal. | |
127 | * | |
128 | * We introduce a concept of time, a period over which we measure | |
129 | * these events, because demand can/will vary over time. The length | |
130 | * of this period itself is measured in page writeback completions. | |
131 | */ | |
132 | struct fprop_global completions; | |
133 | struct timer_list period_timer; /* timer for aging of completions */ | |
134 | unsigned long period_time; | |
dcc25ae7 TH |
135 | |
136 | /* | |
137 | * The dirtyable memory and dirty threshold could be suddenly | |
138 | * knocked down by a large amount (eg. on the startup of KVM in a | |
139 | * swapless system). This may throw the system into deep dirty | |
140 | * exceeded state and throttle heavy/light dirtiers alike. To | |
141 | * retain good responsiveness, maintain global_dirty_limit for | |
142 | * tracking slowly down to the knocked down dirty threshold. | |
143 | * | |
144 | * Both fields are protected by ->lock. | |
145 | */ | |
146 | unsigned long dirty_limit_tstamp; | |
147 | unsigned long dirty_limit; | |
380c27ca TH |
148 | }; |
149 | ||
2529bb3a TH |
150 | /** |
151 | * wb_domain_size_changed - memory available to a wb_domain has changed | |
152 | * @dom: wb_domain of interest | |
153 | * | |
154 | * This function should be called when the amount of memory available to | |
155 | * @dom has changed. It resets @dom's dirty limit parameters to prevent | |
156 | * the past values which don't match the current configuration from skewing | |
157 | * dirty throttling. Without this, when memory size of a wb_domain is | |
158 | * greatly reduced, the dirty throttling logic may allow too many pages to | |
159 | * be dirtied leading to consecutive unnecessary OOMs and may get stuck in | |
160 | * that situation. | |
161 | */ | |
162 | static inline void wb_domain_size_changed(struct wb_domain *dom) | |
163 | { | |
164 | spin_lock(&dom->lock); | |
165 | dom->dirty_limit_tstamp = jiffies; | |
166 | dom->dirty_limit = 0; | |
167 | spin_unlock(&dom->lock); | |
168 | } | |
169 | ||
1da177e4 LT |
170 | /* |
171 | * fs/fs-writeback.c | |
172 | */ | |
03ba3782 | 173 | struct bdi_writeback; |
0e175a18 CW |
174 | void writeback_inodes_sb(struct super_block *, enum wb_reason reason); |
175 | void writeback_inodes_sb_nr(struct super_block *, unsigned long nr, | |
176 | enum wb_reason reason); | |
f30a7d0c TH |
177 | bool try_to_writeback_inodes_sb(struct super_block *, enum wb_reason reason); |
178 | bool try_to_writeback_inodes_sb_nr(struct super_block *, unsigned long nr, | |
179 | enum wb_reason reason); | |
0dc83bd3 | 180 | void sync_inodes_sb(struct super_block *); |
0e175a18 | 181 | void wakeup_flusher_threads(long nr_pages, enum wb_reason reason); |
169ebd90 | 182 | void inode_wait_for_writeback(struct inode *inode); |
1da177e4 LT |
183 | |
184 | /* writeback.h requires fs.h; it, too, is not included from here. */ | |
185 | static inline void wait_on_inode(struct inode *inode) | |
186 | { | |
187 | might_sleep(); | |
74316201 | 188 | wait_on_bit(&inode->i_state, __I_NEW, TASK_UNINTERRUPTIBLE); |
1da177e4 | 189 | } |
1c0eeaf5 | 190 | |
21c6321f TH |
191 | #ifdef CONFIG_CGROUP_WRITEBACK |
192 | ||
b16b1deb TH |
193 | #include <linux/cgroup.h> |
194 | #include <linux/bio.h> | |
195 | ||
21c6321f | 196 | void __inode_attach_wb(struct inode *inode, struct page *page); |
b16b1deb TH |
197 | void wbc_attach_and_unlock_inode(struct writeback_control *wbc, |
198 | struct inode *inode) | |
199 | __releases(&inode->i_lock); | |
200 | void wbc_detach_inode(struct writeback_control *wbc); | |
2a814908 TH |
201 | void wbc_account_io(struct writeback_control *wbc, struct page *page, |
202 | size_t bytes); | |
a1a0e23e | 203 | void cgroup_writeback_umount(void); |
21c6321f TH |
204 | |
205 | /** | |
206 | * inode_attach_wb - associate an inode with its wb | |
207 | * @inode: inode of interest | |
208 | * @page: page being dirtied (may be NULL) | |
209 | * | |
210 | * If @inode doesn't have its wb, associate it with the wb matching the | |
211 | * memcg of @page or, if @page is NULL, %current. May be called w/ or w/o | |
212 | * @inode->i_lock. | |
213 | */ | |
214 | static inline void inode_attach_wb(struct inode *inode, struct page *page) | |
215 | { | |
216 | if (!inode->i_wb) | |
217 | __inode_attach_wb(inode, page); | |
218 | } | |
219 | ||
220 | /** | |
221 | * inode_detach_wb - disassociate an inode from its wb | |
222 | * @inode: inode of interest | |
223 | * | |
224 | * @inode is being freed. Detach from its wb. | |
225 | */ | |
226 | static inline void inode_detach_wb(struct inode *inode) | |
227 | { | |
228 | if (inode->i_wb) { | |
229 | wb_put(inode->i_wb); | |
230 | inode->i_wb = NULL; | |
231 | } | |
232 | } | |
233 | ||
b16b1deb TH |
234 | /** |
235 | * wbc_attach_fdatawrite_inode - associate wbc and inode for fdatawrite | |
236 | * @wbc: writeback_control of interest | |
237 | * @inode: target inode | |
238 | * | |
239 | * This function is to be used by __filemap_fdatawrite_range(), which is an | |
240 | * alternative entry point into writeback code, and first ensures @inode is | |
241 | * associated with a bdi_writeback and attaches it to @wbc. | |
242 | */ | |
243 | static inline void wbc_attach_fdatawrite_inode(struct writeback_control *wbc, | |
244 | struct inode *inode) | |
245 | { | |
246 | spin_lock(&inode->i_lock); | |
247 | inode_attach_wb(inode, NULL); | |
248 | wbc_attach_and_unlock_inode(wbc, inode); | |
249 | } | |
250 | ||
251 | /** | |
252 | * wbc_init_bio - writeback specific initializtion of bio | |
253 | * @wbc: writeback_control for the writeback in progress | |
254 | * @bio: bio to be initialized | |
255 | * | |
256 | * @bio is a part of the writeback in progress controlled by @wbc. Perform | |
257 | * writeback specific initialization. This is used to apply the cgroup | |
258 | * writeback context. | |
259 | */ | |
260 | static inline void wbc_init_bio(struct writeback_control *wbc, struct bio *bio) | |
261 | { | |
262 | /* | |
263 | * pageout() path doesn't attach @wbc to the inode being written | |
264 | * out. This is intentional as we don't want the function to block | |
265 | * behind a slow cgroup. Ultimately, we want pageout() to kick off | |
266 | * regular writeback instead of writing things out itself. | |
267 | */ | |
268 | if (wbc->wb) | |
269 | bio_associate_blkcg(bio, wbc->wb->blkcg_css); | |
270 | } | |
271 | ||
21c6321f TH |
272 | #else /* CONFIG_CGROUP_WRITEBACK */ |
273 | ||
274 | static inline void inode_attach_wb(struct inode *inode, struct page *page) | |
275 | { | |
276 | } | |
277 | ||
278 | static inline void inode_detach_wb(struct inode *inode) | |
279 | { | |
280 | } | |
281 | ||
b16b1deb TH |
282 | static inline void wbc_attach_and_unlock_inode(struct writeback_control *wbc, |
283 | struct inode *inode) | |
284 | __releases(&inode->i_lock) | |
285 | { | |
286 | spin_unlock(&inode->i_lock); | |
287 | } | |
288 | ||
289 | static inline void wbc_attach_fdatawrite_inode(struct writeback_control *wbc, | |
290 | struct inode *inode) | |
291 | { | |
292 | } | |
293 | ||
294 | static inline void wbc_detach_inode(struct writeback_control *wbc) | |
295 | { | |
296 | } | |
297 | ||
298 | static inline void wbc_init_bio(struct writeback_control *wbc, struct bio *bio) | |
299 | { | |
300 | } | |
301 | ||
2a814908 TH |
302 | static inline void wbc_account_io(struct writeback_control *wbc, |
303 | struct page *page, size_t bytes) | |
304 | { | |
305 | } | |
306 | ||
a1a0e23e TH |
307 | static inline void cgroup_writeback_umount(void) |
308 | { | |
309 | } | |
310 | ||
21c6321f TH |
311 | #endif /* CONFIG_CGROUP_WRITEBACK */ |
312 | ||
1da177e4 LT |
313 | /* |
314 | * mm/page-writeback.c | |
315 | */ | |
c2c4986e | 316 | #ifdef CONFIG_BLOCK |
31373d09 | 317 | void laptop_io_completion(struct backing_dev_info *info); |
1da177e4 | 318 | void laptop_sync_completion(void); |
31373d09 MG |
319 | void laptop_mode_sync(struct work_struct *work); |
320 | void laptop_mode_timer_fn(unsigned long data); | |
c2c4986e JA |
321 | #else |
322 | static inline void laptop_sync_completion(void) { } | |
323 | #endif | |
281e3726 | 324 | bool node_dirty_ok(struct pglist_data *pgdat); |
380c27ca | 325 | int wb_domain_init(struct wb_domain *dom, gfp_t gfp); |
841710aa TH |
326 | #ifdef CONFIG_CGROUP_WRITEBACK |
327 | void wb_domain_exit(struct wb_domain *dom); | |
328 | #endif | |
1da177e4 | 329 | |
dcc25ae7 | 330 | extern struct wb_domain global_wb_domain; |
c42843f2 | 331 | |
1da177e4 LT |
332 | /* These are exported to sysctl. */ |
333 | extern int dirty_background_ratio; | |
2da02997 | 334 | extern unsigned long dirty_background_bytes; |
1da177e4 | 335 | extern int vm_dirty_ratio; |
2da02997 | 336 | extern unsigned long vm_dirty_bytes; |
704503d8 AD |
337 | extern unsigned int dirty_writeback_interval; |
338 | extern unsigned int dirty_expire_interval; | |
1efff914 | 339 | extern unsigned int dirtytime_expire_interval; |
195cf453 | 340 | extern int vm_highmem_is_dirtyable; |
1da177e4 LT |
341 | extern int block_dump; |
342 | extern int laptop_mode; | |
343 | ||
2da02997 | 344 | extern int dirty_background_ratio_handler(struct ctl_table *table, int write, |
8d65af78 | 345 | void __user *buffer, size_t *lenp, |
2da02997 DR |
346 | loff_t *ppos); |
347 | extern int dirty_background_bytes_handler(struct ctl_table *table, int write, | |
8d65af78 | 348 | void __user *buffer, size_t *lenp, |
2da02997 | 349 | loff_t *ppos); |
04fbfdc1 | 350 | extern int dirty_ratio_handler(struct ctl_table *table, int write, |
8d65af78 | 351 | void __user *buffer, size_t *lenp, |
04fbfdc1 | 352 | loff_t *ppos); |
2da02997 | 353 | extern int dirty_bytes_handler(struct ctl_table *table, int write, |
8d65af78 | 354 | void __user *buffer, size_t *lenp, |
2da02997 | 355 | loff_t *ppos); |
1efff914 TT |
356 | int dirtytime_interval_handler(struct ctl_table *table, int write, |
357 | void __user *buffer, size_t *lenp, loff_t *ppos); | |
04fbfdc1 | 358 | |
1da177e4 | 359 | struct ctl_table; |
8d65af78 | 360 | int dirty_writeback_centisecs_handler(struct ctl_table *, int, |
1da177e4 LT |
361 | void __user *, size_t *, loff_t *); |
362 | ||
16c4042f | 363 | void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty); |
0d960a38 | 364 | unsigned long wb_calc_thresh(struct bdi_writeback *wb, unsigned long thresh); |
a88a341a | 365 | |
8a731799 | 366 | void wb_update_bandwidth(struct bdi_writeback *wb, unsigned long start_time); |
1da177e4 | 367 | void page_writeback_init(void); |
d0e1d66b | 368 | void balance_dirty_pages_ratelimited(struct address_space *mapping); |
aa661bbe | 369 | bool wb_over_bg_thresh(struct bdi_writeback *wb); |
fa5a734e | 370 | |
0ea97180 MS |
371 | typedef int (*writepage_t)(struct page *page, struct writeback_control *wbc, |
372 | void *data); | |
373 | ||
0ea97180 MS |
374 | int generic_writepages(struct address_space *mapping, |
375 | struct writeback_control *wbc); | |
5b41d924 ES |
376 | void tag_pages_for_writeback(struct address_space *mapping, |
377 | pgoff_t start, pgoff_t end); | |
0ea97180 MS |
378 | int write_cache_pages(struct address_space *mapping, |
379 | struct writeback_control *wbc, writepage_t writepage, | |
380 | void *data); | |
1da177e4 | 381 | int do_writepages(struct address_space *mapping, struct writeback_control *wbc); |
2d1d43f6 | 382 | void writeback_set_ratelimit(void); |
92c09c04 NK |
383 | void tag_pages_for_writeback(struct address_space *mapping, |
384 | pgoff_t start, pgoff_t end); | |
1da177e4 | 385 | |
2f800fbd WF |
386 | void account_page_redirty(struct page *page); |
387 | ||
6c60d2b5 DC |
388 | void sb_mark_inode_writeback(struct inode *inode); |
389 | void sb_clear_inode_writeback(struct inode *inode); | |
390 | ||
1da177e4 | 391 | #endif /* WRITEBACK_H */ |