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