Blame view
fs/fs-writeback.c
44.1 KB
1da177e4c
|
1 2 3 4 5 6 7 8 9 10 |
/* * fs/fs-writeback.c * * Copyright (C) 2002, Linus Torvalds. * * Contains all the functions related to writing back and waiting * upon dirty inodes against superblocks, and writing back dirty * pages against inodes. ie: data writeback. Writeout of the * inode itself is not handled here. * |
e1f8e8744
|
11 |
* 10Apr2002 Andrew Morton |
1da177e4c
|
12 13 14 15 16 |
* Split out of fs/inode.c * Additions for address_space-based writeback */ #include <linux/kernel.h> |
630d9c472
|
17 |
#include <linux/export.h> |
1da177e4c
|
18 |
#include <linux/spinlock.h> |
5a0e3ad6a
|
19 |
#include <linux/slab.h> |
1da177e4c
|
20 21 22 |
#include <linux/sched.h> #include <linux/fs.h> #include <linux/mm.h> |
bc31b86a5
|
23 |
#include <linux/pagemap.h> |
03ba3782e
|
24 |
#include <linux/kthread.h> |
1da177e4c
|
25 26 27 |
#include <linux/writeback.h> #include <linux/blkdev.h> #include <linux/backing-dev.h> |
455b28646
|
28 |
#include <linux/tracepoint.h> |
719ea2fbb
|
29 |
#include <linux/device.h> |
07f3f05c1
|
30 |
#include "internal.h" |
1da177e4c
|
31 |
|
d0bceac74
|
32 |
/* |
bc31b86a5
|
33 34 35 36 37 |
* 4MB minimal write chunk size */ #define MIN_WRITEBACK_PAGES (4096UL >> (PAGE_CACHE_SHIFT - 10)) /* |
c4a77a6c7
|
38 39 |
* Passed into wb_writeback(), essentially a subset of writeback_control */ |
83ba7b071
|
40 |
struct wb_writeback_work { |
c4a77a6c7
|
41 42 |
long nr_pages; struct super_block *sb; |
0dc83bd30
|
43 |
unsigned long *older_than_this; |
c4a77a6c7
|
44 |
enum writeback_sync_modes sync_mode; |
6e6938b6d
|
45 |
unsigned int tagged_writepages:1; |
52957fe1c
|
46 47 48 |
unsigned int for_kupdate:1; unsigned int range_cyclic:1; unsigned int for_background:1; |
7747bd4bc
|
49 |
unsigned int for_sync:1; /* sync(2) WB_SYNC_ALL writeback */ |
0e175a183
|
50 |
enum wb_reason reason; /* why was writeback initiated? */ |
c4a77a6c7
|
51 |
|
8010c3b63
|
52 |
struct list_head list; /* pending work list */ |
83ba7b071
|
53 |
struct completion *done; /* set if the caller waits */ |
03ba3782e
|
54 |
}; |
a2f487069
|
55 56 57 58 59 60 61 62 63 64 65 |
/* * If an inode is constantly having its pages dirtied, but then the * updates stop dirtytime_expire_interval seconds in the past, it's * possible for the worst case time between when an inode has its * timestamps updated and when they finally get written out to be two * dirtytime_expire_intervals. We set the default to 12 hours (in * seconds), which means most of the time inodes will have their * timestamps written to disk after 12 hours, but in the worst case a * few inodes might not their timestamps updated for 24 hours. */ unsigned int dirtytime_expire_interval = 12 * 60 * 60; |
f11b00f3b
|
66 67 68 69 |
/** * writeback_in_progress - determine whether there is writeback in progress * @bdi: the device's backing_dev_info structure. * |
03ba3782e
|
70 71 |
* Determine whether there is writeback waiting to be handled against a * backing device. |
f11b00f3b
|
72 73 74 |
*/ int writeback_in_progress(struct backing_dev_info *bdi) { |
81d73a32d
|
75 |
return test_bit(BDI_writeback_running, &bdi->state); |
f11b00f3b
|
76 |
} |
00d4e7362
|
77 |
EXPORT_SYMBOL(writeback_in_progress); |
f11b00f3b
|
78 |
|
de1414a65
|
79 |
struct backing_dev_info *inode_to_bdi(struct inode *inode) |
692ebd17c
|
80 |
{ |
b520252aa
|
81 82 83 84 85 86 |
struct super_block *sb; if (!inode) return &noop_backing_dev_info; sb = inode->i_sb; |
495a276e1
|
87 |
#ifdef CONFIG_BLOCK |
a8855990e
|
88 |
if (sb_is_blkdev_sb(sb)) |
495a276e1
|
89 90 |
return blk_get_backing_dev_info(I_BDEV(inode)); #endif |
aaead25b9
|
91 |
return sb->s_bdi; |
692ebd17c
|
92 |
} |
de1414a65
|
93 |
EXPORT_SYMBOL_GPL(inode_to_bdi); |
692ebd17c
|
94 |
|
7ccf19a80
|
95 96 97 98 |
static inline struct inode *wb_inode(struct list_head *head) { return list_entry(head, struct inode, i_wb_list); } |
15eb77a07
|
99 100 101 102 103 104 105 |
/* * Include the creation of the trace points after defining the * wb_writeback_work structure and inline functions so that the definition * remains local to this file. */ #define CREATE_TRACE_POINTS #include <trace/events/writeback.h> |
774016b2d
|
106 |
EXPORT_TRACEPOINT_SYMBOL_GPL(wbc_writepage); |
5acda9d12
|
107 108 109 110 111 112 113 |
static void bdi_wakeup_thread(struct backing_dev_info *bdi) { spin_lock_bh(&bdi->wb_lock); if (test_bit(BDI_registered, &bdi->state)) mod_delayed_work(bdi_wq, &bdi->wb.dwork, 0); spin_unlock_bh(&bdi->wb_lock); } |
6585027a5
|
114 115 116 117 118 119 |
static void bdi_queue_work(struct backing_dev_info *bdi, struct wb_writeback_work *work) { trace_writeback_queue(bdi, work); spin_lock_bh(&bdi->wb_lock); |
5acda9d12
|
120 121 122 123 124 |
if (!test_bit(BDI_registered, &bdi->state)) { if (work->done) complete(work->done); goto out_unlock; } |
6585027a5
|
125 |
list_add_tail(&work->list, &bdi->work_list); |
839a8e866
|
126 |
mod_delayed_work(bdi_wq, &bdi->wb.dwork, 0); |
5acda9d12
|
127 128 |
out_unlock: spin_unlock_bh(&bdi->wb_lock); |
1da177e4c
|
129 |
} |
83ba7b071
|
130 131 |
static void __bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages, |
0e175a183
|
132 |
bool range_cyclic, enum wb_reason reason) |
1da177e4c
|
133 |
{ |
83ba7b071
|
134 |
struct wb_writeback_work *work; |
03ba3782e
|
135 |
|
bcddc3f01
|
136 137 138 139 |
/* * This is WB_SYNC_NONE writeback, so if allocation fails just * wakeup the thread for old dirty data writeback */ |
83ba7b071
|
140 141 |
work = kzalloc(sizeof(*work), GFP_ATOMIC); if (!work) { |
839a8e866
|
142 |
trace_writeback_nowork(bdi); |
5acda9d12
|
143 |
bdi_wakeup_thread(bdi); |
83ba7b071
|
144 |
return; |
bcddc3f01
|
145 |
} |
03ba3782e
|
146 |
|
83ba7b071
|
147 148 149 |
work->sync_mode = WB_SYNC_NONE; work->nr_pages = nr_pages; work->range_cyclic = range_cyclic; |
0e175a183
|
150 |
work->reason = reason; |
03ba3782e
|
151 |
|
83ba7b071
|
152 |
bdi_queue_work(bdi, work); |
b6e51316d
|
153 154 155 156 157 158 |
} /** * bdi_start_writeback - start writeback * @bdi: the backing device to write from * @nr_pages: the number of pages to write |
786228ab3
|
159 |
* @reason: reason why some writeback work was initiated |
b6e51316d
|
160 161 162 |
* * Description: * This does WB_SYNC_NONE opportunistic writeback. The IO is only |
25985edce
|
163 |
* started when this function returns, we make no guarantees on |
0e3c9a228
|
164 |
* completion. Caller need not hold sb s_umount semaphore. |
b6e51316d
|
165 166 |
* */ |
0e175a183
|
167 168 |
void bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages, enum wb_reason reason) |
b6e51316d
|
169 |
{ |
0e175a183
|
170 |
__bdi_start_writeback(bdi, nr_pages, true, reason); |
c5444198c
|
171 |
} |
d3ddec763
|
172 |
|
c5444198c
|
173 174 175 176 177 |
/** * bdi_start_background_writeback - start background writeback * @bdi: the backing device to write from * * Description: |
6585027a5
|
178 179 180 181 |
* This makes sure WB_SYNC_NONE background writeback happens. When * this function returns, it is only guaranteed that for given BDI * some IO is happening if we are over background dirty threshold. * Caller need not hold sb s_umount semaphore. |
c5444198c
|
182 183 184 |
*/ void bdi_start_background_writeback(struct backing_dev_info *bdi) { |
6585027a5
|
185 186 187 188 |
/* * We just wake up the flusher thread. It will perform background * writeback as soon as there is no other work to do. */ |
71927e84e
|
189 |
trace_writeback_wake_background(bdi); |
5acda9d12
|
190 |
bdi_wakeup_thread(bdi); |
1da177e4c
|
191 192 193 |
} /* |
a66979aba
|
194 195 196 197 |
* Remove the inode from the writeback list it is on. */ void inode_wb_list_del(struct inode *inode) { |
f758eeabe
|
198 199 200 |
struct backing_dev_info *bdi = inode_to_bdi(inode); spin_lock(&bdi->wb.list_lock); |
a66979aba
|
201 |
list_del_init(&inode->i_wb_list); |
f758eeabe
|
202 |
spin_unlock(&bdi->wb.list_lock); |
a66979aba
|
203 |
} |
a66979aba
|
204 |
/* |
6610a0bc8
|
205 206 207 208 |
* Redirty an inode: set its when-it-was dirtied timestamp and move it to the * furthest end of its superblock's dirty-inode list. * * Before stamping the inode's ->dirtied_when, we check to see whether it is |
66f3b8e2e
|
209 |
* already the most-recently-dirtied inode on the b_dirty list. If that is |
6610a0bc8
|
210 211 212 |
* the case then the inode must have been redirtied while it was being written * out and we don't reset its dirtied_when. */ |
f758eeabe
|
213 |
static void redirty_tail(struct inode *inode, struct bdi_writeback *wb) |
6610a0bc8
|
214 |
{ |
f758eeabe
|
215 |
assert_spin_locked(&wb->list_lock); |
03ba3782e
|
216 |
if (!list_empty(&wb->b_dirty)) { |
66f3b8e2e
|
217 |
struct inode *tail; |
6610a0bc8
|
218 |
|
7ccf19a80
|
219 |
tail = wb_inode(wb->b_dirty.next); |
66f3b8e2e
|
220 |
if (time_before(inode->dirtied_when, tail->dirtied_when)) |
6610a0bc8
|
221 222 |
inode->dirtied_when = jiffies; } |
7ccf19a80
|
223 |
list_move(&inode->i_wb_list, &wb->b_dirty); |
6610a0bc8
|
224 225 226 |
} /* |
66f3b8e2e
|
227 |
* requeue inode for re-scanning after bdi->b_io list is exhausted. |
c986d1e2a
|
228 |
*/ |
f758eeabe
|
229 |
static void requeue_io(struct inode *inode, struct bdi_writeback *wb) |
c986d1e2a
|
230 |
{ |
f758eeabe
|
231 |
assert_spin_locked(&wb->list_lock); |
7ccf19a80
|
232 |
list_move(&inode->i_wb_list, &wb->b_more_io); |
c986d1e2a
|
233 |
} |
1c0eeaf56
|
234 235 |
static void inode_sync_complete(struct inode *inode) { |
365b94ae6
|
236 |
inode->i_state &= ~I_SYNC; |
4eff96dd5
|
237 238 |
/* If inode is clean an unused, put it into LRU now... */ inode_add_lru(inode); |
365b94ae6
|
239 |
/* Waiters must see I_SYNC cleared before being woken up */ |
1c0eeaf56
|
240 241 242 |
smp_mb(); wake_up_bit(&inode->i_state, __I_SYNC); } |
d2caa3c54
|
243 244 245 246 247 248 249 250 |
static bool inode_dirtied_after(struct inode *inode, unsigned long t) { bool ret = time_after(inode->dirtied_when, t); #ifndef CONFIG_64BIT /* * For inodes being constantly redirtied, dirtied_when can get stuck. * It _appears_ to be in the future, but is actually in distant past. * This test is necessary to prevent such wrapped-around relative times |
5b0830cb9
|
251 |
* from permanently stopping the whole bdi writeback. |
d2caa3c54
|
252 253 254 255 256 |
*/ ret = ret && time_before_eq(inode->dirtied_when, jiffies); #endif return ret; } |
0ae45f63d
|
257 |
#define EXPIRE_DIRTY_ATIME 0x0001 |
c986d1e2a
|
258 |
/* |
0e2f2b236
|
259 |
* Move expired (dirtied before work->older_than_this) dirty inodes from |
697e6fed9
|
260 |
* @delaying_queue to @dispatch_queue. |
2c1365791
|
261 |
*/ |
e84d0a4f8
|
262 |
static int move_expired_inodes(struct list_head *delaying_queue, |
2c1365791
|
263 |
struct list_head *dispatch_queue, |
0ae45f63d
|
264 |
int flags, |
ad4e38dd6
|
265 |
struct wb_writeback_work *work) |
2c1365791
|
266 |
{ |
0ae45f63d
|
267 268 |
unsigned long *older_than_this = NULL; unsigned long expire_time; |
5c03449d3
|
269 270 |
LIST_HEAD(tmp); struct list_head *pos, *node; |
cf137307c
|
271 |
struct super_block *sb = NULL; |
5c03449d3
|
272 |
struct inode *inode; |
cf137307c
|
273 |
int do_sb_sort = 0; |
e84d0a4f8
|
274 |
int moved = 0; |
5c03449d3
|
275 |
|
0ae45f63d
|
276 277 |
if ((flags & EXPIRE_DIRTY_ATIME) == 0) older_than_this = work->older_than_this; |
a2f487069
|
278 279 |
else if (!work->for_sync) { expire_time = jiffies - (dirtytime_expire_interval * HZ); |
0ae45f63d
|
280 281 |
older_than_this = &expire_time; } |
2c1365791
|
282 |
while (!list_empty(delaying_queue)) { |
7ccf19a80
|
283 |
inode = wb_inode(delaying_queue->prev); |
0ae45f63d
|
284 285 |
if (older_than_this && inode_dirtied_after(inode, *older_than_this)) |
2c1365791
|
286 |
break; |
a8855990e
|
287 288 |
list_move(&inode->i_wb_list, &tmp); moved++; |
0ae45f63d
|
289 290 |
if (flags & EXPIRE_DIRTY_ATIME) set_bit(__I_DIRTY_TIME_EXPIRED, &inode->i_state); |
a8855990e
|
291 292 |
if (sb_is_blkdev_sb(inode->i_sb)) continue; |
cf137307c
|
293 294 295 |
if (sb && sb != inode->i_sb) do_sb_sort = 1; sb = inode->i_sb; |
5c03449d3
|
296 |
} |
cf137307c
|
297 298 299 |
/* just one sb in list, splice to dispatch_queue and we're done */ if (!do_sb_sort) { list_splice(&tmp, dispatch_queue); |
e84d0a4f8
|
300 |
goto out; |
cf137307c
|
301 |
} |
5c03449d3
|
302 303 |
/* Move inodes from one superblock together */ while (!list_empty(&tmp)) { |
7ccf19a80
|
304 |
sb = wb_inode(tmp.prev)->i_sb; |
5c03449d3
|
305 |
list_for_each_prev_safe(pos, node, &tmp) { |
7ccf19a80
|
306 |
inode = wb_inode(pos); |
5c03449d3
|
307 |
if (inode->i_sb == sb) |
7ccf19a80
|
308 |
list_move(&inode->i_wb_list, dispatch_queue); |
5c03449d3
|
309 |
} |
2c1365791
|
310 |
} |
e84d0a4f8
|
311 312 |
out: return moved; |
2c1365791
|
313 314 315 316 |
} /* * Queue all expired dirty inodes for io, eldest first. |
4ea879b96
|
317 318 319 320 321 322 323 324 |
* Before * newly dirtied b_dirty b_io b_more_io * =============> gf edc BA * After * newly dirtied b_dirty b_io b_more_io * =============> g fBAedc * | * +--> dequeue for IO |
2c1365791
|
325 |
*/ |
ad4e38dd6
|
326 |
static void queue_io(struct bdi_writeback *wb, struct wb_writeback_work *work) |
66f3b8e2e
|
327 |
{ |
e84d0a4f8
|
328 |
int moved; |
0ae45f63d
|
329 |
|
f758eeabe
|
330 |
assert_spin_locked(&wb->list_lock); |
4ea879b96
|
331 |
list_splice_init(&wb->b_more_io, &wb->b_io); |
0ae45f63d
|
332 333 334 |
moved = move_expired_inodes(&wb->b_dirty, &wb->b_io, 0, work); moved += move_expired_inodes(&wb->b_dirty_time, &wb->b_io, EXPIRE_DIRTY_ATIME, work); |
ad4e38dd6
|
335 |
trace_writeback_queue_io(wb, work, moved); |
66f3b8e2e
|
336 |
} |
a9185b41a
|
337 |
static int write_inode(struct inode *inode, struct writeback_control *wbc) |
08d8e9749
|
338 |
{ |
9fb0a7da0
|
339 340 341 342 343 344 345 346 |
int ret; if (inode->i_sb->s_op->write_inode && !is_bad_inode(inode)) { trace_writeback_write_inode_start(inode, wbc); ret = inode->i_sb->s_op->write_inode(inode, wbc); trace_writeback_write_inode(inode, wbc); return ret; } |
03ba3782e
|
347 |
return 0; |
08d8e9749
|
348 |
} |
08d8e9749
|
349 |
|
2c1365791
|
350 |
/* |
169ebd901
|
351 352 |
* Wait for writeback on an inode to complete. Called with i_lock held. * Caller must make sure inode cannot go away when we drop i_lock. |
01c031945
|
353 |
*/ |
169ebd901
|
354 355 356 |
static void __inode_wait_for_writeback(struct inode *inode) __releases(inode->i_lock) __acquires(inode->i_lock) |
01c031945
|
357 358 359 360 361 |
{ DEFINE_WAIT_BIT(wq, &inode->i_state, __I_SYNC); wait_queue_head_t *wqh; wqh = bit_waitqueue(&inode->i_state, __I_SYNC); |
250df6ed2
|
362 363 |
while (inode->i_state & I_SYNC) { spin_unlock(&inode->i_lock); |
743162013
|
364 365 |
__wait_on_bit(wqh, &wq, bit_wait, TASK_UNINTERRUPTIBLE); |
250df6ed2
|
366 |
spin_lock(&inode->i_lock); |
58a9d3d8d
|
367 |
} |
01c031945
|
368 369 370 |
} /* |
169ebd901
|
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 |
* Wait for writeback on an inode to complete. Caller must have inode pinned. */ void inode_wait_for_writeback(struct inode *inode) { spin_lock(&inode->i_lock); __inode_wait_for_writeback(inode); spin_unlock(&inode->i_lock); } /* * Sleep until I_SYNC is cleared. This function must be called with i_lock * held and drops it. It is aimed for callers not holding any inode reference * so once i_lock is dropped, inode can go away. */ static void inode_sleep_on_writeback(struct inode *inode) __releases(inode->i_lock) { DEFINE_WAIT(wait); wait_queue_head_t *wqh = bit_waitqueue(&inode->i_state, __I_SYNC); int sleep; prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE); sleep = inode->i_state & I_SYNC; spin_unlock(&inode->i_lock); if (sleep) schedule(); finish_wait(wqh, &wait); } /* |
ccb26b5a6
|
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 |
* Find proper writeback list for the inode depending on its current state and * possibly also change of its state while we were doing writeback. Here we * handle things such as livelock prevention or fairness of writeback among * inodes. This function can be called only by flusher thread - noone else * processes all inodes in writeback lists and requeueing inodes behind flusher * thread's back can have unexpected consequences. */ static void requeue_inode(struct inode *inode, struct bdi_writeback *wb, struct writeback_control *wbc) { if (inode->i_state & I_FREEING) return; /* * Sync livelock prevention. Each inode is tagged and synced in one * shot. If still dirty, it will be redirty_tail()'ed below. Update * the dirty time to prevent enqueue and sync it again. */ if ((inode->i_state & I_DIRTY) && (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)) inode->dirtied_when = jiffies; |
4f8ad655d
|
422 423 424 425 426 427 428 429 |
if (wbc->pages_skipped) { /* * writeback is not making progress due to locked * buffers. Skip this inode for now. */ redirty_tail(inode, wb); return; } |
ccb26b5a6
|
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 |
if (mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY)) { /* * We didn't write back all the pages. nfs_writepages() * sometimes bales out without doing anything. */ if (wbc->nr_to_write <= 0) { /* Slice used up. Queue for next turn. */ requeue_io(inode, wb); } else { /* * Writeback blocked by something other than * congestion. Delay the inode for some time to * avoid spinning on the CPU (100% iowait) * retrying writeback of the dirty page/inode * that cannot be performed immediately. */ redirty_tail(inode, wb); } } else if (inode->i_state & I_DIRTY) { /* * Filesystems can dirty the inode during writeback operations, * such as delayed allocation during submission or metadata * updates after data IO completion. */ redirty_tail(inode, wb); |
0ae45f63d
|
455 |
} else if (inode->i_state & I_DIRTY_TIME) { |
a2f487069
|
456 |
inode->dirtied_when = jiffies; |
0ae45f63d
|
457 |
list_move(&inode->i_wb_list, &wb->b_dirty_time); |
ccb26b5a6
|
458 459 460 461 462 463 464 |
} else { /* The inode is clean. Remove from writeback lists. */ list_del_init(&inode->i_wb_list); } } /* |
4f8ad655d
|
465 466 467 |
* Write out an inode and its dirty pages. Do not update the writeback list * linkage. That is left to the caller. The caller is also responsible for * setting I_SYNC flag and calling inode_sync_complete() to clear it. |
1da177e4c
|
468 469 |
*/ static int |
cd8ed2a45
|
470 |
__writeback_single_inode(struct inode *inode, struct writeback_control *wbc) |
1da177e4c
|
471 |
{ |
1da177e4c
|
472 |
struct address_space *mapping = inode->i_mapping; |
251d6a471
|
473 |
long nr_to_write = wbc->nr_to_write; |
01c031945
|
474 |
unsigned dirty; |
1da177e4c
|
475 |
int ret; |
4f8ad655d
|
476 |
WARN_ON(!(inode->i_state & I_SYNC)); |
1da177e4c
|
477 |
|
9fb0a7da0
|
478 |
trace_writeback_single_inode_start(inode, wbc, nr_to_write); |
1da177e4c
|
479 |
ret = do_writepages(mapping, wbc); |
26821ed40
|
480 481 482 |
/* * Make sure to wait on the data before writing out the metadata. * This is important for filesystems that modify metadata on data |
7747bd4bc
|
483 484 485 |
* I/O completion. We don't do it for sync(2) writeback because it has a * separate, external IO completion path and ->sync_fs for guaranteeing * inode metadata is written back correctly. |
26821ed40
|
486 |
*/ |
7747bd4bc
|
487 |
if (wbc->sync_mode == WB_SYNC_ALL && !wbc->for_sync) { |
26821ed40
|
488 |
int err = filemap_fdatawait(mapping); |
1da177e4c
|
489 490 491 |
if (ret == 0) ret = err; } |
5547e8aac
|
492 493 494 495 496 |
/* * Some filesystems may redirty the inode during the writeback * due to delalloc, clear dirty metadata flags right before * write_inode() */ |
250df6ed2
|
497 |
spin_lock(&inode->i_lock); |
9c6ac78eb
|
498 |
|
5547e8aac
|
499 |
dirty = inode->i_state & I_DIRTY; |
a2f487069
|
500 501 502 503 504 505 506 507 508 509 510 |
if (inode->i_state & I_DIRTY_TIME) { if ((dirty & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) || unlikely(inode->i_state & I_DIRTY_TIME_EXPIRED) || unlikely(time_after(jiffies, (inode->dirtied_time_when + dirtytime_expire_interval * HZ)))) { dirty |= I_DIRTY_TIME | I_DIRTY_TIME_EXPIRED; trace_writeback_lazytime(inode); } } else inode->i_state &= ~I_DIRTY_TIME_EXPIRED; |
0ae45f63d
|
511 |
inode->i_state &= ~dirty; |
9c6ac78eb
|
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 |
/* * Paired with smp_mb() in __mark_inode_dirty(). This allows * __mark_inode_dirty() to test i_state without grabbing i_lock - * either they see the I_DIRTY bits cleared or we see the dirtied * inode. * * I_DIRTY_PAGES is always cleared together above even if @mapping * still has dirty pages. The flag is reinstated after smp_mb() if * necessary. This guarantees that either __mark_inode_dirty() * sees clear I_DIRTY_PAGES or we see PAGECACHE_TAG_DIRTY. */ smp_mb(); if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) inode->i_state |= I_DIRTY_PAGES; |
250df6ed2
|
528 |
spin_unlock(&inode->i_lock); |
9c6ac78eb
|
529 |
|
0ae45f63d
|
530 531 |
if (dirty & I_DIRTY_TIME) mark_inode_dirty_sync(inode); |
26821ed40
|
532 |
/* Don't write the inode if only I_DIRTY_PAGES was set */ |
0ae45f63d
|
533 |
if (dirty & ~I_DIRTY_PAGES) { |
a9185b41a
|
534 |
int err = write_inode(inode, wbc); |
1da177e4c
|
535 536 537 |
if (ret == 0) ret = err; } |
4f8ad655d
|
538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 |
trace_writeback_single_inode(inode, wbc, nr_to_write); return ret; } /* * Write out an inode's dirty pages. Either the caller has an active reference * on the inode or the inode has I_WILL_FREE set. * * This function is designed to be called for writing back one inode which * we go e.g. from filesystem. Flusher thread uses __writeback_single_inode() * and does more profound writeback list handling in writeback_sb_inodes(). */ static int writeback_single_inode(struct inode *inode, struct bdi_writeback *wb, struct writeback_control *wbc) { int ret = 0; spin_lock(&inode->i_lock); if (!atomic_read(&inode->i_count)) WARN_ON(!(inode->i_state & (I_WILL_FREE|I_FREEING))); else WARN_ON(inode->i_state & I_WILL_FREE); if (inode->i_state & I_SYNC) { if (wbc->sync_mode != WB_SYNC_ALL) goto out; /* |
169ebd901
|
566 567 568 |
* It's a data-integrity sync. We must wait. Since callers hold * inode reference or inode has I_WILL_FREE set, it cannot go * away under us. |
4f8ad655d
|
569 |
*/ |
169ebd901
|
570 |
__inode_wait_for_writeback(inode); |
4f8ad655d
|
571 572 573 |
} WARN_ON(inode->i_state & I_SYNC); /* |
f9b0e058c
|
574 575 576 577 578 579 |
* Skip inode if it is clean and we have no outstanding writeback in * WB_SYNC_ALL mode. We don't want to mess with writeback lists in this * function since flusher thread may be doing for example sync in * parallel and if we move the inode, it could get skipped. So here we * make sure inode is on some writeback list and leave it there unless * we have completely cleaned the inode. |
4f8ad655d
|
580 |
*/ |
0ae45f63d
|
581 |
if (!(inode->i_state & I_DIRTY_ALL) && |
f9b0e058c
|
582 583 |
(wbc->sync_mode != WB_SYNC_ALL || !mapping_tagged(inode->i_mapping, PAGECACHE_TAG_WRITEBACK))) |
4f8ad655d
|
584 585 586 |
goto out; inode->i_state |= I_SYNC; spin_unlock(&inode->i_lock); |
cd8ed2a45
|
587 |
ret = __writeback_single_inode(inode, wbc); |
1da177e4c
|
588 |
|
f758eeabe
|
589 |
spin_lock(&wb->list_lock); |
250df6ed2
|
590 |
spin_lock(&inode->i_lock); |
4f8ad655d
|
591 592 593 594 |
/* * If inode is clean, remove it from writeback lists. Otherwise don't * touch it. See comment above for explanation. */ |
0ae45f63d
|
595 |
if (!(inode->i_state & I_DIRTY_ALL)) |
4f8ad655d
|
596 597 |
list_del_init(&inode->i_wb_list); spin_unlock(&wb->list_lock); |
1c0eeaf56
|
598 |
inode_sync_complete(inode); |
4f8ad655d
|
599 600 |
out: spin_unlock(&inode->i_lock); |
1da177e4c
|
601 602 |
return ret; } |
1a12d8bd7
|
603 604 |
static long writeback_chunk_size(struct backing_dev_info *bdi, struct wb_writeback_work *work) |
d46db3d58
|
605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 |
{ long pages; /* * WB_SYNC_ALL mode does livelock avoidance by syncing dirty * inodes/pages in one big loop. Setting wbc.nr_to_write=LONG_MAX * here avoids calling into writeback_inodes_wb() more than once. * * The intended call sequence for WB_SYNC_ALL writeback is: * * wb_writeback() * writeback_sb_inodes() <== called only once * write_cache_pages() <== called once for each inode * (quickly) tag currently dirty pages * (maybe slowly) sync all tagged pages */ if (work->sync_mode == WB_SYNC_ALL || work->tagged_writepages) pages = LONG_MAX; |
1a12d8bd7
|
623 624 625 626 627 628 629 |
else { pages = min(bdi->avg_write_bandwidth / 2, global_dirty_limit / DIRTY_SCOPE); pages = min(pages, work->nr_pages); pages = round_down(pages + MIN_WRITEBACK_PAGES, MIN_WRITEBACK_PAGES); } |
d46db3d58
|
630 631 632 |
return pages; } |
03ba3782e
|
633 |
/* |
f11c9c5c2
|
634 |
* Write a portion of b_io inodes which belong to @sb. |
edadfb10b
|
635 |
* |
d46db3d58
|
636 |
* Return the number of pages and/or inodes written. |
f11c9c5c2
|
637 |
*/ |
d46db3d58
|
638 639 640 |
static long writeback_sb_inodes(struct super_block *sb, struct bdi_writeback *wb, struct wb_writeback_work *work) |
1da177e4c
|
641 |
{ |
d46db3d58
|
642 643 644 645 646 |
struct writeback_control wbc = { .sync_mode = work->sync_mode, .tagged_writepages = work->tagged_writepages, .for_kupdate = work->for_kupdate, .for_background = work->for_background, |
7747bd4bc
|
647 |
.for_sync = work->for_sync, |
d46db3d58
|
648 649 650 651 652 653 654 |
.range_cyclic = work->range_cyclic, .range_start = 0, .range_end = LLONG_MAX, }; unsigned long start_time = jiffies; long write_chunk; long wrote = 0; /* count both pages and inodes */ |
03ba3782e
|
655 |
while (!list_empty(&wb->b_io)) { |
7ccf19a80
|
656 |
struct inode *inode = wb_inode(wb->b_io.prev); |
edadfb10b
|
657 658 |
if (inode->i_sb != sb) { |
d46db3d58
|
659 |
if (work->sb) { |
edadfb10b
|
660 661 662 663 664 |
/* * We only want to write back data for this * superblock, move all inodes not belonging * to it back onto the dirty list. */ |
f758eeabe
|
665 |
redirty_tail(inode, wb); |
edadfb10b
|
666 667 668 669 670 671 672 673 |
continue; } /* * The inode belongs to a different superblock. * Bounce back to the caller to unpin this and * pin the next superblock. */ |
d46db3d58
|
674 |
break; |
edadfb10b
|
675 |
} |
9843b76aa
|
676 |
/* |
331cbdeed
|
677 678 |
* Don't bother with new inodes or inodes being freed, first * kind does not need periodic writeout yet, and for the latter |
9843b76aa
|
679 680 |
* kind writeout is handled by the freer. */ |
250df6ed2
|
681 |
spin_lock(&inode->i_lock); |
9843b76aa
|
682 |
if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) { |
250df6ed2
|
683 |
spin_unlock(&inode->i_lock); |
fcc5c2221
|
684 |
redirty_tail(inode, wb); |
7ef0d7377
|
685 686 |
continue; } |
cc1676d91
|
687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 |
if ((inode->i_state & I_SYNC) && wbc.sync_mode != WB_SYNC_ALL) { /* * If this inode is locked for writeback and we are not * doing writeback-for-data-integrity, move it to * b_more_io so that writeback can proceed with the * other inodes on s_io. * * We'll have another go at writing back this inode * when we completed a full scan of b_io. */ spin_unlock(&inode->i_lock); requeue_io(inode, wb); trace_writeback_sb_inodes_requeue(inode); continue; } |
f0d07b7ff
|
702 |
spin_unlock(&wb->list_lock); |
4f8ad655d
|
703 704 705 706 707 |
/* * We already requeued the inode if it had I_SYNC set and we * are doing WB_SYNC_NONE writeback. So this catches only the * WB_SYNC_ALL case. */ |
169ebd901
|
708 709 710 711 |
if (inode->i_state & I_SYNC) { /* Wait for I_SYNC. This function drops i_lock... */ inode_sleep_on_writeback(inode); /* Inode may be gone, start again */ |
ead188f9f
|
712 |
spin_lock(&wb->list_lock); |
169ebd901
|
713 714 |
continue; } |
4f8ad655d
|
715 716 |
inode->i_state |= I_SYNC; spin_unlock(&inode->i_lock); |
169ebd901
|
717 |
|
1a12d8bd7
|
718 |
write_chunk = writeback_chunk_size(wb->bdi, work); |
d46db3d58
|
719 720 |
wbc.nr_to_write = write_chunk; wbc.pages_skipped = 0; |
250df6ed2
|
721 |
|
169ebd901
|
722 723 724 725 |
/* * We use I_SYNC to pin the inode in memory. While it is set * evict_inode() will wait so the inode cannot be freed. */ |
cd8ed2a45
|
726 |
__writeback_single_inode(inode, &wbc); |
250df6ed2
|
727 |
|
d46db3d58
|
728 729 |
work->nr_pages -= write_chunk - wbc.nr_to_write; wrote += write_chunk - wbc.nr_to_write; |
4f8ad655d
|
730 731 |
spin_lock(&wb->list_lock); spin_lock(&inode->i_lock); |
0ae45f63d
|
732 |
if (!(inode->i_state & I_DIRTY_ALL)) |
d46db3d58
|
733 |
wrote++; |
4f8ad655d
|
734 735 |
requeue_inode(inode, wb, &wbc); inode_sync_complete(inode); |
0f1b1fd86
|
736 |
spin_unlock(&inode->i_lock); |
169ebd901
|
737 |
cond_resched_lock(&wb->list_lock); |
d46db3d58
|
738 739 740 741 742 743 744 745 746 |
/* * bail out to wb_writeback() often enough to check * background threshold and other termination conditions. */ if (wrote) { if (time_is_before_jiffies(start_time + HZ / 10UL)) break; if (work->nr_pages <= 0) break; |
8bc3be275
|
747 |
} |
1da177e4c
|
748 |
} |
d46db3d58
|
749 |
return wrote; |
f11c9c5c2
|
750 |
} |
d46db3d58
|
751 752 |
static long __writeback_inodes_wb(struct bdi_writeback *wb, struct wb_writeback_work *work) |
f11c9c5c2
|
753 |
{ |
d46db3d58
|
754 755 |
unsigned long start_time = jiffies; long wrote = 0; |
38f219776
|
756 |
|
f11c9c5c2
|
757 |
while (!list_empty(&wb->b_io)) { |
7ccf19a80
|
758 |
struct inode *inode = wb_inode(wb->b_io.prev); |
f11c9c5c2
|
759 |
struct super_block *sb = inode->i_sb; |
9ecc2738a
|
760 |
|
eb6ef3df4
|
761 |
if (!trylock_super(sb)) { |
0e995816f
|
762 |
/* |
eb6ef3df4
|
763 |
* trylock_super() may fail consistently due to |
0e995816f
|
764 765 766 767 |
* s_umount being grabbed by someone else. Don't use * requeue_io() to avoid busy retrying the inode/sb. */ redirty_tail(inode, wb); |
edadfb10b
|
768 |
continue; |
f11c9c5c2
|
769 |
} |
d46db3d58
|
770 |
wrote += writeback_sb_inodes(sb, wb, work); |
eb6ef3df4
|
771 |
up_read(&sb->s_umount); |
f11c9c5c2
|
772 |
|
d46db3d58
|
773 774 775 776 777 778 779 |
/* refer to the same tests at the end of writeback_sb_inodes */ if (wrote) { if (time_is_before_jiffies(start_time + HZ / 10UL)) break; if (work->nr_pages <= 0) break; } |
f11c9c5c2
|
780 |
} |
66f3b8e2e
|
781 |
/* Leave any unwritten inodes on b_io */ |
d46db3d58
|
782 |
return wrote; |
66f3b8e2e
|
783 |
} |
7d9f073b8
|
784 |
static long writeback_inodes_wb(struct bdi_writeback *wb, long nr_pages, |
0e175a183
|
785 |
enum wb_reason reason) |
edadfb10b
|
786 |
{ |
d46db3d58
|
787 788 789 790 |
struct wb_writeback_work work = { .nr_pages = nr_pages, .sync_mode = WB_SYNC_NONE, .range_cyclic = 1, |
0e175a183
|
791 |
.reason = reason, |
d46db3d58
|
792 |
}; |
edadfb10b
|
793 |
|
f758eeabe
|
794 |
spin_lock(&wb->list_lock); |
424b351fe
|
795 |
if (list_empty(&wb->b_io)) |
ad4e38dd6
|
796 |
queue_io(wb, &work); |
d46db3d58
|
797 |
__writeback_inodes_wb(wb, &work); |
f758eeabe
|
798 |
spin_unlock(&wb->list_lock); |
edadfb10b
|
799 |
|
d46db3d58
|
800 801 |
return nr_pages - work.nr_pages; } |
03ba3782e
|
802 |
|
b00949aa2
|
803 |
static bool over_bground_thresh(struct backing_dev_info *bdi) |
03ba3782e
|
804 805 |
{ unsigned long background_thresh, dirty_thresh; |
16c4042f0
|
806 |
global_dirty_limits(&background_thresh, &dirty_thresh); |
03ba3782e
|
807 |
|
b00949aa2
|
808 809 810 811 812 813 814 815 816 |
if (global_page_state(NR_FILE_DIRTY) + global_page_state(NR_UNSTABLE_NFS) > background_thresh) return true; if (bdi_stat(bdi, BDI_RECLAIMABLE) > bdi_dirty_limit(bdi, background_thresh)) return true; return false; |
03ba3782e
|
817 818 819 |
} /* |
e98be2d59
|
820 821 822 823 824 825 |
* Called under wb->list_lock. If there are multiple wb per bdi, * only the flusher working on the first wb should do it. */ static void wb_update_bandwidth(struct bdi_writeback *wb, unsigned long start_time) { |
af6a31138
|
826 |
__bdi_update_bandwidth(wb->bdi, 0, 0, 0, 0, 0, start_time); |
e98be2d59
|
827 828 829 |
} /* |
03ba3782e
|
830 |
* Explicit flushing or periodic writeback of "old" data. |
66f3b8e2e
|
831 |
* |
03ba3782e
|
832 833 834 835 |
* Define "old": the first time one of an inode's pages is dirtied, we mark the * dirtying-time in the inode's address_space. So this periodic writeback code * just walks the superblock inode list, writing back any inodes which are * older than a specific point in time. |
66f3b8e2e
|
836 |
* |
03ba3782e
|
837 838 839 |
* Try to run once per dirty_writeback_interval. But if a writeback event * takes longer than a dirty_writeback_interval interval, then leave a * one-second gap. |
66f3b8e2e
|
840 |
* |
03ba3782e
|
841 842 |
* older_than_this takes precedence over nr_to_write. So we'll only write back * all dirty pages if they are all attached to "old" mappings. |
66f3b8e2e
|
843 |
*/ |
c4a77a6c7
|
844 |
static long wb_writeback(struct bdi_writeback *wb, |
83ba7b071
|
845 |
struct wb_writeback_work *work) |
66f3b8e2e
|
846 |
{ |
e98be2d59
|
847 |
unsigned long wb_start = jiffies; |
d46db3d58
|
848 |
long nr_pages = work->nr_pages; |
0dc83bd30
|
849 |
unsigned long oldest_jif; |
a5989bdc9
|
850 |
struct inode *inode; |
d46db3d58
|
851 |
long progress; |
66f3b8e2e
|
852 |
|
0dc83bd30
|
853 854 |
oldest_jif = jiffies; work->older_than_this = &oldest_jif; |
38f219776
|
855 |
|
e8dfc3058
|
856 |
spin_lock(&wb->list_lock); |
03ba3782e
|
857 858 |
for (;;) { /* |
d3ddec763
|
859 |
* Stop writeback when nr_pages has been consumed |
03ba3782e
|
860 |
*/ |
83ba7b071
|
861 |
if (work->nr_pages <= 0) |
03ba3782e
|
862 |
break; |
66f3b8e2e
|
863 |
|
38f219776
|
864 |
/* |
aa373cf55
|
865 866 867 868 869 870 871 872 873 874 |
* Background writeout and kupdate-style writeback may * run forever. Stop them if there is other work to do * so that e.g. sync can proceed. They'll be restarted * after the other works are all done. */ if ((work->for_background || work->for_kupdate) && !list_empty(&wb->bdi->work_list)) break; /* |
d3ddec763
|
875 876 |
* For background writeout, stop when we are below the * background dirty threshold |
38f219776
|
877 |
*/ |
b00949aa2
|
878 |
if (work->for_background && !over_bground_thresh(wb->bdi)) |
03ba3782e
|
879 |
break; |
38f219776
|
880 |
|
1bc36b642
|
881 882 883 884 885 886 |
/* * Kupdate and background works are special and we want to * include all inodes that need writing. Livelock avoidance is * handled by these works yielding to any other work so we are * safe. */ |
ba9aa8399
|
887 |
if (work->for_kupdate) { |
0dc83bd30
|
888 |
oldest_jif = jiffies - |
ba9aa8399
|
889 |
msecs_to_jiffies(dirty_expire_interval * 10); |
1bc36b642
|
890 |
} else if (work->for_background) |
0dc83bd30
|
891 |
oldest_jif = jiffies; |
028c2dd18
|
892 |
|
d46db3d58
|
893 |
trace_writeback_start(wb->bdi, work); |
e8dfc3058
|
894 |
if (list_empty(&wb->b_io)) |
ad4e38dd6
|
895 |
queue_io(wb, work); |
83ba7b071
|
896 |
if (work->sb) |
d46db3d58
|
897 |
progress = writeback_sb_inodes(work->sb, wb, work); |
edadfb10b
|
898 |
else |
d46db3d58
|
899 900 |
progress = __writeback_inodes_wb(wb, work); trace_writeback_written(wb->bdi, work); |
028c2dd18
|
901 |
|
e98be2d59
|
902 |
wb_update_bandwidth(wb, wb_start); |
03ba3782e
|
903 904 |
/* |
e6fb6da2e
|
905 906 907 908 909 910 |
* Did we write something? Try for more * * Dirty inodes are moved to b_io for writeback in batches. * The completion of the current batch does not necessarily * mean the overall work is done. So we keep looping as long * as made some progress on cleaning pages or inodes. |
03ba3782e
|
911 |
*/ |
d46db3d58
|
912 |
if (progress) |
71fd05a88
|
913 914 |
continue; /* |
e6fb6da2e
|
915 |
* No more inodes for IO, bail |
71fd05a88
|
916 |
*/ |
b7a2441f9
|
917 |
if (list_empty(&wb->b_more_io)) |
03ba3782e
|
918 |
break; |
71fd05a88
|
919 |
/* |
71fd05a88
|
920 921 922 923 |
* Nothing written. Wait for some inode to * become available for writeback. Otherwise * we'll just busyloop. */ |
71fd05a88
|
924 |
if (!list_empty(&wb->b_more_io)) { |
d46db3d58
|
925 |
trace_writeback_wait(wb->bdi, work); |
7ccf19a80
|
926 |
inode = wb_inode(wb->b_more_io.prev); |
250df6ed2
|
927 |
spin_lock(&inode->i_lock); |
f0d07b7ff
|
928 |
spin_unlock(&wb->list_lock); |
169ebd901
|
929 930 |
/* This function drops i_lock... */ inode_sleep_on_writeback(inode); |
f0d07b7ff
|
931 |
spin_lock(&wb->list_lock); |
03ba3782e
|
932 933 |
} } |
e8dfc3058
|
934 |
spin_unlock(&wb->list_lock); |
03ba3782e
|
935 |
|
d46db3d58
|
936 |
return nr_pages - work->nr_pages; |
03ba3782e
|
937 938 939 |
} /* |
83ba7b071
|
940 |
* Return the next wb_writeback_work struct that hasn't been processed yet. |
03ba3782e
|
941 |
*/ |
83ba7b071
|
942 |
static struct wb_writeback_work * |
08852b6d6
|
943 |
get_next_work_item(struct backing_dev_info *bdi) |
03ba3782e
|
944 |
{ |
83ba7b071
|
945 |
struct wb_writeback_work *work = NULL; |
03ba3782e
|
946 |
|
6467716a3
|
947 |
spin_lock_bh(&bdi->wb_lock); |
83ba7b071
|
948 949 950 951 |
if (!list_empty(&bdi->work_list)) { work = list_entry(bdi->work_list.next, struct wb_writeback_work, list); list_del_init(&work->list); |
03ba3782e
|
952 |
} |
6467716a3
|
953 |
spin_unlock_bh(&bdi->wb_lock); |
83ba7b071
|
954 |
return work; |
03ba3782e
|
955 |
} |
cdf01dd54
|
956 957 958 959 960 961 962 963 964 965 |
/* * Add in the number of potentially dirty inodes, because each inode * write can dirty pagecache in the underlying blockdev. */ static unsigned long get_nr_dirty_pages(void) { return global_page_state(NR_FILE_DIRTY) + global_page_state(NR_UNSTABLE_NFS) + get_nr_dirty_inodes(); } |
6585027a5
|
966 967 |
static long wb_check_background_flush(struct bdi_writeback *wb) { |
b00949aa2
|
968 |
if (over_bground_thresh(wb->bdi)) { |
6585027a5
|
969 970 971 972 973 974 |
struct wb_writeback_work work = { .nr_pages = LONG_MAX, .sync_mode = WB_SYNC_NONE, .for_background = 1, .range_cyclic = 1, |
0e175a183
|
975 |
.reason = WB_REASON_BACKGROUND, |
6585027a5
|
976 977 978 979 980 981 982 |
}; return wb_writeback(wb, &work); } return 0; } |
03ba3782e
|
983 984 985 986 |
static long wb_check_old_data_flush(struct bdi_writeback *wb) { unsigned long expired; long nr_pages; |
69b62d01e
|
987 988 989 990 991 |
/* * When set to zero, disable periodic writeback */ if (!dirty_writeback_interval) return 0; |
03ba3782e
|
992 993 994 995 996 997 |
expired = wb->last_old_flush + msecs_to_jiffies(dirty_writeback_interval * 10); if (time_before(jiffies, expired)) return 0; wb->last_old_flush = jiffies; |
cdf01dd54
|
998 |
nr_pages = get_nr_dirty_pages(); |
03ba3782e
|
999 |
|
c4a77a6c7
|
1000 |
if (nr_pages) { |
83ba7b071
|
1001 |
struct wb_writeback_work work = { |
c4a77a6c7
|
1002 1003 1004 1005 |
.nr_pages = nr_pages, .sync_mode = WB_SYNC_NONE, .for_kupdate = 1, .range_cyclic = 1, |
0e175a183
|
1006 |
.reason = WB_REASON_PERIODIC, |
c4a77a6c7
|
1007 |
}; |
83ba7b071
|
1008 |
return wb_writeback(wb, &work); |
c4a77a6c7
|
1009 |
} |
03ba3782e
|
1010 1011 1012 1013 1014 1015 1016 |
return 0; } /* * Retrieve work items and do the writeback they describe */ |
25d130ba2
|
1017 |
static long wb_do_writeback(struct bdi_writeback *wb) |
03ba3782e
|
1018 1019 |
{ struct backing_dev_info *bdi = wb->bdi; |
83ba7b071
|
1020 |
struct wb_writeback_work *work; |
c4a77a6c7
|
1021 |
long wrote = 0; |
03ba3782e
|
1022 |
|
81d73a32d
|
1023 |
set_bit(BDI_writeback_running, &wb->bdi->state); |
08852b6d6
|
1024 |
while ((work = get_next_work_item(bdi)) != NULL) { |
03ba3782e
|
1025 |
|
455b28646
|
1026 |
trace_writeback_exec(bdi, work); |
83ba7b071
|
1027 |
wrote += wb_writeback(wb, work); |
03ba3782e
|
1028 1029 |
/* |
83ba7b071
|
1030 1031 |
* Notify the caller of completion if this is a synchronous * work item, otherwise just free it. |
03ba3782e
|
1032 |
*/ |
83ba7b071
|
1033 1034 1035 1036 |
if (work->done) complete(work->done); else kfree(work); |
03ba3782e
|
1037 1038 1039 1040 1041 1042 |
} /* * Check for periodic writeback, kupdated() style */ wrote += wb_check_old_data_flush(wb); |
6585027a5
|
1043 |
wrote += wb_check_background_flush(wb); |
81d73a32d
|
1044 |
clear_bit(BDI_writeback_running, &wb->bdi->state); |
03ba3782e
|
1045 1046 1047 1048 1049 1050 |
return wrote; } /* * Handle writeback of dirty data for the device backed by this bdi. Also |
839a8e866
|
1051 |
* reschedules periodically and does kupdated style flushing. |
03ba3782e
|
1052 |
*/ |
839a8e866
|
1053 |
void bdi_writeback_workfn(struct work_struct *work) |
03ba3782e
|
1054 |
{ |
839a8e866
|
1055 1056 |
struct bdi_writeback *wb = container_of(to_delayed_work(work), struct bdi_writeback, dwork); |
082439004
|
1057 |
struct backing_dev_info *bdi = wb->bdi; |
03ba3782e
|
1058 |
long pages_written; |
ef3b10192
|
1059 |
set_worker_desc("flush-%s", dev_name(bdi->dev)); |
766f91641
|
1060 |
current->flags |= PF_SWAPWRITE; |
455b28646
|
1061 |
|
839a8e866
|
1062 |
if (likely(!current_is_workqueue_rescuer() || |
5acda9d12
|
1063 |
!test_bit(BDI_registered, &bdi->state))) { |
6467716a3
|
1064 |
/* |
839a8e866
|
1065 1066 1067 1068 |
* The normal path. Keep writing back @bdi until its * work_list is empty. Note that this path is also taken * if @bdi is shutting down even when we're running off the * rescuer as work_list needs to be drained. |
6467716a3
|
1069 |
*/ |
839a8e866
|
1070 |
do { |
25d130ba2
|
1071 |
pages_written = wb_do_writeback(wb); |
839a8e866
|
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 |
trace_writeback_pages_written(pages_written); } while (!list_empty(&bdi->work_list)); } else { /* * bdi_wq can't get enough workers and we're running off * the emergency worker. Don't hog it. Hopefully, 1024 is * enough for efficient IO. */ pages_written = writeback_inodes_wb(&bdi->wb, 1024, WB_REASON_FORKER_THREAD); |
455b28646
|
1082 |
trace_writeback_pages_written(pages_written); |
03ba3782e
|
1083 |
} |
6ca738d60
|
1084 1085 1086 1087 |
if (!list_empty(&bdi->work_list)) mod_delayed_work(bdi_wq, &wb->dwork, 0); else if (wb_has_dirty_io(wb) && dirty_writeback_interval) bdi_wakeup_thread_delayed(bdi); |
455b28646
|
1088 |
|
839a8e866
|
1089 |
current->flags &= ~PF_SWAPWRITE; |
03ba3782e
|
1090 1091 1092 |
} /* |
b8c2f3474
|
1093 1094 |
* Start writeback of `nr_pages' pages. If `nr_pages' is zero, write back * the whole world. |
03ba3782e
|
1095 |
*/ |
0e175a183
|
1096 |
void wakeup_flusher_threads(long nr_pages, enum wb_reason reason) |
03ba3782e
|
1097 |
{ |
b8c2f3474
|
1098 |
struct backing_dev_info *bdi; |
03ba3782e
|
1099 |
|
47df3dded
|
1100 1101 |
if (!nr_pages) nr_pages = get_nr_dirty_pages(); |
03ba3782e
|
1102 |
|
b8c2f3474
|
1103 |
rcu_read_lock(); |
cfc4ba536
|
1104 |
list_for_each_entry_rcu(bdi, &bdi_list, bdi_list) { |
03ba3782e
|
1105 1106 |
if (!bdi_has_dirty_io(bdi)) continue; |
0e175a183
|
1107 |
__bdi_start_writeback(bdi, nr_pages, false, reason); |
03ba3782e
|
1108 |
} |
cfc4ba536
|
1109 |
rcu_read_unlock(); |
1da177e4c
|
1110 |
} |
a2f487069
|
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 |
/* * Wake up bdi's periodically to make sure dirtytime inodes gets * written back periodically. We deliberately do *not* check the * b_dirtytime list in wb_has_dirty_io(), since this would cause the * kernel to be constantly waking up once there are any dirtytime * inodes on the system. So instead we define a separate delayed work * function which gets called much more rarely. (By default, only * once every 12 hours.) * * If there is any other write activity going on in the file system, * this function won't be necessary. But if the only thing that has * happened on the file system is a dirtytime inode caused by an atime * update, we need this infrastructure below to make sure that inode * eventually gets pushed out to disk. */ static void wakeup_dirtytime_writeback(struct work_struct *w); static DECLARE_DELAYED_WORK(dirtytime_work, wakeup_dirtytime_writeback); static void wakeup_dirtytime_writeback(struct work_struct *w) { struct backing_dev_info *bdi; rcu_read_lock(); list_for_each_entry_rcu(bdi, &bdi_list, bdi_list) { if (list_empty(&bdi->wb.b_dirty_time)) continue; bdi_wakeup_thread(bdi); } rcu_read_unlock(); schedule_delayed_work(&dirtytime_work, dirtytime_expire_interval * HZ); } static int __init start_dirtytime_writeback(void) { schedule_delayed_work(&dirtytime_work, dirtytime_expire_interval * HZ); return 0; } __initcall(start_dirtytime_writeback); |
1efff914a
|
1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 |
int dirtytime_interval_handler(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos) { int ret; ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); if (ret == 0 && write) mod_delayed_work(system_wq, &dirtytime_work, 0); return ret; } |
03ba3782e
|
1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 |
static noinline void block_dump___mark_inode_dirty(struct inode *inode) { if (inode->i_ino || strcmp(inode->i_sb->s_id, "bdev")) { struct dentry *dentry; const char *name = "?"; dentry = d_find_alias(inode); if (dentry) { spin_lock(&dentry->d_lock); name = (const char *) dentry->d_name.name; } printk(KERN_DEBUG "%s(%d): dirtied inode %lu (%s) on %s ", current->comm, task_pid_nr(current), inode->i_ino, name, inode->i_sb->s_id); if (dentry) { spin_unlock(&dentry->d_lock); dput(dentry); } } } /** * __mark_inode_dirty - internal function * @inode: inode to mark * @flags: what kind of dirty (i.e. I_DIRTY_SYNC) * Mark an inode as dirty. Callers should use mark_inode_dirty or * mark_inode_dirty_sync. |
1da177e4c
|
1188 |
* |
03ba3782e
|
1189 1190 1191 1192 1193 1194 1195 1196 1197 |
* Put the inode on the super block's dirty list. * * CAREFUL! We mark it dirty unconditionally, but move it onto the * dirty list only if it is hashed or if it refers to a blockdev. * If it was not hashed, it will never be added to the dirty list * even if it is later hashed, as it will have been marked dirty already. * * In short, make sure you hash any inodes _before_ you start marking * them dirty. |
1da177e4c
|
1198 |
* |
03ba3782e
|
1199 1200 1201 1202 1203 1204 |
* Note that for blockdevs, inode->dirtied_when represents the dirtying time of * the block-special inode (/dev/hda1) itself. And the ->dirtied_when field of * the kernel-internal blockdev inode represents the dirtying time of the * blockdev's pages. This is why for I_DIRTY_PAGES we always use * page->mapping->host, so the page-dirtying time is recorded in the internal * blockdev inode. |
1da177e4c
|
1205 |
*/ |
0ae45f63d
|
1206 |
#define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC) |
03ba3782e
|
1207 |
void __mark_inode_dirty(struct inode *inode, int flags) |
1da177e4c
|
1208 |
{ |
03ba3782e
|
1209 |
struct super_block *sb = inode->i_sb; |
253c34e9b
|
1210 |
struct backing_dev_info *bdi = NULL; |
0ae45f63d
|
1211 1212 1213 |
int dirtytime; trace_writeback_mark_inode_dirty(inode, flags); |
1da177e4c
|
1214 |
|
03ba3782e
|
1215 1216 1217 1218 |
/* * Don't do this for I_DIRTY_PAGES - that doesn't actually * dirty the inode itself */ |
0ae45f63d
|
1219 |
if (flags & (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_TIME)) { |
9fb0a7da0
|
1220 |
trace_writeback_dirty_inode_start(inode, flags); |
03ba3782e
|
1221 |
if (sb->s_op->dirty_inode) |
aa3857295
|
1222 |
sb->s_op->dirty_inode(inode, flags); |
9fb0a7da0
|
1223 1224 |
trace_writeback_dirty_inode(inode, flags); |
03ba3782e
|
1225 |
} |
0ae45f63d
|
1226 1227 1228 |
if (flags & I_DIRTY_INODE) flags &= ~I_DIRTY_TIME; dirtytime = flags & I_DIRTY_TIME; |
03ba3782e
|
1229 1230 |
/* |
9c6ac78eb
|
1231 1232 |
* Paired with smp_mb() in __writeback_single_inode() for the * following lockless i_state test. See there for details. |
03ba3782e
|
1233 1234 |
*/ smp_mb(); |
0ae45f63d
|
1235 1236 |
if (((inode->i_state & flags) == flags) || (dirtytime && (inode->i_state & I_DIRTY_INODE))) |
03ba3782e
|
1237 1238 1239 1240 |
return; if (unlikely(block_dump)) block_dump___mark_inode_dirty(inode); |
250df6ed2
|
1241 |
spin_lock(&inode->i_lock); |
0ae45f63d
|
1242 1243 |
if (dirtytime && (inode->i_state & I_DIRTY_INODE)) goto out_unlock_inode; |
03ba3782e
|
1244 1245 |
if ((inode->i_state & flags) != flags) { const int was_dirty = inode->i_state & I_DIRTY; |
0ae45f63d
|
1246 1247 |
if (flags & I_DIRTY_INODE) inode->i_state &= ~I_DIRTY_TIME; |
03ba3782e
|
1248 1249 1250 1251 1252 1253 1254 1255 |
inode->i_state |= flags; /* * If the inode is being synced, just update its dirty state. * The unlocker will place the inode on the appropriate * superblock list, based upon its state. */ if (inode->i_state & I_SYNC) |
250df6ed2
|
1256 |
goto out_unlock_inode; |
03ba3782e
|
1257 1258 1259 1260 1261 1262 |
/* * Only add valid (hashed) inodes to the superblock's * dirty list. Add blockdev inodes as well. */ if (!S_ISBLK(inode->i_mode)) { |
1d3382cbf
|
1263 |
if (inode_unhashed(inode)) |
250df6ed2
|
1264 |
goto out_unlock_inode; |
03ba3782e
|
1265 |
} |
a4ffdde6e
|
1266 |
if (inode->i_state & I_FREEING) |
250df6ed2
|
1267 |
goto out_unlock_inode; |
03ba3782e
|
1268 1269 1270 1271 1272 1273 |
/* * If the inode was already on b_dirty/b_io/b_more_io, don't * reposition it (that would break b_dirty time-ordering). */ if (!was_dirty) { |
a66979aba
|
1274 |
bool wakeup_bdi = false; |
253c34e9b
|
1275 |
bdi = inode_to_bdi(inode); |
146d7009b
|
1276 1277 |
spin_unlock(&inode->i_lock); spin_lock(&bdi->wb.list_lock); |
253c34e9b
|
1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 |
if (bdi_cap_writeback_dirty(bdi)) { WARN(!test_bit(BDI_registered, &bdi->state), "bdi-%s not registered ", bdi->name); /* * If this is the first dirty inode for this * bdi, we have to wake-up the corresponding * bdi thread to make sure background * write-back happens later. */ if (!wb_has_dirty_io(&bdi->wb)) wakeup_bdi = true; |
500b067c5
|
1291 |
} |
03ba3782e
|
1292 1293 |
inode->dirtied_when = jiffies; |
a2f487069
|
1294 1295 1296 1297 1298 1299 1300 |
if (dirtytime) inode->dirtied_time_when = jiffies; if (inode->i_state & (I_DIRTY_INODE | I_DIRTY_PAGES)) list_move(&inode->i_wb_list, &bdi->wb.b_dirty); else list_move(&inode->i_wb_list, &bdi->wb.b_dirty_time); |
f758eeabe
|
1301 |
spin_unlock(&bdi->wb.list_lock); |
0ae45f63d
|
1302 |
trace_writeback_dirty_inode_enqueue(inode); |
a66979aba
|
1303 1304 1305 1306 |
if (wakeup_bdi) bdi_wakeup_thread_delayed(bdi); return; |
1da177e4c
|
1307 |
} |
1da177e4c
|
1308 |
} |
250df6ed2
|
1309 1310 |
out_unlock_inode: spin_unlock(&inode->i_lock); |
253c34e9b
|
1311 |
|
03ba3782e
|
1312 1313 |
} EXPORT_SYMBOL(__mark_inode_dirty); |
b6e51316d
|
1314 |
static void wait_sb_inodes(struct super_block *sb) |
03ba3782e
|
1315 1316 1317 1318 1319 1320 1321 |
{ struct inode *inode, *old_inode = NULL; /* * We need to be protected against the filesystem going from * r/o to r/w or vice versa. */ |
b6e51316d
|
1322 |
WARN_ON(!rwsem_is_locked(&sb->s_umount)); |
03ba3782e
|
1323 |
|
55fa6091d
|
1324 |
spin_lock(&inode_sb_list_lock); |
03ba3782e
|
1325 1326 1327 1328 1329 1330 1331 1332 |
/* * Data integrity sync. Must wait for all pages under writeback, * because there may have been pages dirtied before our sync * call, but which had writeout started before we write it out. * In which case, the inode may not be on the dirty list, but * we still have to wait for that writeout. */ |
b6e51316d
|
1333 |
list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { |
250df6ed2
|
1334 |
struct address_space *mapping = inode->i_mapping; |
03ba3782e
|
1335 |
|
250df6ed2
|
1336 1337 1338 1339 |
spin_lock(&inode->i_lock); if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) || (mapping->nrpages == 0)) { spin_unlock(&inode->i_lock); |
03ba3782e
|
1340 |
continue; |
250df6ed2
|
1341 |
} |
03ba3782e
|
1342 |
__iget(inode); |
250df6ed2
|
1343 |
spin_unlock(&inode->i_lock); |
55fa6091d
|
1344 |
spin_unlock(&inode_sb_list_lock); |
03ba3782e
|
1345 |
/* |
55fa6091d
|
1346 1347 1348 1349 1350 1351 |
* We hold a reference to 'inode' so it couldn't have been * removed from s_inodes list while we dropped the * inode_sb_list_lock. We cannot iput the inode now as we can * be holding the last reference and we cannot iput it under * inode_sb_list_lock. So we keep the reference and iput it * later. |
03ba3782e
|
1352 1353 1354 1355 1356 1357 1358 |
*/ iput(old_inode); old_inode = inode; filemap_fdatawait(mapping); cond_resched(); |
55fa6091d
|
1359 |
spin_lock(&inode_sb_list_lock); |
03ba3782e
|
1360 |
} |
55fa6091d
|
1361 |
spin_unlock(&inode_sb_list_lock); |
03ba3782e
|
1362 |
iput(old_inode); |
1da177e4c
|
1363 |
} |
d8a8559cd
|
1364 |
/** |
3259f8bed
|
1365 |
* writeback_inodes_sb_nr - writeback dirty inodes from given super_block |
d8a8559cd
|
1366 |
* @sb: the superblock |
3259f8bed
|
1367 |
* @nr: the number of pages to write |
786228ab3
|
1368 |
* @reason: reason why some writeback work initiated |
1da177e4c
|
1369 |
* |
d8a8559cd
|
1370 1371 |
* Start writeback on some inodes on this super_block. No guarantees are made * on how many (if any) will be written, and this function does not wait |
3259f8bed
|
1372 |
* for IO completion of submitted IO. |
1da177e4c
|
1373 |
*/ |
0e175a183
|
1374 1375 1376 |
void writeback_inodes_sb_nr(struct super_block *sb, unsigned long nr, enum wb_reason reason) |
1da177e4c
|
1377 |
{ |
83ba7b071
|
1378 1379 |
DECLARE_COMPLETION_ONSTACK(done); struct wb_writeback_work work = { |
6e6938b6d
|
1380 1381 1382 1383 1384 |
.sb = sb, .sync_mode = WB_SYNC_NONE, .tagged_writepages = 1, .done = &done, .nr_pages = nr, |
0e175a183
|
1385 |
.reason = reason, |
3c4d71653
|
1386 |
}; |
d8a8559cd
|
1387 |
|
6eedc7015
|
1388 1389 |
if (sb->s_bdi == &noop_backing_dev_info) return; |
cf37e9724
|
1390 |
WARN_ON(!rwsem_is_locked(&sb->s_umount)); |
83ba7b071
|
1391 1392 |
bdi_queue_work(sb->s_bdi, &work); wait_for_completion(&done); |
e913fc825
|
1393 |
} |
3259f8bed
|
1394 1395 1396 1397 1398 |
EXPORT_SYMBOL(writeback_inodes_sb_nr); /** * writeback_inodes_sb - writeback dirty inodes from given super_block * @sb: the superblock |
786228ab3
|
1399 |
* @reason: reason why some writeback work was initiated |
3259f8bed
|
1400 1401 1402 1403 1404 |
* * Start writeback on some inodes on this super_block. No guarantees are made * on how many (if any) will be written, and this function does not wait * for IO completion of submitted IO. */ |
0e175a183
|
1405 |
void writeback_inodes_sb(struct super_block *sb, enum wb_reason reason) |
3259f8bed
|
1406 |
{ |
0e175a183
|
1407 |
return writeback_inodes_sb_nr(sb, get_nr_dirty_pages(), reason); |
3259f8bed
|
1408 |
} |
0e3c9a228
|
1409 |
EXPORT_SYMBOL(writeback_inodes_sb); |
e913fc825
|
1410 1411 |
/** |
10ee27a06
|
1412 |
* try_to_writeback_inodes_sb_nr - try to start writeback if none underway |
17bd55d03
|
1413 |
* @sb: the superblock |
10ee27a06
|
1414 1415 |
* @nr: the number of pages to write * @reason: the reason of writeback |
17bd55d03
|
1416 |
* |
10ee27a06
|
1417 |
* Invoke writeback_inodes_sb_nr if no writeback is currently underway. |
17bd55d03
|
1418 1419 |
* Returns 1 if writeback was started, 0 if not. */ |
10ee27a06
|
1420 1421 1422 |
int try_to_writeback_inodes_sb_nr(struct super_block *sb, unsigned long nr, enum wb_reason reason) |
17bd55d03
|
1423 |
{ |
10ee27a06
|
1424 |
if (writeback_in_progress(sb->s_bdi)) |
17bd55d03
|
1425 |
return 1; |
10ee27a06
|
1426 1427 |
if (!down_read_trylock(&sb->s_umount)) |
17bd55d03
|
1428 |
return 0; |
10ee27a06
|
1429 1430 1431 1432 |
writeback_inodes_sb_nr(sb, nr, reason); up_read(&sb->s_umount); return 1; |
17bd55d03
|
1433 |
} |
10ee27a06
|
1434 |
EXPORT_SYMBOL(try_to_writeback_inodes_sb_nr); |
17bd55d03
|
1435 1436 |
/** |
10ee27a06
|
1437 |
* try_to_writeback_inodes_sb - try to start writeback if none underway |
3259f8bed
|
1438 |
* @sb: the superblock |
786228ab3
|
1439 |
* @reason: reason why some writeback work was initiated |
3259f8bed
|
1440 |
* |
10ee27a06
|
1441 |
* Implement by try_to_writeback_inodes_sb_nr() |
3259f8bed
|
1442 1443 |
* Returns 1 if writeback was started, 0 if not. */ |
10ee27a06
|
1444 |
int try_to_writeback_inodes_sb(struct super_block *sb, enum wb_reason reason) |
3259f8bed
|
1445 |
{ |
10ee27a06
|
1446 |
return try_to_writeback_inodes_sb_nr(sb, get_nr_dirty_pages(), reason); |
3259f8bed
|
1447 |
} |
10ee27a06
|
1448 |
EXPORT_SYMBOL(try_to_writeback_inodes_sb); |
3259f8bed
|
1449 1450 |
/** |
d8a8559cd
|
1451 |
* sync_inodes_sb - sync sb inode pages |
0dc83bd30
|
1452 |
* @sb: the superblock |
d8a8559cd
|
1453 1454 |
* * This function writes and waits on any dirty inode belonging to this |
0dc83bd30
|
1455 |
* super_block. |
d8a8559cd
|
1456 |
*/ |
0dc83bd30
|
1457 |
void sync_inodes_sb(struct super_block *sb) |
d8a8559cd
|
1458 |
{ |
83ba7b071
|
1459 1460 |
DECLARE_COMPLETION_ONSTACK(done); struct wb_writeback_work work = { |
3c4d71653
|
1461 1462 1463 1464 |
.sb = sb, .sync_mode = WB_SYNC_ALL, .nr_pages = LONG_MAX, .range_cyclic = 0, |
83ba7b071
|
1465 |
.done = &done, |
0e175a183
|
1466 |
.reason = WB_REASON_SYNC, |
7747bd4bc
|
1467 |
.for_sync = 1, |
3c4d71653
|
1468 |
}; |
6eedc7015
|
1469 1470 1471 |
/* Nothing to do? */ if (sb->s_bdi == &noop_backing_dev_info) return; |
cf37e9724
|
1472 |
WARN_ON(!rwsem_is_locked(&sb->s_umount)); |
83ba7b071
|
1473 1474 |
bdi_queue_work(sb->s_bdi, &work); wait_for_completion(&done); |
b6e51316d
|
1475 |
wait_sb_inodes(sb); |
1da177e4c
|
1476 |
} |
d8a8559cd
|
1477 |
EXPORT_SYMBOL(sync_inodes_sb); |
1da177e4c
|
1478 |
|
1da177e4c
|
1479 |
/** |
7f04c26d7
|
1480 1481 1482 1483 1484 1485 |
* write_inode_now - write an inode to disk * @inode: inode to write to disk * @sync: whether the write should be synchronous or not * * This function commits an inode to disk immediately if it is dirty. This is * primarily needed by knfsd. |
1da177e4c
|
1486 |
* |
7f04c26d7
|
1487 |
* The caller must either have a ref on the inode or must have set I_WILL_FREE. |
1da177e4c
|
1488 |
*/ |
1da177e4c
|
1489 1490 |
int write_inode_now(struct inode *inode, int sync) { |
f758eeabe
|
1491 |
struct bdi_writeback *wb = &inode_to_bdi(inode)->wb; |
1da177e4c
|
1492 1493 |
struct writeback_control wbc = { .nr_to_write = LONG_MAX, |
18914b188
|
1494 |
.sync_mode = sync ? WB_SYNC_ALL : WB_SYNC_NONE, |
111ebb6e6
|
1495 1496 |
.range_start = 0, .range_end = LLONG_MAX, |
1da177e4c
|
1497 1498 1499 |
}; if (!mapping_cap_writeback_dirty(inode->i_mapping)) |
49364ce25
|
1500 |
wbc.nr_to_write = 0; |
1da177e4c
|
1501 1502 |
might_sleep(); |
4f8ad655d
|
1503 |
return writeback_single_inode(inode, wb, &wbc); |
1da177e4c
|
1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 |
} EXPORT_SYMBOL(write_inode_now); /** * sync_inode - write an inode and its pages to disk. * @inode: the inode to sync * @wbc: controls the writeback mode * * sync_inode() will write an inode and its pages to disk. It will also * correctly update the inode on its superblock's dirty inode lists and will * update inode->i_state. * * The caller must have a ref on the inode. */ int sync_inode(struct inode *inode, struct writeback_control *wbc) { |
4f8ad655d
|
1520 |
return writeback_single_inode(inode, &inode_to_bdi(inode)->wb, wbc); |
1da177e4c
|
1521 1522 |
} EXPORT_SYMBOL(sync_inode); |
c37650161
|
1523 1524 |
/** |
c691b9d98
|
1525 |
* sync_inode_metadata - write an inode to disk |
c37650161
|
1526 1527 1528 |
* @inode: the inode to sync * @wait: wait for I/O to complete. * |
c691b9d98
|
1529 |
* Write an inode to disk and adjust its dirty state after completion. |
c37650161
|
1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 |
* * Note: only writes the actual inode, no associated data or other metadata. */ int sync_inode_metadata(struct inode *inode, int wait) { struct writeback_control wbc = { .sync_mode = wait ? WB_SYNC_ALL : WB_SYNC_NONE, .nr_to_write = 0, /* metadata-only */ }; return sync_inode(inode, &wbc); } EXPORT_SYMBOL(sync_inode_metadata); |