original development tree for Linux kernel GTP module; now long in mainline.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

151 lines
4.3 KiB

  1. /*
  2. * linux/fs/ext4/fsync.c
  3. *
  4. * Copyright (C) 1993 Stephen Tweedie (sct@redhat.com)
  5. * from
  6. * Copyright (C) 1992 Remy Card (card@masi.ibp.fr)
  7. * Laboratoire MASI - Institut Blaise Pascal
  8. * Universite Pierre et Marie Curie (Paris VI)
  9. * from
  10. * linux/fs/minix/truncate.c Copyright (C) 1991, 1992 Linus Torvalds
  11. *
  12. * ext4fs fsync primitive
  13. *
  14. * Big-endian to little-endian byte-swapping/bitmaps by
  15. * David S. Miller (davem@caip.rutgers.edu), 1995
  16. *
  17. * Removed unnecessary code duplication for little endian machines
  18. * and excessive __inline__s.
  19. * Andi Kleen, 1997
  20. *
  21. * Major simplications and cleanup - we only need to do the metadata, because
  22. * we can depend on generic_block_fdatasync() to sync the data blocks.
  23. */
  24. #include <linux/time.h>
  25. #include <linux/fs.h>
  26. #include <linux/sched.h>
  27. #include <linux/writeback.h>
  28. #include <linux/jbd2.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 = NULL;
  44. struct inode *next;
  45. int ret = 0;
  46. if (!ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY))
  47. return 0;
  48. inode = igrab(inode);
  49. while (ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY)) {
  50. ext4_clear_inode_state(inode, EXT4_STATE_NEWENTRY);
  51. dentry = d_find_any_alias(inode);
  52. if (!dentry)
  53. break;
  54. next = igrab(dentry->d_parent->d_inode);
  55. dput(dentry);
  56. if (!next)
  57. break;
  58. iput(inode);
  59. inode = next;
  60. ret = sync_mapping_buffers(inode->i_mapping);
  61. if (ret)
  62. break;
  63. ret = sync_inode_metadata(inode, 1);
  64. if (ret)
  65. break;
  66. }
  67. iput(inode);
  68. return ret;
  69. }
  70. /*
  71. * akpm: A new design for ext4_sync_file().
  72. *
  73. * This is only called from sys_fsync(), sys_fdatasync() and sys_msync().
  74. * There cannot be a transaction open by this task.
  75. * Another task could have dirtied this inode. Its data can be in any
  76. * state in the journalling system.
  77. *
  78. * What we do is just kick off a commit and wait on it. This will snapshot the
  79. * inode to disk.
  80. */
  81. int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
  82. {
  83. struct inode *inode = file->f_mapping->host;
  84. struct ext4_inode_info *ei = EXT4_I(inode);
  85. journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
  86. int ret = 0, err;
  87. tid_t commit_tid;
  88. bool needs_barrier = false;
  89. J_ASSERT(ext4_journal_current_handle() == NULL);
  90. trace_ext4_sync_file_enter(file, datasync);
  91. if (inode->i_sb->s_flags & MS_RDONLY) {
  92. /* Make sure that we read updated s_mount_flags value */
  93. smp_rmb();
  94. if (EXT4_SB(inode->i_sb)->s_mount_flags & EXT4_MF_FS_ABORTED)
  95. ret = -EROFS;
  96. goto out;
  97. }
  98. if (!journal) {
  99. ret = generic_file_fsync(file, start, end, datasync);
  100. if (!ret && !hlist_empty(&inode->i_dentry))
  101. ret = ext4_sync_parent(inode);
  102. goto out;
  103. }
  104. ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
  105. if (ret)
  106. return ret;
  107. /*
  108. * data=writeback,ordered:
  109. * The caller's filemap_fdatawrite()/wait will sync the data.
  110. * Metadata is in the journal, we wait for proper transaction to
  111. * commit here.
  112. *
  113. * data=journal:
  114. * filemap_fdatawrite won't do anything (the buffers are clean).
  115. * ext4_force_commit will write the file data into the journal and
  116. * will wait on that.
  117. * filemap_fdatawait() will encounter a ton of newly-dirtied pages
  118. * (they were dirtied by commit). But that's OK - the blocks are
  119. * safe in-journal, which is all fsync() needs to ensure.
  120. */
  121. if (ext4_should_journal_data(inode)) {
  122. ret = ext4_force_commit(inode->i_sb);
  123. goto out;
  124. }
  125. commit_tid = datasync ? ei->i_datasync_tid : ei->i_sync_tid;
  126. if (journal->j_flags & JBD2_BARRIER &&
  127. !jbd2_trans_will_send_data_barrier(journal, commit_tid))
  128. needs_barrier = true;
  129. ret = jbd2_complete_transaction(journal, commit_tid);
  130. if (needs_barrier) {
  131. err = blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
  132. if (!ret)
  133. ret = err;
  134. }
  135. out:
  136. trace_ext4_sync_file_exit(inode, ret);
  137. return ret;
  138. }