Branch data Line data Source code
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 : 516 : 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, int page_mkwrite);
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 */
|
