Blame view
fs/fs-writeback.c
30.3 KB
1da177e4c Linux-2.6.12-rc2 |
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 Remove Andrew Mor... |
11 |
* 10Apr2002 Andrew Morton |
1da177e4c Linux-2.6.12-rc2 |
12 13 14 15 16 |
* Split out of fs/inode.c * Additions for address_space-based writeback */ #include <linux/kernel.h> |
f5ff8422b Fix warnings with... |
17 |
#include <linux/module.h> |
1da177e4c Linux-2.6.12-rc2 |
18 |
#include <linux/spinlock.h> |
5a0e3ad6a include cleanup: ... |
19 |
#include <linux/slab.h> |
1da177e4c Linux-2.6.12-rc2 |
20 21 22 |
#include <linux/sched.h> #include <linux/fs.h> #include <linux/mm.h> |
03ba3782e writeback: switch... |
23 24 |
#include <linux/kthread.h> #include <linux/freezer.h> |
1da177e4c Linux-2.6.12-rc2 |
25 26 27 28 |
#include <linux/writeback.h> #include <linux/blkdev.h> #include <linux/backing-dev.h> #include <linux/buffer_head.h> |
07f3f05c1 [PATCH] BLOCK: Mo... |
29 |
#include "internal.h" |
1da177e4c Linux-2.6.12-rc2 |
30 |
|
66f3b8e2e writeback: move d... |
31 |
#define inode_to_bdi(inode) ((inode)->i_mapping->backing_dev_info) |
f11b00f3b fs/fs-writeback.c... |
32 |
|
03ba3782e writeback: switch... |
33 |
/* |
d0bceac74 writeback: get ri... |
34 35 36 37 38 |
* We don't actually have pdflush, but this one is exported though /proc... */ int nr_pdflush_threads; /* |
c4a77a6c7 writeback: make w... |
39 40 |
* Passed into wb_writeback(), essentially a subset of writeback_control */ |
83ba7b071 writeback: simpli... |
41 |
struct wb_writeback_work { |
c4a77a6c7 writeback: make w... |
42 43 44 |
long nr_pages; struct super_block *sb; enum writeback_sync_modes sync_mode; |
52957fe1c fs-writeback.c: b... |
45 46 47 |
unsigned int for_kupdate:1; unsigned int range_cyclic:1; unsigned int for_background:1; |
c4a77a6c7 writeback: make w... |
48 |
|
8010c3b63 writeback: add co... |
49 |
struct list_head list; /* pending work list */ |
83ba7b071 writeback: simpli... |
50 |
struct completion *done; /* set if the caller waits */ |
03ba3782e writeback: switch... |
51 |
}; |
f11b00f3b fs/fs-writeback.c... |
52 53 54 55 |
/** * writeback_in_progress - determine whether there is writeback in progress * @bdi: the device's backing_dev_info structure. * |
03ba3782e writeback: switch... |
56 57 |
* Determine whether there is writeback waiting to be handled against a * backing device. |
f11b00f3b fs/fs-writeback.c... |
58 59 60 |
*/ int writeback_in_progress(struct backing_dev_info *bdi) { |
03ba3782e writeback: switch... |
61 |
return !list_empty(&bdi->work_list); |
f11b00f3b fs/fs-writeback.c... |
62 |
} |
83ba7b071 writeback: simpli... |
63 64 |
static void bdi_queue_work(struct backing_dev_info *bdi, struct wb_writeback_work *work) |
03ba3782e writeback: switch... |
65 |
{ |
bcddc3f01 writeback: inline... |
66 |
spin_lock(&bdi->wb_lock); |
83ba7b071 writeback: simpli... |
67 |
list_add_tail(&work->list, &bdi->work_list); |
bcddc3f01 writeback: inline... |
68 |
spin_unlock(&bdi->wb_lock); |
03ba3782e writeback: switch... |
69 70 71 72 73 74 75 76 77 |
/* * If the default thread isn't there, make sure we add it. When * it gets created and wakes up, we'll run this work. */ if (unlikely(list_empty_careful(&bdi->wb_list))) wake_up_process(default_backing_dev_info.wb.task); else { struct bdi_writeback *wb = &bdi->wb; |
1da177e4c Linux-2.6.12-rc2 |
78 |
|
1ef7d9aa3 writeback: fix po... |
79 |
if (wb->task) |
03ba3782e writeback: switch... |
80 |
wake_up_process(wb->task); |
1da177e4c Linux-2.6.12-rc2 |
81 |
} |
1da177e4c Linux-2.6.12-rc2 |
82 |
} |
83ba7b071 writeback: simpli... |
83 84 85 |
static void __bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages, bool range_cyclic, bool for_background) |
1da177e4c Linux-2.6.12-rc2 |
86 |
{ |
83ba7b071 writeback: simpli... |
87 |
struct wb_writeback_work *work; |
03ba3782e writeback: switch... |
88 |
|
bcddc3f01 writeback: inline... |
89 90 91 92 |
/* * This is WB_SYNC_NONE writeback, so if allocation fails just * wakeup the thread for old dirty data writeback */ |
83ba7b071 writeback: simpli... |
93 94 95 96 97 |
work = kzalloc(sizeof(*work), GFP_ATOMIC); if (!work) { if (bdi->wb.task) wake_up_process(bdi->wb.task); return; |
bcddc3f01 writeback: inline... |
98 |
} |
03ba3782e writeback: switch... |
99 |
|
83ba7b071 writeback: simpli... |
100 101 102 103 |
work->sync_mode = WB_SYNC_NONE; work->nr_pages = nr_pages; work->range_cyclic = range_cyclic; work->for_background = for_background; |
03ba3782e writeback: switch... |
104 |
|
83ba7b071 writeback: simpli... |
105 |
bdi_queue_work(bdi, work); |
b6e51316d writeback: separa... |
106 107 108 109 110 111 112 113 114 115 |
} /** * bdi_start_writeback - start writeback * @bdi: the backing device to write from * @nr_pages: the number of pages to write * * Description: * This does WB_SYNC_NONE opportunistic writeback. The IO is only * started when this function returns, we make no guarentees on |
0e3c9a228 Revert "writeback... |
116 |
* completion. Caller need not hold sb s_umount semaphore. |
b6e51316d writeback: separa... |
117 118 |
* */ |
c5444198c writeback: simpli... |
119 |
void bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages) |
b6e51316d writeback: separa... |
120 |
{ |
83ba7b071 writeback: simpli... |
121 |
__bdi_start_writeback(bdi, nr_pages, true, false); |
c5444198c writeback: simpli... |
122 |
} |
d3ddec763 writeback: stop b... |
123 |
|
c5444198c writeback: simpli... |
124 125 126 127 128 129 130 131 132 133 134 |
/** * bdi_start_background_writeback - start background writeback * @bdi: the backing device to write from * * Description: * This does WB_SYNC_NONE background writeback. The IO is only * started when this function returns, we make no guarentees on * completion. Caller need not hold sb s_umount semaphore. */ void bdi_start_background_writeback(struct backing_dev_info *bdi) { |
83ba7b071 writeback: simpli... |
135 |
__bdi_start_writeback(bdi, LONG_MAX, true, true); |
1da177e4c Linux-2.6.12-rc2 |
136 137 138 |
} /* |
6610a0bc8 writeback: fix ti... |
139 140 141 142 |
* 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 writeback: move d... |
143 |
* already the most-recently-dirtied inode on the b_dirty list. If that is |
6610a0bc8 writeback: fix ti... |
144 145 146 147 148 |
* the case then the inode must have been redirtied while it was being written * out and we don't reset its dirtied_when. */ static void redirty_tail(struct inode *inode) { |
03ba3782e writeback: switch... |
149 |
struct bdi_writeback *wb = &inode_to_bdi(inode)->wb; |
6610a0bc8 writeback: fix ti... |
150 |
|
03ba3782e writeback: switch... |
151 |
if (!list_empty(&wb->b_dirty)) { |
66f3b8e2e writeback: move d... |
152 |
struct inode *tail; |
6610a0bc8 writeback: fix ti... |
153 |
|
03ba3782e writeback: switch... |
154 |
tail = list_entry(wb->b_dirty.next, struct inode, i_list); |
66f3b8e2e writeback: move d... |
155 |
if (time_before(inode->dirtied_when, tail->dirtied_when)) |
6610a0bc8 writeback: fix ti... |
156 157 |
inode->dirtied_when = jiffies; } |
03ba3782e writeback: switch... |
158 |
list_move(&inode->i_list, &wb->b_dirty); |
6610a0bc8 writeback: fix ti... |
159 160 161 |
} /* |
66f3b8e2e writeback: move d... |
162 |
* requeue inode for re-scanning after bdi->b_io list is exhausted. |
c986d1e2a writeback: fix ti... |
163 |
*/ |
0e0f4fc22 writeback: fix pe... |
164 |
static void requeue_io(struct inode *inode) |
c986d1e2a writeback: fix ti... |
165 |
{ |
03ba3782e writeback: switch... |
166 167 168 |
struct bdi_writeback *wb = &inode_to_bdi(inode)->wb; list_move(&inode->i_list, &wb->b_more_io); |
c986d1e2a writeback: fix ti... |
169 |
} |
1c0eeaf56 introduce I_SYNC |
170 171 172 173 174 175 176 177 |
static void inode_sync_complete(struct inode *inode) { /* * Prevent speculative execution through spin_unlock(&inode_lock); */ smp_mb(); wake_up_bit(&inode->i_state, __I_SYNC); } |
d2caa3c54 writeback: guard ... |
178 179 180 181 182 183 184 185 |
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 writeback: get ri... |
186 |
* from permanently stopping the whole bdi writeback. |
d2caa3c54 writeback: guard ... |
187 188 189 190 191 |
*/ ret = ret && time_before_eq(inode->dirtied_when, jiffies); #endif return ret; } |
c986d1e2a writeback: fix ti... |
192 |
/* |
2c1365791 writeback: fix ti... |
193 194 195 196 197 198 |
* Move expired dirty inodes from @delaying_queue to @dispatch_queue. */ static void move_expired_inodes(struct list_head *delaying_queue, struct list_head *dispatch_queue, unsigned long *older_than_this) { |
5c03449d3 writeback: move i... |
199 200 |
LIST_HEAD(tmp); struct list_head *pos, *node; |
cf137307c writeback: don't ... |
201 |
struct super_block *sb = NULL; |
5c03449d3 writeback: move i... |
202 |
struct inode *inode; |
cf137307c writeback: don't ... |
203 |
int do_sb_sort = 0; |
5c03449d3 writeback: move i... |
204 |
|
2c1365791 writeback: fix ti... |
205 |
while (!list_empty(delaying_queue)) { |
5c03449d3 writeback: move i... |
206 |
inode = list_entry(delaying_queue->prev, struct inode, i_list); |
2c1365791 writeback: fix ti... |
207 |
if (older_than_this && |
d2caa3c54 writeback: guard ... |
208 |
inode_dirtied_after(inode, *older_than_this)) |
2c1365791 writeback: fix ti... |
209 |
break; |
cf137307c writeback: don't ... |
210 211 212 |
if (sb && sb != inode->i_sb) do_sb_sort = 1; sb = inode->i_sb; |
5c03449d3 writeback: move i... |
213 214 |
list_move(&inode->i_list, &tmp); } |
cf137307c writeback: don't ... |
215 216 217 218 219 |
/* just one sb in list, splice to dispatch_queue and we're done */ if (!do_sb_sort) { list_splice(&tmp, dispatch_queue); return; } |
5c03449d3 writeback: move i... |
220 221 222 223 224 225 226 227 228 |
/* Move inodes from one superblock together */ while (!list_empty(&tmp)) { inode = list_entry(tmp.prev, struct inode, i_list); sb = inode->i_sb; list_for_each_prev_safe(pos, node, &tmp) { inode = list_entry(pos, struct inode, i_list); if (inode->i_sb == sb) list_move(&inode->i_list, dispatch_queue); } |
2c1365791 writeback: fix ti... |
229 230 231 232 233 234 |
} } /* * Queue all expired dirty inodes for io, eldest first. */ |
03ba3782e writeback: switch... |
235 |
static void queue_io(struct bdi_writeback *wb, unsigned long *older_than_this) |
66f3b8e2e writeback: move d... |
236 |
{ |
03ba3782e writeback: switch... |
237 238 |
list_splice_init(&wb->b_more_io, wb->b_io.prev); move_expired_inodes(&wb->b_dirty, &wb->b_io, older_than_this); |
66f3b8e2e writeback: move d... |
239 |
} |
a9185b41a pass writeback_co... |
240 |
static int write_inode(struct inode *inode, struct writeback_control *wbc) |
08d8e9749 writeback: fix nt... |
241 |
{ |
03ba3782e writeback: switch... |
242 |
if (inode->i_sb->s_op->write_inode && !is_bad_inode(inode)) |
a9185b41a pass writeback_co... |
243 |
return inode->i_sb->s_op->write_inode(inode, wbc); |
03ba3782e writeback: switch... |
244 |
return 0; |
08d8e9749 writeback: fix nt... |
245 |
} |
08d8e9749 writeback: fix nt... |
246 |
|
2c1365791 writeback: fix ti... |
247 |
/* |
01c031945 cleanup __writeba... |
248 249 250 251 252 253 254 255 |
* Wait for writeback on an inode to complete. */ static void inode_wait_for_writeback(struct inode *inode) { DEFINE_WAIT_BIT(wq, &inode->i_state, __I_SYNC); wait_queue_head_t *wqh; wqh = bit_waitqueue(&inode->i_state, __I_SYNC); |
58a9d3d8d fs-writeback: che... |
256 |
while (inode->i_state & I_SYNC) { |
01c031945 cleanup __writeba... |
257 258 259 |
spin_unlock(&inode_lock); __wait_on_bit(wqh, &wq, inode_wait, TASK_UNINTERRUPTIBLE); spin_lock(&inode_lock); |
58a9d3d8d fs-writeback: che... |
260 |
} |
01c031945 cleanup __writeba... |
261 262 263 264 265 266 267 |
} /* * Write out an inode's dirty pages. Called under inode_lock. Either the * caller has ref on the inode (either via __iget or via syscall against an fd) * or the inode has I_WILL_FREE set (via generic_forget_inode) * |
1da177e4c Linux-2.6.12-rc2 |
268 269 270 271 272 273 274 275 276 |
* If `wait' is set, wait on the writeout. * * The whole writeout design is quite complex and fragile. We want to avoid * starvation of particular inodes when others are being redirtied, prevent * livelocks, etc. * * Called under inode_lock. */ static int |
01c031945 cleanup __writeba... |
277 |
writeback_single_inode(struct inode *inode, struct writeback_control *wbc) |
1da177e4c Linux-2.6.12-rc2 |
278 |
{ |
1da177e4c Linux-2.6.12-rc2 |
279 |
struct address_space *mapping = inode->i_mapping; |
01c031945 cleanup __writeba... |
280 |
unsigned dirty; |
1da177e4c Linux-2.6.12-rc2 |
281 |
int ret; |
01c031945 cleanup __writeba... |
282 283 284 285 286 287 288 289 |
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 this inode is locked for writeback and we are not doing |
66f3b8e2e writeback: move d... |
290 |
* writeback-for-data-integrity, move it to b_more_io so that |
01c031945 cleanup __writeba... |
291 292 293 |
* writeback can proceed with the other inodes on s_io. * * We'll have another go at writing back this inode when we |
66f3b8e2e writeback: move d... |
294 |
* completed a full scan of b_io. |
01c031945 cleanup __writeba... |
295 |
*/ |
a9185b41a pass writeback_co... |
296 |
if (wbc->sync_mode != WB_SYNC_ALL) { |
01c031945 cleanup __writeba... |
297 298 299 300 301 302 303 304 305 |
requeue_io(inode); return 0; } /* * It's a data-integrity sync. We must wait. */ inode_wait_for_writeback(inode); } |
1c0eeaf56 introduce I_SYNC |
306 |
BUG_ON(inode->i_state & I_SYNC); |
1da177e4c Linux-2.6.12-rc2 |
307 |
|
5547e8aac writeback: Update... |
308 |
/* Set I_SYNC, reset I_DIRTY_PAGES */ |
1c0eeaf56 introduce I_SYNC |
309 |
inode->i_state |= I_SYNC; |
5547e8aac writeback: Update... |
310 |
inode->i_state &= ~I_DIRTY_PAGES; |
1da177e4c Linux-2.6.12-rc2 |
311 312 313 |
spin_unlock(&inode_lock); ret = do_writepages(mapping, wbc); |
26821ed40 make sure data is... |
314 315 316 317 318 |
/* * Make sure to wait on the data before writing out the metadata. * This is important for filesystems that modify metadata on data * I/O completion. */ |
a9185b41a pass writeback_co... |
319 |
if (wbc->sync_mode == WB_SYNC_ALL) { |
26821ed40 make sure data is... |
320 |
int err = filemap_fdatawait(mapping); |
1da177e4c Linux-2.6.12-rc2 |
321 322 323 |
if (ret == 0) ret = err; } |
5547e8aac writeback: Update... |
324 325 326 327 328 329 330 331 332 |
/* * Some filesystems may redirty the inode during the writeback * due to delalloc, clear dirty metadata flags right before * write_inode() */ spin_lock(&inode_lock); dirty = inode->i_state & I_DIRTY; inode->i_state &= ~(I_DIRTY_SYNC | I_DIRTY_DATASYNC); spin_unlock(&inode_lock); |
26821ed40 make sure data is... |
333 334 |
/* Don't write the inode if only I_DIRTY_PAGES was set */ if (dirty & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) { |
a9185b41a pass writeback_co... |
335 |
int err = write_inode(inode, wbc); |
1da177e4c Linux-2.6.12-rc2 |
336 337 338 339 340 |
if (ret == 0) ret = err; } spin_lock(&inode_lock); |
1c0eeaf56 introduce I_SYNC |
341 |
inode->i_state &= ~I_SYNC; |
84a892456 writeback: skip n... |
342 |
if (!(inode->i_state & (I_FREEING | I_CLEAR))) { |
b3af9468a writeback: don't ... |
343 |
if ((inode->i_state & I_DIRTY_PAGES) && wbc->for_kupdate) { |
ae1b7f7d4 writeback: cleanu... |
344 |
/* |
b3af9468a writeback: don't ... |
345 346 347 348 349 350 351 |
* More pages get dirtied by a fast dirtier. */ goto select_queue; } else if (inode->i_state & I_DIRTY) { /* * At least XFS will redirty the inode during the * writeback (delalloc) and on io completion (isize). |
ae1b7f7d4 writeback: cleanu... |
352 353 354 |
*/ redirty_tail(inode); } else if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) { |
1da177e4c Linux-2.6.12-rc2 |
355 356 357 |
/* * We didn't write back all the pages. nfs_writepages() * sometimes bales out without doing anything. Redirty |
66f3b8e2e writeback: move d... |
358 |
* the inode; Move it from b_io onto b_more_io/b_dirty. |
1b43ef91d writeback: fix co... |
359 360 361 |
*/ /* * akpm: if the caller was the kupdate function we put |
66f3b8e2e writeback: move d... |
362 |
* this inode at the head of b_dirty so it gets first |
1b43ef91d writeback: fix co... |
363 364 365 366 367 |
* consideration. Otherwise, move it to the tail, for * the reasons described there. I'm not really sure * how much sense this makes. Presumably I had a good * reasons for doing it this way, and I'd rather not * muck with it at present. |
1da177e4c Linux-2.6.12-rc2 |
368 369 370 |
*/ if (wbc->for_kupdate) { /* |
2c1365791 writeback: fix ti... |
371 |
* For the kupdate function we move the inode |
66f3b8e2e writeback: move d... |
372 |
* to b_more_io so it will get more writeout as |
2c1365791 writeback: fix ti... |
373 |
* soon as the queue becomes uncongested. |
1da177e4c Linux-2.6.12-rc2 |
374 375 |
*/ inode->i_state |= I_DIRTY_PAGES; |
b3af9468a writeback: don't ... |
376 |
select_queue: |
8bc3be275 writeback: speed ... |
377 378 379 380 381 382 383 384 385 386 387 |
if (wbc->nr_to_write <= 0) { /* * slice used up: queue for next turn */ requeue_io(inode); } else { /* * somehow blocked: retry later */ redirty_tail(inode); } |
1da177e4c Linux-2.6.12-rc2 |
388 389 390 391 392 393 394 395 396 |
} else { /* * Otherwise fully redirty the inode so that * other inodes on this superblock will get some * writeout. Otherwise heavy writing to one * file would indefinitely suspend writeout of * all the other files. */ inode->i_state |= I_DIRTY_PAGES; |
1b43ef91d writeback: fix co... |
397 |
redirty_tail(inode); |
1da177e4c Linux-2.6.12-rc2 |
398 |
} |
1da177e4c Linux-2.6.12-rc2 |
399 400 401 402 403 404 405 406 407 408 |
} else if (atomic_read(&inode->i_count)) { /* * The inode is clean, inuse */ list_move(&inode->i_list, &inode_in_use); } else { /* * The inode is clean, unused */ list_move(&inode->i_list, &inode_unused); |
1da177e4c Linux-2.6.12-rc2 |
409 410 |
} } |
1c0eeaf56 introduce I_SYNC |
411 |
inode_sync_complete(inode); |
1da177e4c Linux-2.6.12-rc2 |
412 413 |
return ret; } |
03ba3782e writeback: switch... |
414 |
/* |
d19de7edf writeback: fix wr... |
415 |
* For background writeback the caller does not have the sb pinned |
03ba3782e writeback: switch... |
416 417 |
* before calling writeback. So make sure that we do pin it, so it doesn't * go away while we are writing inodes from it. |
03ba3782e writeback: switch... |
418 |
*/ |
d19de7edf writeback: fix wr... |
419 |
static bool pin_sb_for_writeback(struct super_block *sb) |
03ba3782e writeback: switch... |
420 |
{ |
03ba3782e writeback: switch... |
421 |
spin_lock(&sb_lock); |
29cb48594 writeback: fix pi... |
422 423 424 425 |
if (list_empty(&sb->s_instances)) { spin_unlock(&sb_lock); return false; } |
03ba3782e writeback: switch... |
426 |
sb->s_count++; |
29cb48594 writeback: fix pi... |
427 |
spin_unlock(&sb_lock); |
03ba3782e writeback: switch... |
428 |
if (down_read_trylock(&sb->s_umount)) { |
29cb48594 writeback: fix pi... |
429 |
if (sb->s_root) |
d19de7edf writeback: fix wr... |
430 |
return true; |
03ba3782e writeback: switch... |
431 432 |
up_read(&sb->s_umount); } |
29cb48594 writeback: fix pi... |
433 434 |
put_super(sb); |
d19de7edf writeback: fix wr... |
435 |
return false; |
03ba3782e writeback: switch... |
436 |
} |
f11c9c5c2 vfs: improve writ... |
437 438 |
/* * Write a portion of b_io inodes which belong to @sb. |
edadfb10b writeback: split ... |
439 440 |
* * If @only_this_sb is true, then find and write all such |
f11c9c5c2 vfs: improve writ... |
441 442 |
* inodes. Otherwise write only ones which go sequentially * in reverse order. |
edadfb10b writeback: split ... |
443 |
* |
f11c9c5c2 vfs: improve writ... |
444 445 446 |
* Return 1, if the caller writeback routine should be * interrupted. Otherwise return 0. */ |
edadfb10b writeback: split ... |
447 448 |
static int writeback_sb_inodes(struct super_block *sb, struct bdi_writeback *wb, struct writeback_control *wbc, bool only_this_sb) |
1da177e4c Linux-2.6.12-rc2 |
449 |
{ |
03ba3782e writeback: switch... |
450 |
while (!list_empty(&wb->b_io)) { |
1da177e4c Linux-2.6.12-rc2 |
451 |
long pages_skipped; |
f11c9c5c2 vfs: improve writ... |
452 453 |
struct inode *inode = list_entry(wb->b_io.prev, struct inode, i_list); |
edadfb10b writeback: split ... |
454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 |
if (inode->i_sb != sb) { if (only_this_sb) { /* * We only want to write back data for this * superblock, move all inodes not belonging * to it back onto the dirty list. */ redirty_tail(inode); continue; } /* * The inode belongs to a different superblock. * Bounce back to the caller to unpin this and * pin the next superblock. */ |
f11c9c5c2 vfs: improve writ... |
471 |
return 0; |
edadfb10b writeback: split ... |
472 |
} |
84a892456 writeback: skip n... |
473 |
if (inode->i_state & (I_NEW | I_WILL_FREE)) { |
7ef0d7377 fs: new inode i_s... |
474 475 476 |
requeue_io(inode); continue; } |
d2caa3c54 writeback: guard ... |
477 478 479 480 |
/* * Was this inode dirtied after sync_sb_inodes was called? * This keeps sync from extra jobs and livelock. */ |
f11c9c5c2 vfs: improve writ... |
481 482 |
if (inode_dirtied_after(inode, wbc->wb_start)) return 1; |
1da177e4c Linux-2.6.12-rc2 |
483 |
|
84a892456 writeback: skip n... |
484 |
BUG_ON(inode->i_state & (I_FREEING | I_CLEAR)); |
1da177e4c Linux-2.6.12-rc2 |
485 486 |
__iget(inode); pages_skipped = wbc->pages_skipped; |
01c031945 cleanup __writeba... |
487 |
writeback_single_inode(inode, wbc); |
1da177e4c Linux-2.6.12-rc2 |
488 489 490 491 492 |
if (wbc->pages_skipped != pages_skipped) { /* * writeback is not making progress due to locked * buffers. Skip this inode for now. */ |
f57b9b7b4 writeback: fix ti... |
493 |
redirty_tail(inode); |
1da177e4c Linux-2.6.12-rc2 |
494 495 |
} spin_unlock(&inode_lock); |
1da177e4c Linux-2.6.12-rc2 |
496 |
iput(inode); |
4ffc84442 [PATCH] Move cond... |
497 |
cond_resched(); |
1da177e4c Linux-2.6.12-rc2 |
498 |
spin_lock(&inode_lock); |
8bc3be275 writeback: speed ... |
499 500 |
if (wbc->nr_to_write <= 0) { wbc->more_io = 1; |
f11c9c5c2 vfs: improve writ... |
501 |
return 1; |
8bc3be275 writeback: speed ... |
502 |
} |
03ba3782e writeback: switch... |
503 |
if (!list_empty(&wb->b_more_io)) |
8bc3be275 writeback: speed ... |
504 |
wbc->more_io = 1; |
1da177e4c Linux-2.6.12-rc2 |
505 |
} |
f11c9c5c2 vfs: improve writ... |
506 507 508 |
/* b_io is empty */ return 1; } |
9c3a8ee8a writeback: remove... |
509 510 |
void writeback_inodes_wb(struct bdi_writeback *wb, struct writeback_control *wbc) |
f11c9c5c2 vfs: improve writ... |
511 512 513 514 515 516 517 |
{ int ret = 0; wbc->wb_start = jiffies; /* livelock avoidance */ spin_lock(&inode_lock); if (!wbc->for_kupdate || list_empty(&wb->b_io)) queue_io(wb, wbc->older_than_this); |
38f219776 fs: sync_sb_inode... |
518 |
|
f11c9c5c2 vfs: improve writ... |
519 520 521 522 |
while (!list_empty(&wb->b_io)) { struct inode *inode = list_entry(wb->b_io.prev, struct inode, i_list); struct super_block *sb = inode->i_sb; |
9ecc2738a writeback: make t... |
523 |
|
edadfb10b writeback: split ... |
524 525 526 |
if (!pin_sb_for_writeback(sb)) { requeue_io(inode); continue; |
f11c9c5c2 vfs: improve writ... |
527 |
} |
edadfb10b writeback: split ... |
528 529 |
ret = writeback_sb_inodes(sb, wb, wbc, false); drop_super(sb); |
f11c9c5c2 vfs: improve writ... |
530 |
|
f11c9c5c2 vfs: improve writ... |
531 532 533 |
if (ret) break; } |
66f3b8e2e writeback: move d... |
534 535 536 |
spin_unlock(&inode_lock); /* Leave any unwritten inodes on b_io */ } |
edadfb10b writeback: split ... |
537 538 539 540 541 542 543 544 545 546 547 548 |
static void __writeback_inodes_sb(struct super_block *sb, struct bdi_writeback *wb, struct writeback_control *wbc) { WARN_ON(!rwsem_is_locked(&sb->s_umount)); wbc->wb_start = jiffies; /* livelock avoidance */ spin_lock(&inode_lock); if (!wbc->for_kupdate || list_empty(&wb->b_io)) queue_io(wb, wbc->older_than_this); writeback_sb_inodes(sb, wb, wbc, true); spin_unlock(&inode_lock); } |
66f3b8e2e writeback: move d... |
549 |
/* |
03ba3782e writeback: switch... |
550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 |
* The maximum number of pages to writeout in a single bdi flush/kupdate * operation. We do this so we don't hold I_SYNC against an inode for * enormous amounts of time, which would block a userspace task which has * been forced to throttle against that inode. Also, the code reevaluates * the dirty each time it has written this many pages. */ #define MAX_WRITEBACK_PAGES 1024 static inline bool over_bground_thresh(void) { unsigned long background_thresh, dirty_thresh; get_dirty_limits(&background_thresh, &dirty_thresh, NULL, NULL); return (global_page_state(NR_FILE_DIRTY) + global_page_state(NR_UNSTABLE_NFS) >= background_thresh); } /* * Explicit flushing or periodic writeback of "old" data. |
66f3b8e2e writeback: move d... |
570 |
* |
03ba3782e writeback: switch... |
571 572 573 574 |
* 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 writeback: move d... |
575 |
* |
03ba3782e writeback: switch... |
576 577 578 |
* 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 writeback: move d... |
579 |
* |
03ba3782e writeback: switch... |
580 581 |
* 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 writeback: move d... |
582 |
*/ |
c4a77a6c7 writeback: make w... |
583 |
static long wb_writeback(struct bdi_writeback *wb, |
83ba7b071 writeback: simpli... |
584 |
struct wb_writeback_work *work) |
66f3b8e2e writeback: move d... |
585 |
{ |
03ba3782e writeback: switch... |
586 |
struct writeback_control wbc = { |
83ba7b071 writeback: simpli... |
587 |
.sync_mode = work->sync_mode, |
03ba3782e writeback: switch... |
588 |
.older_than_this = NULL, |
83ba7b071 writeback: simpli... |
589 590 591 |
.for_kupdate = work->for_kupdate, .for_background = work->for_background, .range_cyclic = work->range_cyclic, |
03ba3782e writeback: switch... |
592 593 594 |
}; unsigned long oldest_jif; long wrote = 0; |
a5989bdc9 fs: Fix busyloop ... |
595 |
struct inode *inode; |
66f3b8e2e writeback: move d... |
596 |
|
03ba3782e writeback: switch... |
597 598 599 600 601 |
if (wbc.for_kupdate) { wbc.older_than_this = &oldest_jif; oldest_jif = jiffies - msecs_to_jiffies(dirty_expire_interval * 10); } |
c4a77a6c7 writeback: make w... |
602 603 604 605 |
if (!wbc.range_cyclic) { wbc.range_start = 0; wbc.range_end = LLONG_MAX; } |
38f219776 fs: sync_sb_inode... |
606 |
|
03ba3782e writeback: switch... |
607 608 |
for (;;) { /* |
d3ddec763 writeback: stop b... |
609 |
* Stop writeback when nr_pages has been consumed |
03ba3782e writeback: switch... |
610 |
*/ |
83ba7b071 writeback: simpli... |
611 |
if (work->nr_pages <= 0) |
03ba3782e writeback: switch... |
612 |
break; |
66f3b8e2e writeback: move d... |
613 |
|
38f219776 fs: sync_sb_inode... |
614 |
/* |
d3ddec763 writeback: stop b... |
615 616 |
* For background writeout, stop when we are below the * background dirty threshold |
38f219776 fs: sync_sb_inode... |
617 |
*/ |
83ba7b071 writeback: simpli... |
618 |
if (work->for_background && !over_bground_thresh()) |
03ba3782e writeback: switch... |
619 |
break; |
38f219776 fs: sync_sb_inode... |
620 |
|
03ba3782e writeback: switch... |
621 |
wbc.more_io = 0; |
03ba3782e writeback: switch... |
622 623 |
wbc.nr_to_write = MAX_WRITEBACK_PAGES; wbc.pages_skipped = 0; |
83ba7b071 writeback: simpli... |
624 625 |
if (work->sb) __writeback_inodes_sb(work->sb, wb, &wbc); |
edadfb10b writeback: split ... |
626 627 |
else writeback_inodes_wb(wb, &wbc); |
83ba7b071 writeback: simpli... |
628 |
work->nr_pages -= MAX_WRITEBACK_PAGES - wbc.nr_to_write; |
03ba3782e writeback: switch... |
629 630 631 |
wrote += MAX_WRITEBACK_PAGES - wbc.nr_to_write; /* |
71fd05a88 writeback: improv... |
632 |
* If we consumed everything, see if we have more |
03ba3782e writeback: switch... |
633 |
*/ |
71fd05a88 writeback: improv... |
634 635 636 637 638 639 |
if (wbc.nr_to_write <= 0) continue; /* * Didn't write everything and we don't have more IO, bail */ if (!wbc.more_io) |
03ba3782e writeback: switch... |
640 |
break; |
71fd05a88 writeback: improv... |
641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 |
/* * Did we write something? Try for more */ if (wbc.nr_to_write < MAX_WRITEBACK_PAGES) continue; /* * Nothing written. Wait for some inode to * become available for writeback. Otherwise * we'll just busyloop. */ spin_lock(&inode_lock); if (!list_empty(&wb->b_more_io)) { inode = list_entry(wb->b_more_io.prev, struct inode, i_list); inode_wait_for_writeback(inode); |
03ba3782e writeback: switch... |
656 |
} |
71fd05a88 writeback: improv... |
657 |
spin_unlock(&inode_lock); |
03ba3782e writeback: switch... |
658 659 660 661 662 663 |
} return wrote; } /* |
83ba7b071 writeback: simpli... |
664 |
* Return the next wb_writeback_work struct that hasn't been processed yet. |
03ba3782e writeback: switch... |
665 |
*/ |
83ba7b071 writeback: simpli... |
666 667 |
static struct wb_writeback_work * get_next_work_item(struct backing_dev_info *bdi, struct bdi_writeback *wb) |
03ba3782e writeback: switch... |
668 |
{ |
83ba7b071 writeback: simpli... |
669 |
struct wb_writeback_work *work = NULL; |
03ba3782e writeback: switch... |
670 |
|
83ba7b071 writeback: simpli... |
671 672 673 674 675 |
spin_lock(&bdi->wb_lock); if (!list_empty(&bdi->work_list)) { work = list_entry(bdi->work_list.next, struct wb_writeback_work, list); list_del_init(&work->list); |
03ba3782e writeback: switch... |
676 |
} |
83ba7b071 writeback: simpli... |
677 678 |
spin_unlock(&bdi->wb_lock); return work; |
03ba3782e writeback: switch... |
679 680 681 682 683 684 |
} static long wb_check_old_data_flush(struct bdi_writeback *wb) { unsigned long expired; long nr_pages; |
69b62d01e writeback: disabl... |
685 686 687 688 689 |
/* * When set to zero, disable periodic writeback */ if (!dirty_writeback_interval) return 0; |
03ba3782e writeback: switch... |
690 691 692 693 694 695 696 697 698 |
expired = wb->last_old_flush + msecs_to_jiffies(dirty_writeback_interval * 10); if (time_before(jiffies, expired)) return 0; wb->last_old_flush = jiffies; nr_pages = global_page_state(NR_FILE_DIRTY) + global_page_state(NR_UNSTABLE_NFS) + (inodes_stat.nr_inodes - inodes_stat.nr_unused); |
c4a77a6c7 writeback: make w... |
699 |
if (nr_pages) { |
83ba7b071 writeback: simpli... |
700 |
struct wb_writeback_work work = { |
c4a77a6c7 writeback: make w... |
701 702 703 704 705 |
.nr_pages = nr_pages, .sync_mode = WB_SYNC_NONE, .for_kupdate = 1, .range_cyclic = 1, }; |
83ba7b071 writeback: simpli... |
706 |
return wb_writeback(wb, &work); |
c4a77a6c7 writeback: make w... |
707 |
} |
03ba3782e writeback: switch... |
708 709 710 711 712 713 714 715 716 717 |
return 0; } /* * Retrieve work items and do the writeback they describe */ long wb_do_writeback(struct bdi_writeback *wb, int force_wait) { struct backing_dev_info *bdi = wb->bdi; |
83ba7b071 writeback: simpli... |
718 |
struct wb_writeback_work *work; |
c4a77a6c7 writeback: make w... |
719 |
long wrote = 0; |
03ba3782e writeback: switch... |
720 721 |
while ((work = get_next_work_item(bdi, wb)) != NULL) { |
03ba3782e writeback: switch... |
722 723 |
/* * Override sync mode, in case we must wait for completion |
83ba7b071 writeback: simpli... |
724 |
* because this thread is exiting now. |
03ba3782e writeback: switch... |
725 726 |
*/ if (force_wait) |
83ba7b071 writeback: simpli... |
727 |
work->sync_mode = WB_SYNC_ALL; |
03ba3782e writeback: switch... |
728 |
|
83ba7b071 writeback: simpli... |
729 |
wrote += wb_writeback(wb, work); |
03ba3782e writeback: switch... |
730 731 |
/* |
83ba7b071 writeback: simpli... |
732 733 |
* Notify the caller of completion if this is a synchronous * work item, otherwise just free it. |
03ba3782e writeback: switch... |
734 |
*/ |
83ba7b071 writeback: simpli... |
735 736 737 738 |
if (work->done) complete(work->done); else kfree(work); |
03ba3782e writeback: switch... |
739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 |
} /* * Check for periodic writeback, kupdated() style */ wrote += wb_check_old_data_flush(wb); return wrote; } /* * Handle writeback of dirty data for the device backed by this bdi. Also * wakes up periodically and does kupdated style flushing. */ int bdi_writeback_task(struct bdi_writeback *wb) { unsigned long last_active = jiffies; unsigned long wait_jiffies = -1UL; long pages_written; while (!kthread_should_stop()) { pages_written = wb_do_writeback(wb, 0); if (pages_written) last_active = jiffies; else if (wait_jiffies != -1UL) { unsigned long max_idle; |
38f219776 fs: sync_sb_inode... |
766 |
/* |
03ba3782e writeback: switch... |
767 768 769 |
* Longest period of inactivity that we tolerate. If we * see dirty data again later, the task will get * recreated automatically. |
38f219776 fs: sync_sb_inode... |
770 |
*/ |
03ba3782e writeback: switch... |
771 772 773 774 |
max_idle = max(5UL * 60 * HZ, wait_jiffies); if (time_after(jiffies, max_idle + last_active)) break; } |
69b62d01e writeback: disabl... |
775 776 777 |
if (dirty_writeback_interval) { wait_jiffies = msecs_to_jiffies(dirty_writeback_interval * 10); schedule_timeout_interruptible(wait_jiffies); |
f9eadbbd4 writeback: bdi_wr... |
778 779 780 781 782 783 784 |
} else { set_current_state(TASK_INTERRUPTIBLE); if (list_empty_careful(&wb->bdi->work_list) && !kthread_should_stop()) schedule(); __set_current_state(TASK_RUNNING); } |
69b62d01e writeback: disabl... |
785 |
|
03ba3782e writeback: switch... |
786 787 788 789 790 791 792 |
try_to_freeze(); } return 0; } /* |
b8c2f3474 writeback: simpli... |
793 794 |
* Start writeback of `nr_pages' pages. If `nr_pages' is zero, write back * the whole world. |
03ba3782e writeback: switch... |
795 |
*/ |
b8c2f3474 writeback: simpli... |
796 |
void wakeup_flusher_threads(long nr_pages) |
03ba3782e writeback: switch... |
797 |
{ |
b8c2f3474 writeback: simpli... |
798 |
struct backing_dev_info *bdi; |
03ba3782e writeback: switch... |
799 |
|
83ba7b071 writeback: simpli... |
800 801 |
if (!nr_pages) { nr_pages = global_page_state(NR_FILE_DIRTY) + |
b8c2f3474 writeback: simpli... |
802 803 |
global_page_state(NR_UNSTABLE_NFS); } |
03ba3782e writeback: switch... |
804 |
|
b8c2f3474 writeback: simpli... |
805 |
rcu_read_lock(); |
cfc4ba536 writeback: use RC... |
806 |
list_for_each_entry_rcu(bdi, &bdi_list, bdi_list) { |
03ba3782e writeback: switch... |
807 808 |
if (!bdi_has_dirty_io(bdi)) continue; |
83ba7b071 writeback: simpli... |
809 |
__bdi_start_writeback(bdi, nr_pages, false, false); |
03ba3782e writeback: switch... |
810 |
} |
cfc4ba536 writeback: use RC... |
811 |
rcu_read_unlock(); |
1da177e4c Linux-2.6.12-rc2 |
812 |
} |
03ba3782e writeback: switch... |
813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 |
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 Linux-2.6.12-rc2 |
842 |
* |
03ba3782e writeback: switch... |
843 844 845 846 847 848 849 850 851 |
* 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 Linux-2.6.12-rc2 |
852 |
* |
03ba3782e writeback: switch... |
853 854 |
* This function *must* be atomic for the I_DIRTY_PAGES case - * set_page_dirty() is called under spinlock in several places. |
1da177e4c Linux-2.6.12-rc2 |
855 |
* |
03ba3782e writeback: switch... |
856 857 858 859 860 861 |
* 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 Linux-2.6.12-rc2 |
862 |
*/ |
03ba3782e writeback: switch... |
863 |
void __mark_inode_dirty(struct inode *inode, int flags) |
1da177e4c Linux-2.6.12-rc2 |
864 |
{ |
03ba3782e writeback: switch... |
865 |
struct super_block *sb = inode->i_sb; |
1da177e4c Linux-2.6.12-rc2 |
866 |
|
03ba3782e writeback: switch... |
867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 |
/* * Don't do this for I_DIRTY_PAGES - that doesn't actually * dirty the inode itself */ if (flags & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) { if (sb->s_op->dirty_inode) sb->s_op->dirty_inode(inode); } /* * make sure that changes are seen by all cpus before we test i_state * -- mikulas */ smp_mb(); /* avoid the locking if we can */ if ((inode->i_state & flags) == flags) return; if (unlikely(block_dump)) block_dump___mark_inode_dirty(inode); spin_lock(&inode_lock); if ((inode->i_state & flags) != flags) { const int was_dirty = inode->i_state & I_DIRTY; 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) goto out; /* * Only add valid (hashed) inodes to the superblock's * dirty list. Add blockdev inodes as well. */ if (!S_ISBLK(inode->i_mode)) { if (hlist_unhashed(&inode->i_hash)) goto out; } if (inode->i_state & (I_FREEING|I_CLEAR)) goto out; /* * 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) { struct bdi_writeback *wb = &inode_to_bdi(inode)->wb; |
500b067c5 writeback: check ... |
920 921 922 923 924 925 926 927 928 |
struct backing_dev_info *bdi = wb->bdi; if (bdi_cap_writeback_dirty(bdi) && !test_bit(BDI_registered, &bdi->state)) { WARN_ON(1); printk(KERN_ERR "bdi-%s not registered ", bdi->name); } |
03ba3782e writeback: switch... |
929 930 931 |
inode->dirtied_when = jiffies; list_move(&inode->i_list, &wb->b_dirty); |
1da177e4c Linux-2.6.12-rc2 |
932 |
} |
1da177e4c Linux-2.6.12-rc2 |
933 |
} |
03ba3782e writeback: switch... |
934 935 936 937 938 939 940 941 942 943 944 945 |
out: spin_unlock(&inode_lock); } EXPORT_SYMBOL(__mark_inode_dirty); /* * Write out a superblock's list of dirty inodes. A wait will be performed * upon no inodes, all inodes or the final one, depending upon sync_mode. * * If older_than_this is non-NULL, then only write out inodes which * had their first dirtying at a time earlier than *older_than_this. * |
03ba3782e writeback: switch... |
946 947 948 949 950 951 952 953 954 955 |
* If `bdi' is non-zero then we're being asked to writeback a specific queue. * This function assumes that the blockdev superblock's inodes are backed by * a variety of queues, so all inodes are searched. For other superblocks, * assume that all inodes are backed by the same queue. * * The inodes to be written are parked on bdi->b_io. They are moved back onto * bdi->b_dirty as they are selected for writing. This way, none can be missed * on the writer throttling path, and we get decent balancing between many * throttled threads: we don't want them all piling up on inode_sync_wait. */ |
b6e51316d writeback: separa... |
956 |
static void wait_sb_inodes(struct super_block *sb) |
03ba3782e writeback: switch... |
957 958 959 960 961 962 963 |
{ 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 writeback: separa... |
964 |
WARN_ON(!rwsem_is_locked(&sb->s_umount)); |
03ba3782e writeback: switch... |
965 966 967 968 969 970 971 972 973 974 |
spin_lock(&inode_lock); /* * 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 writeback: separa... |
975 |
list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { |
03ba3782e writeback: switch... |
976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 |
struct address_space *mapping; if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE|I_NEW)) continue; mapping = inode->i_mapping; if (mapping->nrpages == 0) continue; __iget(inode); spin_unlock(&inode_lock); /* * We hold a reference to 'inode' so it couldn't have * been removed from s_inodes list while we dropped the * inode_lock. We cannot iput the inode now as we can * be holding the last reference and we cannot iput it * under inode_lock. So we keep the reference and iput * it later. */ iput(old_inode); old_inode = inode; filemap_fdatawait(mapping); cond_resched(); spin_lock(&inode_lock); } spin_unlock(&inode_lock); iput(old_inode); |
1da177e4c Linux-2.6.12-rc2 |
1004 |
} |
d8a8559cd writeback: get ri... |
1005 1006 1007 |
/** * writeback_inodes_sb - writeback dirty inodes from given super_block * @sb: the superblock |
1da177e4c Linux-2.6.12-rc2 |
1008 |
* |
d8a8559cd writeback: get ri... |
1009 1010 1011 1012 |
* 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. The number of pages submitted is * returned. |
1da177e4c Linux-2.6.12-rc2 |
1013 |
*/ |
b6e51316d writeback: separa... |
1014 |
void writeback_inodes_sb(struct super_block *sb) |
1da177e4c Linux-2.6.12-rc2 |
1015 |
{ |
0e3c9a228 Revert "writeback... |
1016 1017 |
unsigned long nr_dirty = global_page_state(NR_FILE_DIRTY); unsigned long nr_unstable = global_page_state(NR_UNSTABLE_NFS); |
83ba7b071 writeback: simpli... |
1018 1019 |
DECLARE_COMPLETION_ONSTACK(done); struct wb_writeback_work work = { |
3c4d71653 writeback: queue ... |
1020 1021 |
.sb = sb, .sync_mode = WB_SYNC_NONE, |
83ba7b071 writeback: simpli... |
1022 |
.done = &done, |
3c4d71653 writeback: queue ... |
1023 |
}; |
d8a8559cd writeback: get ri... |
1024 |
|
cf37e9724 writeback: enforc... |
1025 |
WARN_ON(!rwsem_is_locked(&sb->s_umount)); |
83ba7b071 writeback: simpli... |
1026 |
work.nr_pages = nr_dirty + nr_unstable + |
0e3c9a228 Revert "writeback... |
1027 |
(inodes_stat.nr_inodes - inodes_stat.nr_unused); |
83ba7b071 writeback: simpli... |
1028 1029 |
bdi_queue_work(sb->s_bdi, &work); wait_for_completion(&done); |
e913fc825 writeback: fix WB... |
1030 |
} |
0e3c9a228 Revert "writeback... |
1031 |
EXPORT_SYMBOL(writeback_inodes_sb); |
e913fc825 writeback: fix WB... |
1032 1033 |
/** |
17bd55d03 fs-writeback: Add... |
1034 1035 1036 1037 1038 1039 1040 1041 1042 |
* writeback_inodes_sb_if_idle - start writeback if none underway * @sb: the superblock * * Invoke writeback_inodes_sb if no writeback is currently underway. * Returns 1 if writeback was started, 0 if not. */ int writeback_inodes_sb_if_idle(struct super_block *sb) { if (!writeback_in_progress(sb->s_bdi)) { |
cf37e9724 writeback: enforc... |
1043 |
down_read(&sb->s_umount); |
17bd55d03 fs-writeback: Add... |
1044 |
writeback_inodes_sb(sb); |
cf37e9724 writeback: enforc... |
1045 |
up_read(&sb->s_umount); |
17bd55d03 fs-writeback: Add... |
1046 1047 1048 1049 1050 1051 1052 |
return 1; } else return 0; } EXPORT_SYMBOL(writeback_inodes_sb_if_idle); /** |
d8a8559cd writeback: get ri... |
1053 1054 1055 1056 1057 1058 |
* sync_inodes_sb - sync sb inode pages * @sb: the superblock * * This function writes and waits on any dirty inode belonging to this * super_block. The number of pages synced is returned. */ |
b6e51316d writeback: separa... |
1059 |
void sync_inodes_sb(struct super_block *sb) |
d8a8559cd writeback: get ri... |
1060 |
{ |
83ba7b071 writeback: simpli... |
1061 1062 |
DECLARE_COMPLETION_ONSTACK(done); struct wb_writeback_work work = { |
3c4d71653 writeback: queue ... |
1063 1064 1065 1066 |
.sb = sb, .sync_mode = WB_SYNC_ALL, .nr_pages = LONG_MAX, .range_cyclic = 0, |
83ba7b071 writeback: simpli... |
1067 |
.done = &done, |
3c4d71653 writeback: queue ... |
1068 |
}; |
cf37e9724 writeback: enforc... |
1069 |
WARN_ON(!rwsem_is_locked(&sb->s_umount)); |
83ba7b071 writeback: simpli... |
1070 1071 |
bdi_queue_work(sb->s_bdi, &work); wait_for_completion(&done); |
b6e51316d writeback: separa... |
1072 |
wait_sb_inodes(sb); |
1da177e4c Linux-2.6.12-rc2 |
1073 |
} |
d8a8559cd writeback: get ri... |
1074 |
EXPORT_SYMBOL(sync_inodes_sb); |
1da177e4c Linux-2.6.12-rc2 |
1075 |
|
1da177e4c Linux-2.6.12-rc2 |
1076 |
/** |
7f04c26d7 [PATCH] fix nr_un... |
1077 1078 1079 1080 1081 1082 |
* 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 Linux-2.6.12-rc2 |
1083 |
* |
7f04c26d7 [PATCH] fix nr_un... |
1084 |
* The caller must either have a ref on the inode or must have set I_WILL_FREE. |
1da177e4c Linux-2.6.12-rc2 |
1085 |
*/ |
1da177e4c Linux-2.6.12-rc2 |
1086 1087 1088 1089 1090 |
int write_inode_now(struct inode *inode, int sync) { int ret; struct writeback_control wbc = { .nr_to_write = LONG_MAX, |
18914b188 write_inode_now()... |
1091 |
.sync_mode = sync ? WB_SYNC_ALL : WB_SYNC_NONE, |
111ebb6e6 [PATCH] writeback... |
1092 1093 |
.range_start = 0, .range_end = LLONG_MAX, |
1da177e4c Linux-2.6.12-rc2 |
1094 1095 1096 |
}; if (!mapping_cap_writeback_dirty(inode->i_mapping)) |
49364ce25 [PATCH] write_ino... |
1097 |
wbc.nr_to_write = 0; |
1da177e4c Linux-2.6.12-rc2 |
1098 1099 1100 |
might_sleep(); spin_lock(&inode_lock); |
01c031945 cleanup __writeba... |
1101 |
ret = writeback_single_inode(inode, &wbc); |
1da177e4c Linux-2.6.12-rc2 |
1102 1103 |
spin_unlock(&inode_lock); if (sync) |
1c0eeaf56 introduce I_SYNC |
1104 |
inode_sync_wait(inode); |
1da177e4c Linux-2.6.12-rc2 |
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 |
return ret; } 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) { int ret; spin_lock(&inode_lock); |
01c031945 cleanup __writeba... |
1125 |
ret = writeback_single_inode(inode, wbc); |
1da177e4c Linux-2.6.12-rc2 |
1126 1127 1128 1129 |
spin_unlock(&inode_lock); return ret; } EXPORT_SYMBOL(sync_inode); |