| 1 | /* |
| 2 | * include/linux/writeback.h |
| 3 | */ |
| 4 | #ifndef WRITEBACK_H |
| 5 | #define WRITEBACK_H |
| 6 | |
| 7 | #include <linux/sched.h> |
| 8 | #include <linux/workqueue.h> |
| 9 | #include <linux/fs.h> |
| 10 | |
| 11 | DECLARE_PER_CPU(int, dirty_throttle_leaks); |
| 12 | |
| 13 | /* |
| 14 | * The 1/4 region under the global dirty thresh is for smooth dirty throttling: |
| 15 | * |
| 16 | * (thresh - thresh/DIRTY_FULL_SCOPE, thresh) |
| 17 | * |
| 18 | * Further beyond, all dirtier tasks will enter a loop waiting (possibly long |
| 19 | * time) for the dirty pages to drop, unless written enough pages. |
| 20 | * |
| 21 | * The global dirty threshold is normally equal to the global dirty limit, |
| 22 | * except when the system suddenly allocates a lot of anonymous memory and |
| 23 | * knocks down the global dirty threshold quickly, in which case the global |
| 24 | * dirty limit will follow down slowly to prevent livelocking all dirtier tasks. |
| 25 | */ |
| 26 | #define DIRTY_SCOPE 8 |
| 27 | #define DIRTY_FULL_SCOPE (DIRTY_SCOPE / 2) |
| 28 | |
| 29 | struct backing_dev_info; |
| 30 | |
| 31 | /* |
| 32 | * fs/fs-writeback.c |
| 33 | */ |
| 34 | enum writeback_sync_modes { |
| 35 | WB_SYNC_NONE, /* Don't wait on anything */ |
| 36 | WB_SYNC_ALL, /* Wait on every mapping */ |
| 37 | }; |
| 38 | |
| 39 | /* |
| 40 | * why some writeback work was initiated |
| 41 | */ |
| 42 | enum wb_reason { |
| 43 | WB_REASON_BACKGROUND, |
| 44 | WB_REASON_TRY_TO_FREE_PAGES, |
| 45 | WB_REASON_SYNC, |
| 46 | WB_REASON_PERIODIC, |
| 47 | WB_REASON_LAPTOP_TIMER, |
| 48 | WB_REASON_FREE_MORE_MEM, |
| 49 | WB_REASON_FS_FREE_SPACE, |
| 50 | /* |
| 51 | * There is no bdi forker thread any more and works are done |
| 52 | * by emergency worker, however, this is TPs userland visible |
| 53 | * and we'll be exposing exactly the same information, |
| 54 | * so it has a mismatch name. |
| 55 | */ |
| 56 | WB_REASON_FORKER_THREAD, |
| 57 | |
| 58 | WB_REASON_MAX, |
| 59 | }; |
| 60 | |
| 61 | /* |
| 62 | * A control structure which tells the writeback code what to do. These are |
| 63 | * always on the stack, and hence need no locking. They are always initialised |
| 64 | * in a manner such that unspecified fields are set to zero. |
| 65 | */ |
| 66 | struct writeback_control { |
| 67 | long nr_to_write; /* Write this many pages, and decrement |
| 68 | this for each page written */ |
| 69 | long pages_skipped; /* Pages which were not written */ |
| 70 | |
| 71 | /* |
| 72 | * For a_ops->writepages(): if start or end are non-zero then this is |
| 73 | * a hint that the filesystem need only write out the pages inside that |
| 74 | * byterange. The byte at `end' is included in the writeout request. |
| 75 | */ |
| 76 | loff_t range_start; |
| 77 | loff_t range_end; |
| 78 | |
| 79 | enum writeback_sync_modes sync_mode; |
| 80 | |
| 81 | unsigned for_kupdate:1; /* A kupdate writeback */ |
| 82 | unsigned for_background:1; /* A background writeback */ |
| 83 | unsigned tagged_writepages:1; /* tag-and-write to avoid livelock */ |
| 84 | unsigned for_reclaim:1; /* Invoked from the page allocator */ |
| 85 | unsigned range_cyclic:1; /* range_start is cyclic */ |
| 86 | unsigned for_sync:1; /* sync(2) WB_SYNC_ALL writeback */ |
| 87 | }; |
| 88 | |
| 89 | /* |
| 90 | * fs/fs-writeback.c |
| 91 | */ |
| 92 | struct bdi_writeback; |
| 93 | int inode_wait(void *); |
| 94 | void writeback_inodes_sb(struct super_block *, enum wb_reason reason); |
| 95 | void writeback_inodes_sb_nr(struct super_block *, unsigned long nr, |
| 96 | enum wb_reason reason); |
| 97 | int try_to_writeback_inodes_sb(struct super_block *, enum wb_reason reason); |
| 98 | int try_to_writeback_inodes_sb_nr(struct super_block *, unsigned long nr, |
| 99 | enum wb_reason reason); |
| 100 | void sync_inodes_sb(struct super_block *); |
| 101 | void wakeup_flusher_threads(long nr_pages, enum wb_reason reason); |
| 102 | void inode_wait_for_writeback(struct inode *inode); |
| 103 | |
| 104 | /* writeback.h requires fs.h; it, too, is not included from here. */ |
| 105 | static inline void wait_on_inode(struct inode *inode) |
| 106 | { |
| 107 | might_sleep(); |
| 108 | wait_on_bit(&inode->i_state, __I_NEW, inode_wait, TASK_UNINTERRUPTIBLE); |
| 109 | } |
| 110 | |
| 111 | /* |
| 112 | * mm/page-writeback.c |
| 113 | */ |
| 114 | #ifdef CONFIG_BLOCK |
| 115 | void laptop_io_completion(struct backing_dev_info *info); |
| 116 | void laptop_sync_completion(void); |
| 117 | void laptop_mode_sync(struct work_struct *work); |
| 118 | void laptop_mode_timer_fn(unsigned long data); |
| 119 | #else |
| 120 | static inline void laptop_sync_completion(void) { } |
| 121 | #endif |
| 122 | void throttle_vm_writeout(gfp_t gfp_mask); |
| 123 | bool zone_dirty_ok(struct zone *zone); |
| 124 | |
| 125 | extern unsigned long global_dirty_limit; |
| 126 | |
| 127 | /* These are exported to sysctl. */ |
| 128 | extern int dirty_background_ratio; |
| 129 | extern unsigned long dirty_background_bytes; |
| 130 | extern int vm_dirty_ratio; |
| 131 | extern unsigned long vm_dirty_bytes; |
| 132 | extern unsigned int dirty_writeback_interval; |
| 133 | extern unsigned int dirty_expire_interval; |
| 134 | extern int vm_highmem_is_dirtyable; |
| 135 | extern int block_dump; |
| 136 | extern int laptop_mode; |
| 137 | |
| 138 | extern int dirty_background_ratio_handler(struct ctl_table *table, int write, |
| 139 | void __user *buffer, size_t *lenp, |
| 140 | loff_t *ppos); |
| 141 | extern int dirty_background_bytes_handler(struct ctl_table *table, int write, |
| 142 | void __user *buffer, size_t *lenp, |
| 143 | loff_t *ppos); |
| 144 | extern int dirty_ratio_handler(struct ctl_table *table, int write, |
| 145 | void __user *buffer, size_t *lenp, |
| 146 | loff_t *ppos); |
| 147 | extern int dirty_bytes_handler(struct ctl_table *table, int write, |
| 148 | void __user *buffer, size_t *lenp, |
| 149 | loff_t *ppos); |
| 150 | |
| 151 | struct ctl_table; |
| 152 | int dirty_writeback_centisecs_handler(struct ctl_table *, int, |
| 153 | void __user *, size_t *, loff_t *); |
| 154 | |
| 155 | void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty); |
| 156 | unsigned long bdi_dirty_limit(struct backing_dev_info *bdi, |
| 157 | unsigned long dirty); |
| 158 | |
| 159 | void __bdi_update_bandwidth(struct backing_dev_info *bdi, |
| 160 | unsigned long thresh, |
| 161 | unsigned long bg_thresh, |
| 162 | unsigned long dirty, |
| 163 | unsigned long bdi_thresh, |
| 164 | unsigned long bdi_dirty, |
| 165 | unsigned long start_time); |
| 166 | |
| 167 | void page_writeback_init(void); |
| 168 | void balance_dirty_pages_ratelimited(struct address_space *mapping); |
| 169 | |
| 170 | typedef int (*writepage_t)(struct page *page, struct writeback_control *wbc, |
| 171 | void *data); |
| 172 | |
| 173 | int generic_writepages(struct address_space *mapping, |
| 174 | struct writeback_control *wbc); |
| 175 | void tag_pages_for_writeback(struct address_space *mapping, |
| 176 | pgoff_t start, pgoff_t end); |
| 177 | int write_cache_pages(struct address_space *mapping, |
| 178 | struct writeback_control *wbc, writepage_t writepage, |
| 179 | void *data); |
| 180 | int do_writepages(struct address_space *mapping, struct writeback_control *wbc); |
| 181 | void set_page_dirty_balance(struct page *page); |
| 182 | void writeback_set_ratelimit(void); |
| 183 | void tag_pages_for_writeback(struct address_space *mapping, |
| 184 | pgoff_t start, pgoff_t end); |
| 185 | |
| 186 | void account_page_redirty(struct page *page); |
| 187 | |
| 188 | #endif /* WRITEBACK_H */ |