Root/
Source at commit 6c17a31f1fc515425221067cb3ece599c09dbc5d created 12 years 8 months ago. By Werner Almesberger, atusb, atben: moved from spi/ to ieee802154/; renamed atusb to spi_atusb | |
---|---|
1 | /* |
2 | * fs/fs-writeback.c |
3 | * |
4 | * Copyright (C) 2002, Linus Torvalds. |
5 | * |
6 | * Contains all the functions related to writing back and waiting |
7 | * upon dirty inodes against superblocks, and writing back dirty |
8 | * pages against inodes. ie: data writeback. Writeout of the |
9 | * inode itself is not handled here. |
10 | * |
11 | * 10Apr2002 Andrew Morton |
12 | * Split out of fs/inode.c |
13 | * Additions for address_space-based writeback |
14 | */ |
15 | |
16 | #include <linux/kernel.h> |
17 | #include <linux/module.h> |
18 | #include <linux/spinlock.h> |
19 | #include <linux/slab.h> |
20 | #include <linux/sched.h> |
21 | #include <linux/fs.h> |
22 | #include <linux/mm.h> |
23 | #include <linux/kthread.h> |
24 | #include <linux/freezer.h> |
25 | #include <linux/writeback.h> |
26 | #include <linux/blkdev.h> |
27 | #include <linux/backing-dev.h> |
28 | #include <linux/buffer_head.h> |
29 | #include <linux/tracepoint.h> |
30 | #include "internal.h" |
31 | |
32 | /* |
33 | * Passed into wb_writeback(), essentially a subset of writeback_control |
34 | */ |
35 | struct wb_writeback_work { |
36 | long nr_pages; |
37 | struct super_block *sb; |
38 | enum writeback_sync_modes sync_mode; |
39 | unsigned int for_kupdate:1; |
40 | unsigned int range_cyclic:1; |
41 | unsigned int for_background:1; |
42 | |
43 | struct list_head list; /* pending work list */ |
44 | struct completion *done; /* set if the caller waits */ |
45 | }; |
46 | |
47 | /* |
48 | * Include the creation of the trace points after defining the |
49 | * wb_writeback_work structure so that the definition remains local to this |
50 | * file. |
51 | */ |
52 | #define CREATE_TRACE_POINTS |
53 | #include <trace/events/writeback.h> |
54 | |
55 | /* |
56 | * We don't actually have pdflush, but this one is exported though /proc... |
57 | */ |
58 | int nr_pdflush_threads; |
59 | |
60 | /** |
61 | * writeback_in_progress - determine whether there is writeback in progress |
62 | * @bdi: the device's backing_dev_info structure. |
63 | * |
64 | * Determine whether there is writeback waiting to be handled against a |
65 | * backing device. |
66 | */ |
67 | int writeback_in_progress(struct backing_dev_info *bdi) |
68 | { |
69 | return test_bit(BDI_writeback_running, &bdi->state); |
70 | } |
71 | |
72 | static inline struct backing_dev_info *inode_to_bdi(struct inode *inode) |
73 | { |
74 | struct super_block *sb = inode->i_sb; |
75 | |
76 | if (strcmp(sb->s_type->name, "bdev") == 0) |
77 | return inode->i_mapping->backing_dev_info; |
78 | |
79 | return sb->s_bdi; |
80 | } |
81 | |
82 | static inline struct inode *wb_inode(struct list_head *head) |
83 | { |
84 | return list_entry(head, struct inode, i_wb_list); |
85 | } |
86 | |
87 | /* Wakeup flusher thread or forker thread to fork it. Requires bdi->wb_lock. */ |
88 | static void bdi_wakeup_flusher(struct backing_dev_info *bdi) |
89 | { |
90 | if (bdi->wb.task) { |
91 | wake_up_process(bdi->wb.task); |
92 | } else { |
93 | /* |
94 | * The bdi thread isn't there, wake up the forker thread which |
95 | * will create and run it. |
96 | */ |
97 | wake_up_process(default_backing_dev_info.wb.task); |
98 | } |
99 | } |
100 | |
101 | static void bdi_queue_work(struct backing_dev_info *bdi, |
102 | struct wb_writeback_work *work) |
103 | { |
104 | trace_writeback_queue(bdi, work); |
105 | |
106 | spin_lock_bh(&bdi->wb_lock); |
107 | list_add_tail(&work->list, &bdi->work_list); |
108 | if (!bdi->wb.task) |
109 | trace_writeback_nothread(bdi, work); |
110 | bdi_wakeup_flusher(bdi); |
111 | spin_unlock_bh(&bdi->wb_lock); |
112 | } |
113 | |
114 | static void |
115 | __bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages, |
116 | bool range_cyclic) |
117 | { |
118 | struct wb_writeback_work *work; |
119 | |
120 | /* |
121 | * This is WB_SYNC_NONE writeback, so if allocation fails just |
122 | * wakeup the thread for old dirty data writeback |
123 | */ |
124 | work = kzalloc(sizeof(*work), GFP_ATOMIC); |
125 | if (!work) { |
126 | if (bdi->wb.task) { |
127 | trace_writeback_nowork(bdi); |
128 | wake_up_process(bdi->wb.task); |
129 | } |
130 | return; |
131 | } |
132 | |
133 | work->sync_mode = WB_SYNC_NONE; |
134 | work->nr_pages = nr_pages; |
135 | work->range_cyclic = range_cyclic; |
136 | |
137 | bdi_queue_work(bdi, work); |
138 | } |
139 | |
140 | /** |
141 | * bdi_start_writeback - start writeback |
142 | * @bdi: the backing device to write from |
143 | * @nr_pages: the number of pages to write |
144 | * |
145 | * Description: |
146 | * This does WB_SYNC_NONE opportunistic writeback. The IO is only |
147 | * started when this function returns, we make no guarentees on |
148 | * completion. Caller need not hold sb s_umount semaphore. |
149 | * |
150 | */ |
151 | void bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages) |
152 | { |
153 | __bdi_start_writeback(bdi, nr_pages, true); |
154 | } |
155 | |
156 | /** |
157 | * bdi_start_background_writeback - start background writeback |
158 | * @bdi: the backing device to write from |
159 | * |
160 | * Description: |
161 | * This makes sure WB_SYNC_NONE background writeback happens. When |
162 | * this function returns, it is only guaranteed that for given BDI |
163 | * some IO is happening if we are over background dirty threshold. |
164 | * Caller need not hold sb s_umount semaphore. |
165 | */ |
166 | void bdi_start_background_writeback(struct backing_dev_info *bdi) |
167 | { |
168 | /* |
169 | * We just wake up the flusher thread. It will perform background |
170 | * writeback as soon as there is no other work to do. |
171 | */ |
172 | trace_writeback_wake_background(bdi); |
173 | spin_lock_bh(&bdi->wb_lock); |
174 | bdi_wakeup_flusher(bdi); |
175 | spin_unlock_bh(&bdi->wb_lock); |
176 | } |
177 | |
178 | /* |
179 | * Redirty an inode: set its when-it-was dirtied timestamp and move it to the |
180 | * furthest end of its superblock's dirty-inode list. |
181 | * |
182 | * Before stamping the inode's ->dirtied_when, we check to see whether it is |
183 | * already the most-recently-dirtied inode on the b_dirty list. If that is |
184 | * the case then the inode must have been redirtied while it was being written |
185 | * out and we don't reset its dirtied_when. |
186 | */ |
187 | static void redirty_tail(struct inode *inode) |
188 | { |
189 | struct bdi_writeback *wb = &inode_to_bdi(inode)->wb; |
190 | |
191 | if (!list_empty(&wb->b_dirty)) { |
192 | struct inode *tail; |
193 | |
194 | tail = wb_inode(wb->b_dirty.next); |
195 | if (time_before(inode->dirtied_when, tail->dirtied_when)) |
196 | inode->dirtied_when = jiffies; |
197 | } |
198 | list_move(&inode->i_wb_list, &wb->b_dirty); |
199 | } |
200 | |
201 | /* |
202 | * requeue inode for re-scanning after bdi->b_io list is exhausted. |
203 | */ |
204 | static void requeue_io(struct inode *inode) |
205 | { |
206 | struct bdi_writeback *wb = &inode_to_bdi(inode)->wb; |
207 | |
208 | list_move(&inode->i_wb_list, &wb->b_more_io); |
209 | } |
210 | |
211 | static void inode_sync_complete(struct inode *inode) |
212 | { |
213 | /* |
214 | * Prevent speculative execution through spin_unlock(&inode_lock); |
215 | */ |
216 | smp_mb(); |
217 | wake_up_bit(&inode->i_state, __I_SYNC); |
218 | } |
219 | |
220 | static bool inode_dirtied_after(struct inode *inode, unsigned long t) |
221 | { |
222 | bool ret = time_after(inode->dirtied_when, t); |
223 | #ifndef CONFIG_64BIT |
224 | /* |
225 | * For inodes being constantly redirtied, dirtied_when can get stuck. |
226 | * It _appears_ to be in the future, but is actually in distant past. |
227 | * This test is necessary to prevent such wrapped-around relative times |
228 | * from permanently stopping the whole bdi writeback. |
229 | */ |
230 | ret = ret && time_before_eq(inode->dirtied_when, jiffies); |
231 | #endif |
232 | return ret; |
233 | } |
234 | |
235 | /* |
236 | * Move expired dirty inodes from @delaying_queue to @dispatch_queue. |
237 | */ |
238 | static void move_expired_inodes(struct list_head *delaying_queue, |
239 | struct list_head *dispatch_queue, |
240 | unsigned long *older_than_this) |
241 | { |
242 | LIST_HEAD(tmp); |
243 | struct list_head *pos, *node; |
244 | struct super_block *sb = NULL; |
245 | struct inode *inode; |
246 | int do_sb_sort = 0; |
247 | |
248 | while (!list_empty(delaying_queue)) { |
249 | inode = wb_inode(delaying_queue->prev); |
250 | if (older_than_this && |
251 | inode_dirtied_after(inode, *older_than_this)) |
252 | break; |
253 | if (sb && sb != inode->i_sb) |
254 | do_sb_sort = 1; |
255 | sb = inode->i_sb; |
256 | list_move(&inode->i_wb_list, &tmp); |
257 | } |
258 | |
259 | /* just one sb in list, splice to dispatch_queue and we're done */ |
260 | if (!do_sb_sort) { |
261 | list_splice(&tmp, dispatch_queue); |
262 | return; |
263 | } |
264 | |
265 | /* Move inodes from one superblock together */ |
266 | while (!list_empty(&tmp)) { |
267 | sb = wb_inode(tmp.prev)->i_sb; |
268 | list_for_each_prev_safe(pos, node, &tmp) { |
269 | inode = wb_inode(pos); |
270 | if (inode->i_sb == sb) |
271 | list_move(&inode->i_wb_list, dispatch_queue); |
272 | } |
273 | } |
274 | } |
275 | |
276 | /* |
277 | * Queue all expired dirty inodes for io, eldest first. |
278 | * Before |
279 | * newly dirtied b_dirty b_io b_more_io |
280 | * =============> gf edc BA |
281 | * After |
282 | * newly dirtied b_dirty b_io b_more_io |
283 | * =============> g fBAedc |
284 | * | |
285 | * +--> dequeue for IO |
286 | */ |
287 | static void queue_io(struct bdi_writeback *wb, unsigned long *older_than_this) |
288 | { |
289 | list_splice_init(&wb->b_more_io, &wb->b_io); |
290 | move_expired_inodes(&wb->b_dirty, &wb->b_io, older_than_this); |
291 | } |
292 | |
293 | static int write_inode(struct inode *inode, struct writeback_control *wbc) |
294 | { |
295 | if (inode->i_sb->s_op->write_inode && !is_bad_inode(inode)) |
296 | return inode->i_sb->s_op->write_inode(inode, wbc); |
297 | return 0; |
298 | } |
299 | |
300 | /* |
301 | * Wait for writeback on an inode to complete. |
302 | */ |
303 | static void inode_wait_for_writeback(struct inode *inode) |
304 | { |
305 | DEFINE_WAIT_BIT(wq, &inode->i_state, __I_SYNC); |
306 | wait_queue_head_t *wqh; |
307 | |
308 | wqh = bit_waitqueue(&inode->i_state, __I_SYNC); |
309 | while (inode->i_state & I_SYNC) { |
310 | spin_unlock(&inode_lock); |
311 | __wait_on_bit(wqh, &wq, inode_wait, TASK_UNINTERRUPTIBLE); |
312 | spin_lock(&inode_lock); |
313 | } |
314 | } |
315 | |
316 | /* |
317 | * Write out an inode's dirty pages. Called under inode_lock. Either the |
318 | * caller has ref on the inode (either via __iget or via syscall against an fd) |
319 | * or the inode has I_WILL_FREE set (via generic_forget_inode) |
320 | * |
321 | * If `wait' is set, wait on the writeout. |
322 | * |
323 | * The whole writeout design is quite complex and fragile. We want to avoid |
324 | * starvation of particular inodes when others are being redirtied, prevent |
325 | * livelocks, etc. |
326 | * |
327 | * Called under inode_lock. |
328 | */ |
329 | static int |
330 | writeback_single_inode(struct inode *inode, struct writeback_control *wbc) |
331 | { |
332 | struct address_space *mapping = inode->i_mapping; |
333 | unsigned dirty; |
334 | int ret; |
335 | |
336 | if (!atomic_read(&inode->i_count)) |
337 | WARN_ON(!(inode->i_state & (I_WILL_FREE|I_FREEING))); |
338 | else |
339 | WARN_ON(inode->i_state & I_WILL_FREE); |
340 | |
341 | if (inode->i_state & I_SYNC) { |
342 | /* |
343 | * If this inode is locked for writeback and we are not doing |
344 | * writeback-for-data-integrity, move it to b_more_io so that |
345 | * writeback can proceed with the other inodes on s_io. |
346 | * |
347 | * We'll have another go at writing back this inode when we |
348 | * completed a full scan of b_io. |
349 | */ |
350 | if (wbc->sync_mode != WB_SYNC_ALL) { |
351 | requeue_io(inode); |
352 | return 0; |
353 | } |
354 | |
355 | /* |
356 | * It's a data-integrity sync. We must wait. |
357 | */ |
358 | inode_wait_for_writeback(inode); |
359 | } |
360 | |
361 | BUG_ON(inode->i_state & I_SYNC); |
362 | |
363 | /* Set I_SYNC, reset I_DIRTY_PAGES */ |
364 | inode->i_state |= I_SYNC; |
365 | inode->i_state &= ~I_DIRTY_PAGES; |
366 | spin_unlock(&inode_lock); |
367 | |
368 | ret = do_writepages(mapping, wbc); |
369 | |
370 | /* |
371 | * Make sure to wait on the data before writing out the metadata. |
372 | * This is important for filesystems that modify metadata on data |
373 | * I/O completion. |
374 | */ |
375 | if (wbc->sync_mode == WB_SYNC_ALL) { |
376 | int err = filemap_fdatawait(mapping); |
377 | if (ret == 0) |
378 | ret = err; |
379 | } |
380 | |
381 | /* |
382 | * Some filesystems may redirty the inode during the writeback |
383 | * due to delalloc, clear dirty metadata flags right before |
384 | * write_inode() |
385 | */ |
386 | spin_lock(&inode_lock); |
387 | dirty = inode->i_state & I_DIRTY; |
388 | inode->i_state &= ~(I_DIRTY_SYNC | I_DIRTY_DATASYNC); |
389 | spin_unlock(&inode_lock); |
390 | /* Don't write the inode if only I_DIRTY_PAGES was set */ |
391 | if (dirty & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) { |
392 | int err = write_inode(inode, wbc); |
393 | if (ret == 0) |
394 | ret = err; |
395 | } |
396 | |
397 | spin_lock(&inode_lock); |
398 | inode->i_state &= ~I_SYNC; |
399 | if (!(inode->i_state & I_FREEING)) { |
400 | if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) { |
401 | /* |
402 | * We didn't write back all the pages. nfs_writepages() |
403 | * sometimes bales out without doing anything. |
404 | */ |
405 | inode->i_state |= I_DIRTY_PAGES; |
406 | if (wbc->nr_to_write <= 0) { |
407 | /* |
408 | * slice used up: queue for next turn |
409 | */ |
410 | requeue_io(inode); |
411 | } else { |
412 | /* |
413 | * Writeback blocked by something other than |
414 | * congestion. Delay the inode for some time to |
415 | * avoid spinning on the CPU (100% iowait) |
416 | * retrying writeback of the dirty page/inode |
417 | * that cannot be performed immediately. |
418 | */ |
419 | redirty_tail(inode); |
420 | } |
421 | } else if (inode->i_state & I_DIRTY) { |
422 | /* |
423 | * Filesystems can dirty the inode during writeback |
424 | * operations, such as delayed allocation during |
425 | * submission or metadata updates after data IO |
426 | * completion. |
427 | */ |
428 | redirty_tail(inode); |
429 | } else { |
430 | /* |
431 | * The inode is clean. At this point we either have |
432 | * a reference to the inode or it's on it's way out. |
433 | * No need to add it back to the LRU. |
434 | */ |
435 | list_del_init(&inode->i_wb_list); |
436 | } |
437 | } |
438 | inode_sync_complete(inode); |
439 | return ret; |
440 | } |
441 | |
442 | /* |
443 | * For background writeback the caller does not have the sb pinned |
444 | * before calling writeback. So make sure that we do pin it, so it doesn't |
445 | * go away while we are writing inodes from it. |
446 | */ |
447 | static bool pin_sb_for_writeback(struct super_block *sb) |
448 | { |
449 | spin_lock(&sb_lock); |
450 | if (list_empty(&sb->s_instances)) { |
451 | spin_unlock(&sb_lock); |
452 | return false; |
453 | } |
454 | |
455 | sb->s_count++; |
456 | spin_unlock(&sb_lock); |
457 | |
458 | if (down_read_trylock(&sb->s_umount)) { |
459 | if (sb->s_root) |
460 | return true; |
461 | up_read(&sb->s_umount); |
462 | } |
463 | |
464 | put_super(sb); |
465 | return false; |
466 | } |
467 | |
468 | /* |
469 | * Write a portion of b_io inodes which belong to @sb. |
470 | * |
471 | * If @only_this_sb is true, then find and write all such |
472 | * inodes. Otherwise write only ones which go sequentially |
473 | * in reverse order. |
474 | * |
475 | * Return 1, if the caller writeback routine should be |
476 | * interrupted. Otherwise return 0. |
477 | */ |
478 | static int writeback_sb_inodes(struct super_block *sb, struct bdi_writeback *wb, |
479 | struct writeback_control *wbc, bool only_this_sb) |
480 | { |
481 | while (!list_empty(&wb->b_io)) { |
482 | long pages_skipped; |
483 | struct inode *inode = wb_inode(wb->b_io.prev); |
484 | |
485 | if (inode->i_sb != sb) { |
486 | if (only_this_sb) { |
487 | /* |
488 | * We only want to write back data for this |
489 | * superblock, move all inodes not belonging |
490 | * to it back onto the dirty list. |
491 | */ |
492 | redirty_tail(inode); |
493 | continue; |
494 | } |
495 | |
496 | /* |
497 | * The inode belongs to a different superblock. |
498 | * Bounce back to the caller to unpin this and |
499 | * pin the next superblock. |
500 | */ |
501 | return 0; |
502 | } |
503 | |
504 | /* |
505 | * Don't bother with new inodes or inodes beeing freed, first |
506 | * kind does not need peridic writeout yet, and for the latter |
507 | * kind writeout is handled by the freer. |
508 | */ |
509 | if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) { |
510 | requeue_io(inode); |
511 | continue; |
512 | } |
513 | |
514 | /* |
515 | * Was this inode dirtied after sync_sb_inodes was called? |
516 | * This keeps sync from extra jobs and livelock. |
517 | */ |
518 | if (inode_dirtied_after(inode, wbc->wb_start)) |
519 | return 1; |
520 | |
521 | __iget(inode); |
522 | pages_skipped = wbc->pages_skipped; |
523 | writeback_single_inode(inode, wbc); |
524 | if (wbc->pages_skipped != pages_skipped) { |
525 | /* |
526 | * writeback is not making progress due to locked |
527 | * buffers. Skip this inode for now. |
528 | */ |
529 | redirty_tail(inode); |
530 | } |
531 | spin_unlock(&inode_lock); |
532 | iput(inode); |
533 | cond_resched(); |
534 | spin_lock(&inode_lock); |
535 | if (wbc->nr_to_write <= 0) { |
536 | wbc->more_io = 1; |
537 | return 1; |
538 | } |
539 | if (!list_empty(&wb->b_more_io)) |
540 | wbc->more_io = 1; |
541 | } |
542 | /* b_io is empty */ |
543 | return 1; |
544 | } |
545 | |
546 | void writeback_inodes_wb(struct bdi_writeback *wb, |
547 | struct writeback_control *wbc) |
548 | { |
549 | int ret = 0; |
550 | |
551 | if (!wbc->wb_start) |
552 | wbc->wb_start = jiffies; /* livelock avoidance */ |
553 | spin_lock(&inode_lock); |
554 | if (!wbc->for_kupdate || list_empty(&wb->b_io)) |
555 | queue_io(wb, wbc->older_than_this); |
556 | |
557 | while (!list_empty(&wb->b_io)) { |
558 | struct inode *inode = wb_inode(wb->b_io.prev); |
559 | struct super_block *sb = inode->i_sb; |
560 | |
561 | if (!pin_sb_for_writeback(sb)) { |
562 | requeue_io(inode); |
563 | continue; |
564 | } |
565 | ret = writeback_sb_inodes(sb, wb, wbc, false); |
566 | drop_super(sb); |
567 | |
568 | if (ret) |
569 | break; |
570 | } |
571 | spin_unlock(&inode_lock); |
572 | /* Leave any unwritten inodes on b_io */ |
573 | } |
574 | |
575 | static void __writeback_inodes_sb(struct super_block *sb, |
576 | struct bdi_writeback *wb, struct writeback_control *wbc) |
577 | { |
578 | WARN_ON(!rwsem_is_locked(&sb->s_umount)); |
579 | |
580 | spin_lock(&inode_lock); |
581 | if (!wbc->for_kupdate || list_empty(&wb->b_io)) |
582 | queue_io(wb, wbc->older_than_this); |
583 | writeback_sb_inodes(sb, wb, wbc, true); |
584 | spin_unlock(&inode_lock); |
585 | } |
586 | |
587 | /* |
588 | * The maximum number of pages to writeout in a single bdi flush/kupdate |
589 | * operation. We do this so we don't hold I_SYNC against an inode for |
590 | * enormous amounts of time, which would block a userspace task which has |
591 | * been forced to throttle against that inode. Also, the code reevaluates |
592 | * the dirty each time it has written this many pages. |
593 | */ |
594 | #define MAX_WRITEBACK_PAGES 1024 |
595 | |
596 | static inline bool over_bground_thresh(void) |
597 | { |
598 | unsigned long background_thresh, dirty_thresh; |
599 | |
600 | global_dirty_limits(&background_thresh, &dirty_thresh); |
601 | |
602 | return (global_page_state(NR_FILE_DIRTY) + |
603 | global_page_state(NR_UNSTABLE_NFS) > background_thresh); |
604 | } |
605 | |
606 | /* |
607 | * Explicit flushing or periodic writeback of "old" data. |
608 | * |
609 | * Define "old": the first time one of an inode's pages is dirtied, we mark the |
610 | * dirtying-time in the inode's address_space. So this periodic writeback code |
611 | * just walks the superblock inode list, writing back any inodes which are |
612 | * older than a specific point in time. |
613 | * |
614 | * Try to run once per dirty_writeback_interval. But if a writeback event |
615 | * takes longer than a dirty_writeback_interval interval, then leave a |
616 | * one-second gap. |
617 | * |
618 | * older_than_this takes precedence over nr_to_write. So we'll only write back |
619 | * all dirty pages if they are all attached to "old" mappings. |
620 | */ |
621 | static long wb_writeback(struct bdi_writeback *wb, |
622 | struct wb_writeback_work *work) |
623 | { |
624 | struct writeback_control wbc = { |
625 | .sync_mode = work->sync_mode, |
626 | .older_than_this = NULL, |
627 | .for_kupdate = work->for_kupdate, |
628 | .for_background = work->for_background, |
629 | .range_cyclic = work->range_cyclic, |
630 | }; |
631 | unsigned long oldest_jif; |
632 | long wrote = 0; |
633 | long write_chunk; |
634 | struct inode *inode; |
635 | |
636 | if (wbc.for_kupdate) { |
637 | wbc.older_than_this = &oldest_jif; |
638 | oldest_jif = jiffies - |
639 | msecs_to_jiffies(dirty_expire_interval * 10); |
640 | } |
641 | if (!wbc.range_cyclic) { |
642 | wbc.range_start = 0; |
643 | wbc.range_end = LLONG_MAX; |
644 | } |
645 | |
646 | /* |
647 | * WB_SYNC_ALL mode does livelock avoidance by syncing dirty |
648 | * inodes/pages in one big loop. Setting wbc.nr_to_write=LONG_MAX |
649 | * here avoids calling into writeback_inodes_wb() more than once. |
650 | * |
651 | * The intended call sequence for WB_SYNC_ALL writeback is: |
652 | * |
653 | * wb_writeback() |
654 | * __writeback_inodes_sb() <== called only once |
655 | * write_cache_pages() <== called once for each inode |
656 | * (quickly) tag currently dirty pages |
657 | * (maybe slowly) sync all tagged pages |
658 | */ |
659 | if (wbc.sync_mode == WB_SYNC_NONE) |
660 | write_chunk = MAX_WRITEBACK_PAGES; |
661 | else |
662 | write_chunk = LONG_MAX; |
663 | |
664 | wbc.wb_start = jiffies; /* livelock avoidance */ |
665 | for (;;) { |
666 | /* |
667 | * Stop writeback when nr_pages has been consumed |
668 | */ |
669 | if (work->nr_pages <= 0) |
670 | break; |
671 | |
672 | /* |
673 | * Background writeout and kupdate-style writeback may |
674 | * run forever. Stop them if there is other work to do |
675 | * so that e.g. sync can proceed. They'll be restarted |
676 | * after the other works are all done. |
677 | */ |
678 | if ((work->for_background || work->for_kupdate) && |
679 | !list_empty(&wb->bdi->work_list)) |
680 | break; |
681 | |
682 | /* |
683 | * For background writeout, stop when we are below the |
684 | * background dirty threshold |
685 | */ |
686 | if (work->for_background && !over_bground_thresh()) |
687 | break; |
688 | |
689 | wbc.more_io = 0; |
690 | wbc.nr_to_write = write_chunk; |
691 | wbc.pages_skipped = 0; |
692 | |
693 | trace_wbc_writeback_start(&wbc, wb->bdi); |
694 | if (work->sb) |
695 | __writeback_inodes_sb(work->sb, wb, &wbc); |
696 | else |
697 | writeback_inodes_wb(wb, &wbc); |
698 | trace_wbc_writeback_written(&wbc, wb->bdi); |
699 | |
700 | work->nr_pages -= write_chunk - wbc.nr_to_write; |
701 | wrote += write_chunk - wbc.nr_to_write; |
702 | |
703 | /* |
704 | * If we consumed everything, see if we have more |
705 | */ |
706 | if (wbc.nr_to_write <= 0) |
707 | continue; |
708 | /* |
709 | * Didn't write everything and we don't have more IO, bail |
710 | */ |
711 | if (!wbc.more_io) |
712 | break; |
713 | /* |
714 | * Did we write something? Try for more |
715 | */ |
716 | if (wbc.nr_to_write < write_chunk) |
717 | continue; |
718 | /* |
719 | * Nothing written. Wait for some inode to |
720 | * become available for writeback. Otherwise |
721 | * we'll just busyloop. |
722 | */ |
723 | spin_lock(&inode_lock); |
724 | if (!list_empty(&wb->b_more_io)) { |
725 | inode = wb_inode(wb->b_more_io.prev); |
726 | trace_wbc_writeback_wait(&wbc, wb->bdi); |
727 | inode_wait_for_writeback(inode); |
728 | } |
729 | spin_unlock(&inode_lock); |
730 | } |
731 | |
732 | return wrote; |
733 | } |
734 | |
735 | /* |
736 | * Return the next wb_writeback_work struct that hasn't been processed yet. |
737 | */ |
738 | static struct wb_writeback_work * |
739 | get_next_work_item(struct backing_dev_info *bdi) |
740 | { |
741 | struct wb_writeback_work *work = NULL; |
742 | |
743 | spin_lock_bh(&bdi->wb_lock); |
744 | if (!list_empty(&bdi->work_list)) { |
745 | work = list_entry(bdi->work_list.next, |
746 | struct wb_writeback_work, list); |
747 | list_del_init(&work->list); |
748 | } |
749 | spin_unlock_bh(&bdi->wb_lock); |
750 | return work; |
751 | } |
752 | |
753 | /* |
754 | * Add in the number of potentially dirty inodes, because each inode |
755 | * write can dirty pagecache in the underlying blockdev. |
756 | */ |
757 | static unsigned long get_nr_dirty_pages(void) |
758 | { |
759 | return global_page_state(NR_FILE_DIRTY) + |
760 | global_page_state(NR_UNSTABLE_NFS) + |
761 | get_nr_dirty_inodes(); |
762 | } |
763 | |
764 | static long wb_check_background_flush(struct bdi_writeback *wb) |
765 | { |
766 | if (over_bground_thresh()) { |
767 | |
768 | struct wb_writeback_work work = { |
769 | .nr_pages = LONG_MAX, |
770 | .sync_mode = WB_SYNC_NONE, |
771 | .for_background = 1, |
772 | .range_cyclic = 1, |
773 | }; |
774 | |
775 | return wb_writeback(wb, &work); |
776 | } |
777 | |
778 | return 0; |
779 | } |
780 | |
781 | static long wb_check_old_data_flush(struct bdi_writeback *wb) |
782 | { |
783 | unsigned long expired; |
784 | long nr_pages; |
785 | |
786 | /* |
787 | * When set to zero, disable periodic writeback |
788 | */ |
789 | if (!dirty_writeback_interval) |
790 | return 0; |
791 | |
792 | expired = wb->last_old_flush + |
793 | msecs_to_jiffies(dirty_writeback_interval * 10); |
794 | if (time_before(jiffies, expired)) |
795 | return 0; |
796 | |
797 | wb->last_old_flush = jiffies; |
798 | nr_pages = get_nr_dirty_pages(); |
799 | |
800 | if (nr_pages) { |
801 | struct wb_writeback_work work = { |
802 | .nr_pages = nr_pages, |
803 | .sync_mode = WB_SYNC_NONE, |
804 | .for_kupdate = 1, |
805 | .range_cyclic = 1, |
806 | }; |
807 | |
808 | return wb_writeback(wb, &work); |
809 | } |
810 | |
811 | return 0; |
812 | } |
813 | |
814 | /* |
815 | * Retrieve work items and do the writeback they describe |
816 | */ |
817 | long wb_do_writeback(struct bdi_writeback *wb, int force_wait) |
818 | { |
819 | struct backing_dev_info *bdi = wb->bdi; |
820 | struct wb_writeback_work *work; |
821 | long wrote = 0; |
822 | |
823 | set_bit(BDI_writeback_running, &wb->bdi->state); |
824 | while ((work = get_next_work_item(bdi)) != NULL) { |
825 | /* |
826 | * Override sync mode, in case we must wait for completion |
827 | * because this thread is exiting now. |
828 | */ |
829 | if (force_wait) |
830 | work->sync_mode = WB_SYNC_ALL; |
831 | |
832 | trace_writeback_exec(bdi, work); |
833 | |
834 | wrote += wb_writeback(wb, work); |
835 | |
836 | /* |
837 | * Notify the caller of completion if this is a synchronous |
838 | * work item, otherwise just free it. |
839 | */ |
840 | if (work->done) |
841 | complete(work->done); |
842 | else |
843 | kfree(work); |
844 | } |
845 | |
846 | /* |
847 | * Check for periodic writeback, kupdated() style |
848 | */ |
849 | wrote += wb_check_old_data_flush(wb); |
850 | wrote += wb_check_background_flush(wb); |
851 | clear_bit(BDI_writeback_running, &wb->bdi->state); |
852 | |
853 | return wrote; |
854 | } |
855 | |
856 | /* |
857 | * Handle writeback of dirty data for the device backed by this bdi. Also |
858 | * wakes up periodically and does kupdated style flushing. |
859 | */ |
860 | int bdi_writeback_thread(void *data) |
861 | { |
862 | struct bdi_writeback *wb = data; |
863 | struct backing_dev_info *bdi = wb->bdi; |
864 | long pages_written; |
865 | |
866 | current->flags |= PF_SWAPWRITE; |
867 | set_freezable(); |
868 | wb->last_active = jiffies; |
869 | |
870 | /* |
871 | * Our parent may run at a different priority, just set us to normal |
872 | */ |
873 | set_user_nice(current, 0); |
874 | |
875 | trace_writeback_thread_start(bdi); |
876 | |
877 | while (!kthread_should_stop()) { |
878 | /* |
879 | * Remove own delayed wake-up timer, since we are already awake |
880 | * and we'll take care of the preriodic write-back. |
881 | */ |
882 | del_timer(&wb->wakeup_timer); |
883 | |
884 | pages_written = wb_do_writeback(wb, 0); |
885 | |
886 | trace_writeback_pages_written(pages_written); |
887 | |
888 | if (pages_written) |
889 | wb->last_active = jiffies; |
890 | |
891 | set_current_state(TASK_INTERRUPTIBLE); |
892 | if (!list_empty(&bdi->work_list) || kthread_should_stop()) { |
893 | __set_current_state(TASK_RUNNING); |
894 | continue; |
895 | } |
896 | |
897 | if (wb_has_dirty_io(wb) && dirty_writeback_interval) |
898 | schedule_timeout(msecs_to_jiffies(dirty_writeback_interval * 10)); |
899 | else { |
900 | /* |
901 | * We have nothing to do, so can go sleep without any |
902 | * timeout and save power. When a work is queued or |
903 | * something is made dirty - we will be woken up. |
904 | */ |
905 | schedule(); |
906 | } |
907 | |
908 | try_to_freeze(); |
909 | } |
910 | |
911 | /* Flush any work that raced with us exiting */ |
912 | if (!list_empty(&bdi->work_list)) |
913 | wb_do_writeback(wb, 1); |
914 | |
915 | trace_writeback_thread_stop(bdi); |
916 | return 0; |
917 | } |
918 | |
919 | |
920 | /* |
921 | * Start writeback of `nr_pages' pages. If `nr_pages' is zero, write back |
922 | * the whole world. |
923 | */ |
924 | void wakeup_flusher_threads(long nr_pages) |
925 | { |
926 | struct backing_dev_info *bdi; |
927 | |
928 | if (!nr_pages) { |
929 | nr_pages = global_page_state(NR_FILE_DIRTY) + |
930 | global_page_state(NR_UNSTABLE_NFS); |
931 | } |
932 | |
933 | rcu_read_lock(); |
934 | list_for_each_entry_rcu(bdi, &bdi_list, bdi_list) { |
935 | if (!bdi_has_dirty_io(bdi)) |
936 | continue; |
937 | __bdi_start_writeback(bdi, nr_pages, false); |
938 | } |
939 | rcu_read_unlock(); |
940 | } |
941 | |
942 | static noinline void block_dump___mark_inode_dirty(struct inode *inode) |
943 | { |
944 | if (inode->i_ino || strcmp(inode->i_sb->s_id, "bdev")) { |
945 | struct dentry *dentry; |
946 | const char *name = "?"; |
947 | |
948 | dentry = d_find_alias(inode); |
949 | if (dentry) { |
950 | spin_lock(&dentry->d_lock); |
951 | name = (const char *) dentry->d_name.name; |
952 | } |
953 | printk(KERN_DEBUG |
954 | "%s(%d): dirtied inode %lu (%s) on %s\n", |
955 | current->comm, task_pid_nr(current), inode->i_ino, |
956 | name, inode->i_sb->s_id); |
957 | if (dentry) { |
958 | spin_unlock(&dentry->d_lock); |
959 | dput(dentry); |
960 | } |
961 | } |
962 | } |
963 | |
964 | /** |
965 | * __mark_inode_dirty - internal function |
966 | * @inode: inode to mark |
967 | * @flags: what kind of dirty (i.e. I_DIRTY_SYNC) |
968 | * Mark an inode as dirty. Callers should use mark_inode_dirty or |
969 | * mark_inode_dirty_sync. |
970 | * |
971 | * Put the inode on the super block's dirty list. |
972 | * |
973 | * CAREFUL! We mark it dirty unconditionally, but move it onto the |
974 | * dirty list only if it is hashed or if it refers to a blockdev. |
975 | * If it was not hashed, it will never be added to the dirty list |
976 | * even if it is later hashed, as it will have been marked dirty already. |
977 | * |
978 | * In short, make sure you hash any inodes _before_ you start marking |
979 | * them dirty. |
980 | * |
981 | * This function *must* be atomic for the I_DIRTY_PAGES case - |
982 | * set_page_dirty() is called under spinlock in several places. |
983 | * |
984 | * Note that for blockdevs, inode->dirtied_when represents the dirtying time of |
985 | * the block-special inode (/dev/hda1) itself. And the ->dirtied_when field of |
986 | * the kernel-internal blockdev inode represents the dirtying time of the |
987 | * blockdev's pages. This is why for I_DIRTY_PAGES we always use |
988 | * page->mapping->host, so the page-dirtying time is recorded in the internal |
989 | * blockdev inode. |
990 | */ |
991 | void __mark_inode_dirty(struct inode *inode, int flags) |
992 | { |
993 | struct super_block *sb = inode->i_sb; |
994 | struct backing_dev_info *bdi = NULL; |
995 | bool wakeup_bdi = false; |
996 | |
997 | /* |
998 | * Don't do this for I_DIRTY_PAGES - that doesn't actually |
999 | * dirty the inode itself |
1000 | */ |
1001 | if (flags & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) { |
1002 | if (sb->s_op->dirty_inode) |
1003 | sb->s_op->dirty_inode(inode); |
1004 | } |
1005 | |
1006 | /* |
1007 | * make sure that changes are seen by all cpus before we test i_state |
1008 | * -- mikulas |
1009 | */ |
1010 | smp_mb(); |
1011 | |
1012 | /* avoid the locking if we can */ |
1013 | if ((inode->i_state & flags) == flags) |
1014 | return; |
1015 | |
1016 | if (unlikely(block_dump)) |
1017 | block_dump___mark_inode_dirty(inode); |
1018 | |
1019 | spin_lock(&inode_lock); |
1020 | if ((inode->i_state & flags) != flags) { |
1021 | const int was_dirty = inode->i_state & I_DIRTY; |
1022 | |
1023 | inode->i_state |= flags; |
1024 | |
1025 | /* |
1026 | * If the inode is being synced, just update its dirty state. |
1027 | * The unlocker will place the inode on the appropriate |
1028 | * superblock list, based upon its state. |
1029 | */ |
1030 | if (inode->i_state & I_SYNC) |
1031 | goto out; |
1032 | |
1033 | /* |
1034 | * Only add valid (hashed) inodes to the superblock's |
1035 | * dirty list. Add blockdev inodes as well. |
1036 | */ |
1037 | if (!S_ISBLK(inode->i_mode)) { |
1038 | if (inode_unhashed(inode)) |
1039 | goto out; |
1040 | } |
1041 | if (inode->i_state & I_FREEING) |
1042 | goto out; |
1043 | |
1044 | /* |
1045 | * If the inode was already on b_dirty/b_io/b_more_io, don't |
1046 | * reposition it (that would break b_dirty time-ordering). |
1047 | */ |
1048 | if (!was_dirty) { |
1049 | bdi = inode_to_bdi(inode); |
1050 | |
1051 | if (bdi_cap_writeback_dirty(bdi)) { |
1052 | WARN(!test_bit(BDI_registered, &bdi->state), |
1053 | "bdi-%s not registered\n", bdi->name); |
1054 | |
1055 | /* |
1056 | * If this is the first dirty inode for this |
1057 | * bdi, we have to wake-up the corresponding |
1058 | * bdi thread to make sure background |
1059 | * write-back happens later. |
1060 | */ |
1061 | if (!wb_has_dirty_io(&bdi->wb)) |
1062 | wakeup_bdi = true; |
1063 | } |
1064 | |
1065 | inode->dirtied_when = jiffies; |
1066 | list_move(&inode->i_wb_list, &bdi->wb.b_dirty); |
1067 | } |
1068 | } |
1069 | out: |
1070 | spin_unlock(&inode_lock); |
1071 | |
1072 | if (wakeup_bdi) |
1073 | bdi_wakeup_thread_delayed(bdi); |
1074 | } |
1075 | EXPORT_SYMBOL(__mark_inode_dirty); |
1076 | |
1077 | /* |
1078 | * Write out a superblock's list of dirty inodes. A wait will be performed |
1079 | * upon no inodes, all inodes or the final one, depending upon sync_mode. |
1080 | * |
1081 | * If older_than_this is non-NULL, then only write out inodes which |
1082 | * had their first dirtying at a time earlier than *older_than_this. |
1083 | * |
1084 | * If `bdi' is non-zero then we're being asked to writeback a specific queue. |
1085 | * This function assumes that the blockdev superblock's inodes are backed by |
1086 | * a variety of queues, so all inodes are searched. For other superblocks, |
1087 | * assume that all inodes are backed by the same queue. |
1088 | * |
1089 | * The inodes to be written are parked on bdi->b_io. They are moved back onto |
1090 | * bdi->b_dirty as they are selected for writing. This way, none can be missed |
1091 | * on the writer throttling path, and we get decent balancing between many |
1092 | * throttled threads: we don't want them all piling up on inode_sync_wait. |
1093 | */ |
1094 | static void wait_sb_inodes(struct super_block *sb) |
1095 | { |
1096 | struct inode *inode, *old_inode = NULL; |
1097 | |
1098 | /* |
1099 | * We need to be protected against the filesystem going from |
1100 | * r/o to r/w or vice versa. |
1101 | */ |
1102 | WARN_ON(!rwsem_is_locked(&sb->s_umount)); |
1103 | |
1104 | spin_lock(&inode_lock); |
1105 | |
1106 | /* |
1107 | * Data integrity sync. Must wait for all pages under writeback, |
1108 | * because there may have been pages dirtied before our sync |
1109 | * call, but which had writeout started before we write it out. |
1110 | * In which case, the inode may not be on the dirty list, but |
1111 | * we still have to wait for that writeout. |
1112 | */ |
1113 | list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { |
1114 | struct address_space *mapping; |
1115 | |
1116 | if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) |
1117 | continue; |
1118 | mapping = inode->i_mapping; |
1119 | if (mapping->nrpages == 0) |
1120 | continue; |
1121 | __iget(inode); |
1122 | spin_unlock(&inode_lock); |
1123 | /* |
1124 | * We hold a reference to 'inode' so it couldn't have |
1125 | * been removed from s_inodes list while we dropped the |
1126 | * inode_lock. We cannot iput the inode now as we can |
1127 | * be holding the last reference and we cannot iput it |
1128 | * under inode_lock. So we keep the reference and iput |
1129 | * it later. |
1130 | */ |
1131 | iput(old_inode); |
1132 | old_inode = inode; |
1133 | |
1134 | filemap_fdatawait(mapping); |
1135 | |
1136 | cond_resched(); |
1137 | |
1138 | spin_lock(&inode_lock); |
1139 | } |
1140 | spin_unlock(&inode_lock); |
1141 | iput(old_inode); |
1142 | } |
1143 | |
1144 | /** |
1145 | * writeback_inodes_sb_nr - writeback dirty inodes from given super_block |
1146 | * @sb: the superblock |
1147 | * @nr: the number of pages to write |
1148 | * |
1149 | * Start writeback on some inodes on this super_block. No guarantees are made |
1150 | * on how many (if any) will be written, and this function does not wait |
1151 | * for IO completion of submitted IO. |
1152 | */ |
1153 | void writeback_inodes_sb_nr(struct super_block *sb, unsigned long nr) |
1154 | { |
1155 | DECLARE_COMPLETION_ONSTACK(done); |
1156 | struct wb_writeback_work work = { |
1157 | .sb = sb, |
1158 | .sync_mode = WB_SYNC_NONE, |
1159 | .done = &done, |
1160 | .nr_pages = nr, |
1161 | }; |
1162 | |
1163 | WARN_ON(!rwsem_is_locked(&sb->s_umount)); |
1164 | bdi_queue_work(sb->s_bdi, &work); |
1165 | wait_for_completion(&done); |
1166 | } |
1167 | EXPORT_SYMBOL(writeback_inodes_sb_nr); |
1168 | |
1169 | /** |
1170 | * writeback_inodes_sb - writeback dirty inodes from given super_block |
1171 | * @sb: the superblock |
1172 | * |
1173 | * Start writeback on some inodes on this super_block. No guarantees are made |
1174 | * on how many (if any) will be written, and this function does not wait |
1175 | * for IO completion of submitted IO. |
1176 | */ |
1177 | void writeback_inodes_sb(struct super_block *sb) |
1178 | { |
1179 | return writeback_inodes_sb_nr(sb, get_nr_dirty_pages()); |
1180 | } |
1181 | EXPORT_SYMBOL(writeback_inodes_sb); |
1182 | |
1183 | /** |
1184 | * writeback_inodes_sb_if_idle - start writeback if none underway |
1185 | * @sb: the superblock |
1186 | * |
1187 | * Invoke writeback_inodes_sb if no writeback is currently underway. |
1188 | * Returns 1 if writeback was started, 0 if not. |
1189 | */ |
1190 | int writeback_inodes_sb_if_idle(struct super_block *sb) |
1191 | { |
1192 | if (!writeback_in_progress(sb->s_bdi)) { |
1193 | down_read(&sb->s_umount); |
1194 | writeback_inodes_sb(sb); |
1195 | up_read(&sb->s_umount); |
1196 | return 1; |
1197 | } else |
1198 | return 0; |
1199 | } |
1200 | EXPORT_SYMBOL(writeback_inodes_sb_if_idle); |
1201 | |
1202 | /** |
1203 | * writeback_inodes_sb_if_idle - start writeback if none underway |
1204 | * @sb: the superblock |
1205 | * @nr: the number of pages to write |
1206 | * |
1207 | * Invoke writeback_inodes_sb if no writeback is currently underway. |
1208 | * Returns 1 if writeback was started, 0 if not. |
1209 | */ |
1210 | int writeback_inodes_sb_nr_if_idle(struct super_block *sb, |
1211 | unsigned long nr) |
1212 | { |
1213 | if (!writeback_in_progress(sb->s_bdi)) { |
1214 | down_read(&sb->s_umount); |
1215 | writeback_inodes_sb_nr(sb, nr); |
1216 | up_read(&sb->s_umount); |
1217 | return 1; |
1218 | } else |
1219 | return 0; |
1220 | } |
1221 | EXPORT_SYMBOL(writeback_inodes_sb_nr_if_idle); |
1222 | |
1223 | /** |
1224 | * sync_inodes_sb - sync sb inode pages |
1225 | * @sb: the superblock |
1226 | * |
1227 | * This function writes and waits on any dirty inode belonging to this |
1228 | * super_block. |
1229 | */ |
1230 | void sync_inodes_sb(struct super_block *sb) |
1231 | { |
1232 | DECLARE_COMPLETION_ONSTACK(done); |
1233 | struct wb_writeback_work work = { |
1234 | .sb = sb, |
1235 | .sync_mode = WB_SYNC_ALL, |
1236 | .nr_pages = LONG_MAX, |
1237 | .range_cyclic = 0, |
1238 | .done = &done, |
1239 | }; |
1240 | |
1241 | WARN_ON(!rwsem_is_locked(&sb->s_umount)); |
1242 | |
1243 | bdi_queue_work(sb->s_bdi, &work); |
1244 | wait_for_completion(&done); |
1245 | |
1246 | wait_sb_inodes(sb); |
1247 | } |
1248 | EXPORT_SYMBOL(sync_inodes_sb); |
1249 | |
1250 | /** |
1251 | * write_inode_now - write an inode to disk |
1252 | * @inode: inode to write to disk |
1253 | * @sync: whether the write should be synchronous or not |
1254 | * |
1255 | * This function commits an inode to disk immediately if it is dirty. This is |
1256 | * primarily needed by knfsd. |
1257 | * |
1258 | * The caller must either have a ref on the inode or must have set I_WILL_FREE. |
1259 | */ |
1260 | int write_inode_now(struct inode *inode, int sync) |
1261 | { |
1262 | int ret; |
1263 | struct writeback_control wbc = { |
1264 | .nr_to_write = LONG_MAX, |
1265 | .sync_mode = sync ? WB_SYNC_ALL : WB_SYNC_NONE, |
1266 | .range_start = 0, |
1267 | .range_end = LLONG_MAX, |
1268 | }; |
1269 | |
1270 | if (!mapping_cap_writeback_dirty(inode->i_mapping)) |
1271 | wbc.nr_to_write = 0; |
1272 | |
1273 | might_sleep(); |
1274 | spin_lock(&inode_lock); |
1275 | ret = writeback_single_inode(inode, &wbc); |
1276 | spin_unlock(&inode_lock); |
1277 | if (sync) |
1278 | inode_sync_wait(inode); |
1279 | return ret; |
1280 | } |
1281 | EXPORT_SYMBOL(write_inode_now); |
1282 | |
1283 | /** |
1284 | * sync_inode - write an inode and its pages to disk. |
1285 | * @inode: the inode to sync |
1286 | * @wbc: controls the writeback mode |
1287 | * |
1288 | * sync_inode() will write an inode and its pages to disk. It will also |
1289 | * correctly update the inode on its superblock's dirty inode lists and will |
1290 | * update inode->i_state. |
1291 | * |
1292 | * The caller must have a ref on the inode. |
1293 | */ |
1294 | int sync_inode(struct inode *inode, struct writeback_control *wbc) |
1295 | { |
1296 | int ret; |
1297 | |
1298 | spin_lock(&inode_lock); |
1299 | ret = writeback_single_inode(inode, wbc); |
1300 | spin_unlock(&inode_lock); |
1301 | return ret; |
1302 | } |
1303 | EXPORT_SYMBOL(sync_inode); |
1304 | |
1305 | /** |
1306 | * sync_inode_metadata - write an inode to disk |
1307 | * @inode: the inode to sync |
1308 | * @wait: wait for I/O to complete. |
1309 | * |
1310 | * Write an inode to disk and adjust its dirty state after completion. |
1311 | * |
1312 | * Note: only writes the actual inode, no associated data or other metadata. |
1313 | */ |
1314 | int sync_inode_metadata(struct inode *inode, int wait) |
1315 | { |
1316 | struct writeback_control wbc = { |
1317 | .sync_mode = wait ? WB_SYNC_ALL : WB_SYNC_NONE, |
1318 | .nr_to_write = 0, /* metadata-only */ |
1319 | }; |
1320 | |
1321 | return sync_inode(inode, &wbc); |
1322 | } |
1323 | EXPORT_SYMBOL(sync_inode_metadata); |
1324 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9