Commit | Line | Data |
---|---|---|
8984d137 AM |
1 | /* |
2 | * Interface between ext4 and JBD | |
3 | */ | |
4 | ||
3dcf5451 | 5 | #include "ext4_jbd2.h" |
8984d137 | 6 | |
d6797d14 TT |
7 | #include <trace/events/ext4.h> |
8 | ||
8984d137 AM |
9 | int __ext4_journal_get_undo_access(const char *where, handle_t *handle, |
10 | struct buffer_head *bh) | |
11 | { | |
0390131b FM |
12 | int err = 0; |
13 | ||
14 | if (ext4_handle_valid(handle)) { | |
15 | err = jbd2_journal_get_undo_access(handle, bh); | |
16 | if (err) | |
17 | ext4_journal_abort_handle(where, __func__, bh, | |
18 | handle, err); | |
19 | } | |
8984d137 AM |
20 | return err; |
21 | } | |
22 | ||
23 | int __ext4_journal_get_write_access(const char *where, handle_t *handle, | |
24 | struct buffer_head *bh) | |
25 | { | |
0390131b FM |
26 | int err = 0; |
27 | ||
28 | if (ext4_handle_valid(handle)) { | |
29 | err = jbd2_journal_get_write_access(handle, bh); | |
30 | if (err) | |
31 | ext4_journal_abort_handle(where, __func__, bh, | |
32 | handle, err); | |
33 | } | |
8984d137 AM |
34 | return err; |
35 | } | |
36 | ||
37 | int __ext4_journal_forget(const char *where, handle_t *handle, | |
38 | struct buffer_head *bh) | |
39 | { | |
0390131b FM |
40 | int err = 0; |
41 | ||
42 | if (ext4_handle_valid(handle)) { | |
43 | err = jbd2_journal_forget(handle, bh); | |
44 | if (err) | |
45 | ext4_journal_abort_handle(where, __func__, bh, | |
46 | handle, err); | |
47 | } | |
e6b5d301 | 48 | else |
c7acb4c1 | 49 | bforget(bh); |
8984d137 AM |
50 | return err; |
51 | } | |
52 | ||
53 | int __ext4_journal_revoke(const char *where, handle_t *handle, | |
54 | ext4_fsblk_t blocknr, struct buffer_head *bh) | |
55 | { | |
0390131b FM |
56 | int err = 0; |
57 | ||
58 | if (ext4_handle_valid(handle)) { | |
59 | err = jbd2_journal_revoke(handle, blocknr, bh); | |
60 | if (err) | |
61 | ext4_journal_abort_handle(where, __func__, bh, | |
62 | handle, err); | |
63 | } | |
e6b5d301 | 64 | else |
c7acb4c1 | 65 | bforget(bh); |
8984d137 AM |
66 | return err; |
67 | } | |
68 | ||
d6797d14 TT |
69 | /* |
70 | * The ext4 forget function must perform a revoke if we are freeing data | |
71 | * which has been journaled. Metadata (eg. indirect blocks) must be | |
72 | * revoked in all cases. | |
73 | * | |
74 | * "bh" may be NULL: a metadata block may have been freed from memory | |
75 | * but there may still be a record of it in the journal, and that record | |
76 | * still needs to be revoked. | |
77 | * | |
78 | * If the handle isn't valid we're not journaling, but we still need to | |
79 | * call into ext4_journal_revoke() to put the buffer head. | |
80 | */ | |
81 | int __ext4_forget(const char *where, handle_t *handle, int is_metadata, | |
82 | struct inode *inode, struct buffer_head *bh, | |
83 | ext4_fsblk_t blocknr) | |
84 | { | |
85 | int err; | |
86 | ||
87 | might_sleep(); | |
88 | ||
89 | trace_ext4_forget(inode, is_metadata, blocknr); | |
90 | BUFFER_TRACE(bh, "enter"); | |
91 | ||
92 | jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, " | |
93 | "data mode %x\n", | |
94 | bh, is_metadata, inode->i_mode, | |
95 | test_opt(inode->i_sb, DATA_FLAGS)); | |
96 | ||
97 | /* Never use the revoke function if we are doing full data | |
98 | * journaling: there is no need to, and a V1 superblock won't | |
99 | * support it. Otherwise, only skip the revoke on un-journaled | |
100 | * data blocks. */ | |
101 | ||
102 | if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA || | |
103 | (!is_metadata && !ext4_should_journal_data(inode))) { | |
104 | if (bh) { | |
105 | BUFFER_TRACE(bh, "call jbd2_journal_forget"); | |
106 | return __ext4_journal_forget(where, handle, bh); | |
107 | } | |
108 | return 0; | |
109 | } | |
110 | ||
111 | /* | |
112 | * data!=journal && (is_metadata || should_journal_data(inode)) | |
113 | */ | |
114 | BUFFER_TRACE(bh, "call ext4_journal_revoke"); | |
115 | err = __ext4_journal_revoke(where, handle, blocknr, bh); | |
116 | if (err) | |
117 | ext4_abort(inode->i_sb, __func__, | |
118 | "error %d when attempting revoke", err); | |
119 | BUFFER_TRACE(bh, "exit"); | |
120 | return err; | |
121 | } | |
122 | ||
8984d137 AM |
123 | int __ext4_journal_get_create_access(const char *where, |
124 | handle_t *handle, struct buffer_head *bh) | |
125 | { | |
0390131b FM |
126 | int err = 0; |
127 | ||
128 | if (ext4_handle_valid(handle)) { | |
129 | err = jbd2_journal_get_create_access(handle, bh); | |
130 | if (err) | |
131 | ext4_journal_abort_handle(where, __func__, bh, | |
132 | handle, err); | |
133 | } | |
8984d137 AM |
134 | return err; |
135 | } | |
136 | ||
0390131b FM |
137 | int __ext4_handle_dirty_metadata(const char *where, handle_t *handle, |
138 | struct inode *inode, struct buffer_head *bh) | |
8984d137 | 139 | { |
0390131b FM |
140 | int err = 0; |
141 | ||
142 | if (ext4_handle_valid(handle)) { | |
143 | err = jbd2_journal_dirty_metadata(handle, bh); | |
144 | if (err) | |
145 | ext4_journal_abort_handle(where, __func__, bh, | |
146 | handle, err); | |
147 | } else { | |
fe188c0e TT |
148 | if (inode && bh) |
149 | mark_buffer_dirty_inode(bh, inode); | |
150 | else | |
151 | mark_buffer_dirty(bh); | |
0390131b FM |
152 | if (inode && inode_needs_sync(inode)) { |
153 | sync_dirty_buffer(bh); | |
154 | if (buffer_req(bh) && !buffer_uptodate(bh)) { | |
155 | ext4_error(inode->i_sb, __func__, | |
156 | "IO error syncing inode, " | |
157 | "inode=%lu, block=%llu", | |
158 | inode->i_ino, | |
159 | (unsigned long long) bh->b_blocknr); | |
160 | err = -EIO; | |
161 | } | |
162 | } | |
163 | } | |
8984d137 AM |
164 | return err; |
165 | } |