fs-writeback.c 35 KB

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