]>
Commit | Line | Data |
---|---|---|
ac27a0ec | 1 | /* |
617ba13b | 2 | * linux/fs/ext4/fsync.c |
ac27a0ec DK |
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 | * | |
617ba13b | 12 | * ext4fs fsync primitive |
ac27a0ec DK |
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 | ||
25 | #include <linux/time.h> | |
26 | #include <linux/fs.h> | |
27 | #include <linux/sched.h> | |
28 | #include <linux/writeback.h> | |
dab291af | 29 | #include <linux/jbd2.h> |
d755fb38 | 30 | #include <linux/blkdev.h> |
9bffad1e | 31 | |
3dcf5451 CH |
32 | #include "ext4.h" |
33 | #include "ext4_jbd2.h" | |
ac27a0ec | 34 | |
9bffad1e TT |
35 | #include <trace/events/ext4.h> |
36 | ||
14ece102 FM |
37 | /* |
38 | * If we're not journaling and this is a just-created file, we have to | |
39 | * sync our parent directory (if it was freshly created) since | |
40 | * otherwise it will only be written by writeback, leaving a huge | |
41 | * window during which a crash may lose the file. This may apply for | |
42 | * the parent directory's parent as well, and so on recursively, if | |
43 | * they are also freshly created. | |
44 | */ | |
45 | static void ext4_sync_parent(struct inode *inode) | |
46 | { | |
47 | struct dentry *dentry = NULL; | |
48 | ||
49 | while (inode && ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY)) { | |
50 | ext4_clear_inode_state(inode, EXT4_STATE_NEWENTRY); | |
51 | dentry = list_entry(inode->i_dentry.next, | |
52 | struct dentry, d_alias); | |
53 | if (!dentry || !dentry->d_parent || !dentry->d_parent->d_inode) | |
54 | break; | |
55 | inode = dentry->d_parent->d_inode; | |
56 | sync_mapping_buffers(inode->i_mapping); | |
57 | } | |
58 | } | |
59 | ||
ac27a0ec | 60 | /* |
617ba13b | 61 | * akpm: A new design for ext4_sync_file(). |
ac27a0ec DK |
62 | * |
63 | * This is only called from sys_fsync(), sys_fdatasync() and sys_msync(). | |
64 | * There cannot be a transaction open by this task. | |
65 | * Another task could have dirtied this inode. Its data can be in any | |
66 | * state in the journalling system. | |
67 | * | |
68 | * What we do is just kick off a commit and wait on it. This will snapshot the | |
69 | * inode to disk. | |
8d5d02e6 MC |
70 | * |
71 | * i_mutex lock is held when entering and exiting this function | |
ac27a0ec DK |
72 | */ |
73 | ||
7ea80859 | 74 | int ext4_sync_file(struct file *file, int datasync) |
ac27a0ec | 75 | { |
7ea80859 | 76 | struct inode *inode = file->f_mapping->host; |
b436b9be | 77 | struct ext4_inode_info *ei = EXT4_I(inode); |
d755fb38 | 78 | journal_t *journal = EXT4_SB(inode->i_sb)->s_journal; |
b436b9be JK |
79 | int ret; |
80 | tid_t commit_tid; | |
ac27a0ec | 81 | |
ac39849d | 82 | J_ASSERT(ext4_journal_current_handle() == NULL); |
ac27a0ec | 83 | |
7ea80859 | 84 | trace_ext4_sync_file(file, datasync); |
ede86cc4 | 85 | |
b436b9be JK |
86 | if (inode->i_sb->s_flags & MS_RDONLY) |
87 | return 0; | |
88 | ||
c7064ef1 | 89 | ret = flush_completed_IO(inode); |
8d5d02e6 | 90 | if (ret < 0) |
6b17d902 | 91 | return ret; |
60e6679e | 92 | |
14ece102 | 93 | if (!journal) { |
7ea80859 | 94 | ret = simple_fsync(file, datasync); |
14ece102 FM |
95 | if (!ret && !list_empty(&inode->i_dentry)) |
96 | ext4_sync_parent(inode); | |
97 | return ret; | |
98 | } | |
b436b9be | 99 | |
ac27a0ec | 100 | /* |
b436b9be | 101 | * data=writeback,ordered: |
ac27a0ec | 102 | * The caller's filemap_fdatawrite()/wait will sync the data. |
b436b9be JK |
103 | * Metadata is in the journal, we wait for proper transaction to |
104 | * commit here. | |
ac27a0ec DK |
105 | * |
106 | * data=journal: | |
107 | * filemap_fdatawrite won't do anything (the buffers are clean). | |
617ba13b | 108 | * ext4_force_commit will write the file data into the journal and |
ac27a0ec DK |
109 | * will wait on that. |
110 | * filemap_fdatawait() will encounter a ton of newly-dirtied pages | |
111 | * (they were dirtied by commit). But that's OK - the blocks are | |
112 | * safe in-journal, which is all fsync() needs to ensure. | |
113 | */ | |
6b17d902 TT |
114 | if (ext4_should_journal_data(inode)) |
115 | return ext4_force_commit(inode->i_sb); | |
ac27a0ec | 116 | |
b436b9be | 117 | commit_tid = datasync ? ei->i_datasync_tid : ei->i_sync_tid; |
cc3e1bea TT |
118 | if (jbd2_log_start_commit(journal, commit_tid)) { |
119 | /* | |
120 | * When the journal is on a different device than the | |
121 | * fs data disk, we need to issue the barrier in | |
122 | * writeback mode. (In ordered mode, the jbd2 layer | |
123 | * will take care of issuing the barrier. In | |
124 | * data=journal, all of the data blocks are written to | |
125 | * the journal device.) | |
126 | */ | |
127 | if (ext4_should_writeback_data(inode) && | |
128 | (journal->j_fs_dev != journal->j_dev) && | |
129 | (journal->j_flags & JBD2_BARRIER)) | |
fbd9b09a DM |
130 | blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, |
131 | NULL, BLKDEV_IFL_WAIT); | |
0671e704 | 132 | ret = jbd2_log_wait_commit(journal, commit_tid); |
cc3e1bea | 133 | } else if (journal->j_flags & JBD2_BARRIER) |
fbd9b09a DM |
134 | blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL, |
135 | BLKDEV_IFL_WAIT); | |
ac27a0ec DK |
136 | return ret; |
137 | } |