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> |
Jens Axboe | f5ff842 | 2007-09-21 09:19:54 +0200 | [diff] [blame] | 8 | #include <linux/fs.h> |
Alexey Dobriyan | e8edc6e | 2007-05-21 01:22:52 +0400 | [diff] [blame] | 9 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | struct backing_dev_info; |
| 11 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | * fs/fs-writeback.c |
| 14 | */ |
| 15 | enum writeback_sync_modes { |
| 16 | WB_SYNC_NONE, /* Don't wait on anything */ |
| 17 | WB_SYNC_ALL, /* Wait on every mapping */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | }; |
| 19 | |
| 20 | /* |
| 21 | * A control structure which tells the writeback code what to do. These are |
| 22 | * always on the stack, and hence need no locking. They are always initialised |
| 23 | * in a manner such that unspecified fields are set to zero. |
| 24 | */ |
| 25 | struct writeback_control { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | enum writeback_sync_modes sync_mode; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | long nr_to_write; /* Write this many pages, and decrement |
| 28 | this for each page written */ |
| 29 | long pages_skipped; /* Pages which were not written */ |
| 30 | |
| 31 | /* |
| 32 | * For a_ops->writepages(): is start or end are non-zero then this is |
| 33 | * a hint that the filesystem need only write out the pages inside that |
| 34 | * byterange. The byte at `end' is included in the writeout request. |
| 35 | */ |
OGAWA Hirofumi | 111ebb6 | 2006-06-23 02:03:26 -0700 | [diff] [blame] | 36 | loff_t range_start; |
| 37 | loff_t range_end; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | |
Andrew Morton | 22905f7 | 2005-11-16 15:07:01 -0800 | [diff] [blame] | 39 | unsigned for_kupdate:1; /* A kupdate writeback */ |
Wu Fengguang | b17621f | 2009-12-03 13:54:25 +0100 | [diff] [blame] | 40 | unsigned for_background:1; /* A background writeback */ |
Wu Fengguang | 6e6938b | 2010-06-06 10:38:15 -0600 | [diff] [blame] | 41 | unsigned tagged_writepages:1; /* tag-and-write to avoid livelock */ |
Andrew Morton | 22905f7 | 2005-11-16 15:07:01 -0800 | [diff] [blame] | 42 | unsigned for_reclaim:1; /* Invoked from the page allocator */ |
OGAWA Hirofumi | 111ebb6 | 2006-06-23 02:03:26 -0700 | [diff] [blame] | 43 | unsigned range_cyclic:1; /* range_start is cyclic */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | }; |
| 45 | |
| 46 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | * fs/fs-writeback.c |
| 48 | */ |
Jens Axboe | 03ba378 | 2009-09-09 09:08:54 +0200 | [diff] [blame] | 49 | struct bdi_writeback; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | int inode_wait(void *); |
Jens Axboe | b6e5131 | 2009-09-16 15:13:54 +0200 | [diff] [blame] | 51 | void writeback_inodes_sb(struct super_block *); |
Chris Mason | 3259f8b | 2010-10-29 11:16:17 -0400 | [diff] [blame] | 52 | void writeback_inodes_sb_nr(struct super_block *, unsigned long nr); |
Eric Sandeen | 17bd55d | 2009-12-23 07:57:07 -0500 | [diff] [blame] | 53 | int writeback_inodes_sb_if_idle(struct super_block *); |
Chris Mason | 3259f8b | 2010-10-29 11:16:17 -0400 | [diff] [blame] | 54 | int writeback_inodes_sb_nr_if_idle(struct super_block *, unsigned long nr); |
Jens Axboe | b6e5131 | 2009-09-16 15:13:54 +0200 | [diff] [blame] | 55 | void sync_inodes_sb(struct super_block *); |
Wu Fengguang | d46db3d | 2011-05-04 19:54:37 -0600 | [diff] [blame] | 56 | long writeback_inodes_wb(struct bdi_writeback *wb, long nr_pages); |
Jens Axboe | 03ba378 | 2009-09-09 09:08:54 +0200 | [diff] [blame] | 57 | long wb_do_writeback(struct bdi_writeback *wb, int force_wait); |
| 58 | void wakeup_flusher_threads(long nr_pages); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 59 | |
| 60 | /* writeback.h requires fs.h; it, too, is not included from here. */ |
| 61 | static inline void wait_on_inode(struct inode *inode) |
| 62 | { |
| 63 | might_sleep(); |
Christoph Hellwig | eaff807 | 2009-12-17 14:25:01 +0100 | [diff] [blame] | 64 | wait_on_bit(&inode->i_state, __I_NEW, inode_wait, TASK_UNINTERRUPTIBLE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | } |
Joern Engel | 1c0eeaf | 2007-10-16 23:30:44 -0700 | [diff] [blame] | 66 | static inline void inode_sync_wait(struct inode *inode) |
| 67 | { |
| 68 | might_sleep(); |
| 69 | wait_on_bit(&inode->i_state, __I_SYNC, inode_wait, |
| 70 | TASK_UNINTERRUPTIBLE); |
| 71 | } |
| 72 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | |
| 74 | /* |
| 75 | * mm/page-writeback.c |
| 76 | */ |
Jens Axboe | c2c4986 | 2010-05-20 09:18:47 +0200 | [diff] [blame] | 77 | #ifdef CONFIG_BLOCK |
Matthew Garrett | 31373d0 | 2010-04-06 14:25:14 +0200 | [diff] [blame] | 78 | void laptop_io_completion(struct backing_dev_info *info); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | void laptop_sync_completion(void); |
Matthew Garrett | 31373d0 | 2010-04-06 14:25:14 +0200 | [diff] [blame] | 80 | void laptop_mode_sync(struct work_struct *work); |
| 81 | void laptop_mode_timer_fn(unsigned long data); |
Jens Axboe | c2c4986 | 2010-05-20 09:18:47 +0200 | [diff] [blame] | 82 | #else |
| 83 | static inline void laptop_sync_completion(void) { } |
| 84 | #endif |
Andrew Morton | 232ea4d | 2007-02-28 20:13:21 -0800 | [diff] [blame] | 85 | void throttle_vm_writeout(gfp_t gfp_mask); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 86 | |
Wu Fengguang | c42843f | 2011-03-02 15:54:09 -0600 | [diff] [blame^] | 87 | extern unsigned long global_dirty_limit; |
| 88 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | /* These are exported to sysctl. */ |
| 90 | extern int dirty_background_ratio; |
David Rientjes | 2da0299 | 2009-01-06 14:39:31 -0800 | [diff] [blame] | 91 | extern unsigned long dirty_background_bytes; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 92 | extern int vm_dirty_ratio; |
David Rientjes | 2da0299 | 2009-01-06 14:39:31 -0800 | [diff] [blame] | 93 | extern unsigned long vm_dirty_bytes; |
Alexey Dobriyan | 704503d | 2009-03-31 15:23:18 -0700 | [diff] [blame] | 94 | extern unsigned int dirty_writeback_interval; |
| 95 | extern unsigned int dirty_expire_interval; |
Bron Gondwana | 195cf453 | 2008-02-04 22:29:20 -0800 | [diff] [blame] | 96 | extern int vm_highmem_is_dirtyable; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | extern int block_dump; |
| 98 | extern int laptop_mode; |
| 99 | |
Steven Rostedt | 3eefae9 | 2008-05-12 21:21:04 +0200 | [diff] [blame] | 100 | extern unsigned long determine_dirtyable_memory(void); |
| 101 | |
David Rientjes | 2da0299 | 2009-01-06 14:39:31 -0800 | [diff] [blame] | 102 | extern int dirty_background_ratio_handler(struct ctl_table *table, int write, |
Alexey Dobriyan | 8d65af7 | 2009-09-23 15:57:19 -0700 | [diff] [blame] | 103 | void __user *buffer, size_t *lenp, |
David Rientjes | 2da0299 | 2009-01-06 14:39:31 -0800 | [diff] [blame] | 104 | loff_t *ppos); |
| 105 | extern int dirty_background_bytes_handler(struct ctl_table *table, int write, |
Alexey Dobriyan | 8d65af7 | 2009-09-23 15:57:19 -0700 | [diff] [blame] | 106 | void __user *buffer, size_t *lenp, |
David Rientjes | 2da0299 | 2009-01-06 14:39:31 -0800 | [diff] [blame] | 107 | loff_t *ppos); |
Peter Zijlstra | 04fbfdc | 2007-10-16 23:25:50 -0700 | [diff] [blame] | 108 | extern int dirty_ratio_handler(struct ctl_table *table, int write, |
Alexey Dobriyan | 8d65af7 | 2009-09-23 15:57:19 -0700 | [diff] [blame] | 109 | void __user *buffer, size_t *lenp, |
Peter Zijlstra | 04fbfdc | 2007-10-16 23:25:50 -0700 | [diff] [blame] | 110 | loff_t *ppos); |
David Rientjes | 2da0299 | 2009-01-06 14:39:31 -0800 | [diff] [blame] | 111 | extern int dirty_bytes_handler(struct ctl_table *table, int write, |
Alexey Dobriyan | 8d65af7 | 2009-09-23 15:57:19 -0700 | [diff] [blame] | 112 | void __user *buffer, size_t *lenp, |
David Rientjes | 2da0299 | 2009-01-06 14:39:31 -0800 | [diff] [blame] | 113 | loff_t *ppos); |
Peter Zijlstra | 04fbfdc | 2007-10-16 23:25:50 -0700 | [diff] [blame] | 114 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | struct ctl_table; |
Alexey Dobriyan | 8d65af7 | 2009-09-23 15:57:19 -0700 | [diff] [blame] | 116 | int dirty_writeback_centisecs_handler(struct ctl_table *, int, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | void __user *, size_t *, loff_t *); |
| 118 | |
Wu Fengguang | 16c4042 | 2010-08-11 14:17:39 -0700 | [diff] [blame] | 119 | void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty); |
| 120 | unsigned long bdi_dirty_limit(struct backing_dev_info *bdi, |
| 121 | unsigned long dirty); |
Peter Zijlstra | cf0ca9f | 2008-04-30 00:54:32 -0700 | [diff] [blame] | 122 | |
Wu Fengguang | e98be2d | 2010-08-29 11:22:30 -0600 | [diff] [blame] | 123 | void __bdi_update_bandwidth(struct backing_dev_info *bdi, |
Wu Fengguang | c42843f | 2011-03-02 15:54:09 -0600 | [diff] [blame^] | 124 | unsigned long thresh, |
| 125 | unsigned long dirty, |
| 126 | unsigned long bdi_thresh, |
| 127 | unsigned long bdi_dirty, |
Wu Fengguang | e98be2d | 2010-08-29 11:22:30 -0600 | [diff] [blame] | 128 | unsigned long start_time); |
| 129 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | void page_writeback_init(void); |
Andrew Morton | fa5a734 | 2006-03-24 03:18:10 -0800 | [diff] [blame] | 131 | void balance_dirty_pages_ratelimited_nr(struct address_space *mapping, |
| 132 | unsigned long nr_pages_dirtied); |
| 133 | |
| 134 | static inline void |
| 135 | balance_dirty_pages_ratelimited(struct address_space *mapping) |
| 136 | { |
| 137 | balance_dirty_pages_ratelimited_nr(mapping, 1); |
| 138 | } |
| 139 | |
Miklos Szeredi | 0ea9718 | 2007-05-10 22:22:51 -0700 | [diff] [blame] | 140 | typedef int (*writepage_t)(struct page *page, struct writeback_control *wbc, |
| 141 | void *data); |
| 142 | |
Miklos Szeredi | 0ea9718 | 2007-05-10 22:22:51 -0700 | [diff] [blame] | 143 | int generic_writepages(struct address_space *mapping, |
| 144 | struct writeback_control *wbc); |
Eric Sandeen | 5b41d92 | 2010-10-27 21:30:13 -0400 | [diff] [blame] | 145 | void tag_pages_for_writeback(struct address_space *mapping, |
| 146 | pgoff_t start, pgoff_t end); |
Miklos Szeredi | 0ea9718 | 2007-05-10 22:22:51 -0700 | [diff] [blame] | 147 | int write_cache_pages(struct address_space *mapping, |
| 148 | struct writeback_control *wbc, writepage_t writepage, |
| 149 | void *data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | int do_writepages(struct address_space *mapping, struct writeback_control *wbc); |
Peter Zijlstra | a200ee1 | 2007-10-08 18:54:37 +0200 | [diff] [blame] | 151 | void set_page_dirty_balance(struct page *page, int page_mkwrite); |
Chandra Seetharaman | 2d1d43f | 2006-09-29 02:01:25 -0700 | [diff] [blame] | 152 | void writeback_set_ratelimit(void); |
Namhyung Kim | 92c09c0 | 2010-10-26 14:22:03 -0700 | [diff] [blame] | 153 | void tag_pages_for_writeback(struct address_space *mapping, |
| 154 | pgoff_t start, pgoff_t end); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 155 | |
| 156 | /* pdflush.c */ |
| 157 | extern int nr_pdflush_threads; /* Global so it can be exported to sysctl |
| 158 | read-only. */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | |
| 160 | |
| 161 | #endif /* WRITEBACK_H */ |