]>
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 | ||
d6797d14 TT |
53 | /* |
54 | * The ext4 forget function must perform a revoke if we are freeing data | |
55 | * which has been journaled. Metadata (eg. indirect blocks) must be | |
56 | * revoked in all cases. | |
57 | * | |
58 | * "bh" may be NULL: a metadata block may have been freed from memory | |
59 | * but there may still be a record of it in the journal, and that record | |
60 | * still needs to be revoked. | |
61 | * | |
62 | * If the handle isn't valid we're not journaling, but we still need to | |
63 | * call into ext4_journal_revoke() to put the buffer head. | |
64 | */ | |
65 | int __ext4_forget(const char *where, handle_t *handle, int is_metadata, | |
66 | struct inode *inode, struct buffer_head *bh, | |
67 | ext4_fsblk_t blocknr) | |
68 | { | |
69 | int err; | |
70 | ||
71 | might_sleep(); | |
72 | ||
73 | trace_ext4_forget(inode, is_metadata, blocknr); | |
74 | BUFFER_TRACE(bh, "enter"); | |
75 | ||
76 | jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, " | |
77 | "data mode %x\n", | |
78 | bh, is_metadata, inode->i_mode, | |
79 | test_opt(inode->i_sb, DATA_FLAGS)); | |
80 | ||
e4684b3f TT |
81 | /* In the no journal case, we can just do a bforget and return */ |
82 | if (!ext4_handle_valid(handle)) { | |
83 | bforget(bh); | |
84 | return 0; | |
85 | } | |
86 | ||
d6797d14 TT |
87 | /* Never use the revoke function if we are doing full data |
88 | * journaling: there is no need to, and a V1 superblock won't | |
89 | * support it. Otherwise, only skip the revoke on un-journaled | |
90 | * data blocks. */ | |
91 | ||
92 | if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA || | |
93 | (!is_metadata && !ext4_should_journal_data(inode))) { | |
94 | if (bh) { | |
95 | BUFFER_TRACE(bh, "call jbd2_journal_forget"); | |
96 | return __ext4_journal_forget(where, handle, bh); | |
97 | } | |
98 | return 0; | |
99 | } | |
100 | ||
101 | /* | |
102 | * data!=journal && (is_metadata || should_journal_data(inode)) | |
103 | */ | |
e4684b3f TT |
104 | BUFFER_TRACE(bh, "call jbd2_journal_revoke"); |
105 | err = jbd2_journal_revoke(handle, blocknr, bh); | |
106 | if (err) { | |
107 | ext4_journal_abort_handle(where, __func__, bh, handle, err); | |
d6797d14 TT |
108 | ext4_abort(inode->i_sb, __func__, |
109 | "error %d when attempting revoke", err); | |
e4684b3f | 110 | } |
d6797d14 TT |
111 | BUFFER_TRACE(bh, "exit"); |
112 | return err; | |
113 | } | |
114 | ||
8984d137 AM |
115 | int __ext4_journal_get_create_access(const char *where, |
116 | handle_t *handle, struct buffer_head *bh) | |
117 | { | |
0390131b FM |
118 | int err = 0; |
119 | ||
120 | if (ext4_handle_valid(handle)) { | |
121 | err = jbd2_journal_get_create_access(handle, bh); | |
122 | if (err) | |
123 | ext4_journal_abort_handle(where, __func__, bh, | |
124 | handle, err); | |
125 | } | |
8984d137 AM |
126 | return err; |
127 | } | |
128 | ||
0390131b FM |
129 | int __ext4_handle_dirty_metadata(const char *where, handle_t *handle, |
130 | struct inode *inode, struct buffer_head *bh) | |
8984d137 | 131 | { |
0390131b FM |
132 | int err = 0; |
133 | ||
134 | if (ext4_handle_valid(handle)) { | |
135 | err = jbd2_journal_dirty_metadata(handle, bh); | |
136 | if (err) | |
137 | ext4_journal_abort_handle(where, __func__, bh, | |
138 | handle, err); | |
139 | } else { | |
fe188c0e TT |
140 | if (inode && bh) |
141 | mark_buffer_dirty_inode(bh, inode); | |
142 | else | |
143 | mark_buffer_dirty(bh); | |
0390131b FM |
144 | if (inode && inode_needs_sync(inode)) { |
145 | sync_dirty_buffer(bh); | |
146 | if (buffer_req(bh) && !buffer_uptodate(bh)) { | |
147 | ext4_error(inode->i_sb, __func__, | |
148 | "IO error syncing inode, " | |
149 | "inode=%lu, block=%llu", | |
150 | inode->i_ino, | |
151 | (unsigned long long) bh->b_blocknr); | |
152 | err = -EIO; | |
153 | } | |
154 | } | |
155 | } | |
8984d137 AM |
156 | return err; |
157 | } |