fsync.c 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * linux/fs/ext4/fsync.c
  4. *
  5. * Copyright (C) 1993 Stephen Tweedie (sct@redhat.com)
  6. * from
  7. * Copyright (C) 1992 Remy Card (card@masi.ibp.fr)
  8. * Laboratoire MASI - Institut Blaise Pascal
  9. * Universite Pierre et Marie Curie (Paris VI)
  10. * from
  11. * linux/fs/minix/truncate.c Copyright (C) 1991, 1992 Linus Torvalds
  12. *
  13. * ext4fs fsync primitive
  14. *
  15. * Big-endian to little-endian byte-swapping/bitmaps by
  16. * David S. Miller (davem@caip.rutgers.edu), 1995
  17. *
  18. * Removed unnecessary code duplication for little endian machines
  19. * and excessive __inline__s.
  20. * Andi Kleen, 1997
  21. *
  22. * Major simplications and cleanup - we only need to do the metadata, because
  23. * we can depend on generic_block_fdatasync() to sync the data blocks.
  24. */
  25. #include <linux/time.h>
  26. #include <linux/fs.h>
  27. #include <linux/sched.h>
  28. #include <linux/writeback.h>
  29. #include <linux/blkdev.h>
  30. #include "ext4.h"
  31. #include "ext4_jbd2.h"
  32. #include <trace/events/ext4.h>
  33. /*
  34. * If we're not journaling and this is a just-created file, we have to
  35. * sync our parent directory (if it was freshly created) since
  36. * otherwise it will only be written by writeback, leaving a huge
  37. * window during which a crash may lose the file. This may apply for
  38. * the parent directory's parent as well, and so on recursively, if
  39. * they are also freshly created.
  40. */
  41. static int ext4_sync_parent(struct inode *inode)
  42. {
  43. struct dentry *dentry, *next;
  44. int ret = 0;
  45. if (!ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY))
  46. return 0;
  47. dentry = d_find_any_alias(inode);
  48. if (!dentry)
  49. return 0;
  50. while (ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY)) {
  51. ext4_clear_inode_state(inode, EXT4_STATE_NEWENTRY);
  52. next = dget_parent(dentry);
  53. dput(dentry);
  54. dentry = next;
  55. inode = dentry->d_inode;
  56. /*
  57. * The directory inode may have gone through rmdir by now. But
  58. * the inode itself and its blocks are still allocated (we hold
  59. * a reference to the inode via its dentry), so it didn't go
  60. * through ext4_evict_inode()) and so we are safe to flush
  61. * metadata blocks and the inode.
  62. */
  63. ret = sync_mapping_buffers(inode->i_mapping);
  64. if (ret)
  65. break;
  66. ret = sync_inode_metadata(inode, 1);
  67. if (ret)
  68. break;
  69. }
  70. dput(dentry);
  71. return ret;
  72. }
  73. /*
  74. * akpm: A new design for ext4_sync_file().
  75. *
  76. * This is only called from sys_fsync(), sys_fdatasync() and sys_msync().
  77. * There cannot be a transaction open by this task.
  78. * Another task could have dirtied this inode. Its data can be in any
  79. * state in the journalling system.
  80. *
  81. * What we do is just kick off a commit and wait on it. This will snapshot the
  82. * inode to disk.
  83. */
  84. int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
  85. {
  86. struct inode *inode = file->f_mapping->host;
  87. struct ext4_inode_info *ei = EXT4_I(inode);
  88. journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
  89. int ret = 0, err;
  90. tid_t commit_tid;
  91. bool needs_barrier = false;
  92. if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
  93. return -EIO;
  94. J_ASSERT(ext4_journal_current_handle() == NULL);
  95. trace_ext4_sync_file_enter(file, datasync);
  96. if (sb_rdonly(inode->i_sb)) {
  97. /* Make sure that we read updated s_mount_flags value */
  98. smp_rmb();
  99. if (EXT4_SB(inode->i_sb)->s_mount_flags & EXT4_MF_FS_ABORTED)
  100. ret = -EROFS;
  101. goto out;
  102. }
  103. if (!journal) {
  104. ret = __generic_file_fsync(file, start, end, datasync);
  105. if (!ret)
  106. ret = ext4_sync_parent(inode);
  107. if (test_opt(inode->i_sb, BARRIER))
  108. goto issue_flush;
  109. goto out;
  110. }
  111. ret = file_write_and_wait_range(file, start, end);
  112. if (ret)
  113. return ret;
  114. /*
  115. * data=writeback,ordered:
  116. * The caller's filemap_fdatawrite()/wait will sync the data.
  117. * Metadata is in the journal, we wait for proper transaction to
  118. * commit here.
  119. *
  120. * data=journal:
  121. * filemap_fdatawrite won't do anything (the buffers are clean).
  122. * ext4_force_commit will write the file data into the journal and
  123. * will wait on that.
  124. * filemap_fdatawait() will encounter a ton of newly-dirtied pages
  125. * (they were dirtied by commit). But that's OK - the blocks are
  126. * safe in-journal, which is all fsync() needs to ensure.
  127. */
  128. if (ext4_should_journal_data(inode)) {
  129. ret = ext4_force_commit(inode->i_sb);
  130. goto out;
  131. }
  132. commit_tid = datasync ? ei->i_datasync_tid : ei->i_sync_tid;
  133. if (journal->j_flags & JBD2_BARRIER &&
  134. !jbd2_trans_will_send_data_barrier(journal, commit_tid))
  135. needs_barrier = true;
  136. ret = jbd2_complete_transaction(journal, commit_tid);
  137. if (needs_barrier) {
  138. issue_flush:
  139. err = blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
  140. if (!ret)
  141. ret = err;
  142. }
  143. out:
  144. err = file_check_and_advance_wb_err(file);
  145. if (ret == 0)
  146. ret = err;
  147. trace_ext4_sync_file_exit(inode, ret);
  148. return ret;
  149. }