Andrew Morton | 8984d13 | 2006-12-06 20:37:15 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Interface between ext4 and JBD |
| 3 | */ |
| 4 | |
Christoph Hellwig | 3dcf545 | 2008-04-29 18:13:32 -0400 | [diff] [blame] | 5 | #include "ext4_jbd2.h" |
Andrew Morton | 8984d13 | 2006-12-06 20:37:15 -0800 | [diff] [blame] | 6 | |
Theodore Ts'o | d6797d1 | 2009-11-22 20:52:12 -0500 | [diff] [blame] | 7 | #include <trace/events/ext4.h> |
| 8 | |
Theodore Ts'o | 722887d | 2013-02-08 13:00:31 -0500 | [diff] [blame] | 9 | /* Just increment the non-pointer handle value */ |
| 10 | static handle_t *ext4_get_nojournal(void) |
| 11 | { |
| 12 | handle_t *handle = current->journal_info; |
| 13 | unsigned long ref_cnt = (unsigned long)handle; |
| 14 | |
| 15 | BUG_ON(ref_cnt >= EXT4_NOJOURNAL_MAX_REF_COUNT); |
| 16 | |
| 17 | ref_cnt++; |
| 18 | handle = (handle_t *)ref_cnt; |
| 19 | |
| 20 | current->journal_info = handle; |
| 21 | return handle; |
| 22 | } |
| 23 | |
| 24 | |
| 25 | /* Decrement the non-pointer handle value */ |
| 26 | static void ext4_put_nojournal(handle_t *handle) |
| 27 | { |
| 28 | unsigned long ref_cnt = (unsigned long)handle; |
| 29 | |
| 30 | BUG_ON(ref_cnt == 0); |
| 31 | |
| 32 | ref_cnt--; |
| 33 | handle = (handle_t *)ref_cnt; |
| 34 | |
| 35 | current->journal_info = handle; |
| 36 | } |
| 37 | |
| 38 | /* |
| 39 | * Wrappers for jbd2_journal_start/end. |
| 40 | */ |
Jan Kara | 5fe2fe8 | 2013-06-04 12:37:50 -0400 | [diff] [blame] | 41 | static int ext4_journal_check_start(struct super_block *sb) |
Theodore Ts'o | 722887d | 2013-02-08 13:00:31 -0500 | [diff] [blame] | 42 | { |
| 43 | journal_t *journal; |
| 44 | |
Theodore Ts'o | b10a44c | 2013-04-03 22:00:52 -0400 | [diff] [blame] | 45 | might_sleep(); |
Theodore Ts'o | 722887d | 2013-02-08 13:00:31 -0500 | [diff] [blame] | 46 | if (sb->s_flags & MS_RDONLY) |
Jan Kara | 5fe2fe8 | 2013-06-04 12:37:50 -0400 | [diff] [blame] | 47 | return -EROFS; |
Theodore Ts'o | 722887d | 2013-02-08 13:00:31 -0500 | [diff] [blame] | 48 | WARN_ON(sb->s_writers.frozen == SB_FREEZE_COMPLETE); |
| 49 | journal = EXT4_SB(sb)->s_journal; |
Theodore Ts'o | 722887d | 2013-02-08 13:00:31 -0500 | [diff] [blame] | 50 | /* |
| 51 | * Special case here: if the journal has aborted behind our |
| 52 | * backs (eg. EIO in the commit thread), then we still need to |
| 53 | * take the FS itself readonly cleanly. |
| 54 | */ |
Jan Kara | 5fe2fe8 | 2013-06-04 12:37:50 -0400 | [diff] [blame] | 55 | if (journal && is_journal_aborted(journal)) { |
Theodore Ts'o | 722887d | 2013-02-08 13:00:31 -0500 | [diff] [blame] | 56 | ext4_abort(sb, "Detected aborted journal"); |
Jan Kara | 5fe2fe8 | 2013-06-04 12:37:50 -0400 | [diff] [blame] | 57 | return -EROFS; |
Theodore Ts'o | 722887d | 2013-02-08 13:00:31 -0500 | [diff] [blame] | 58 | } |
Jan Kara | 5fe2fe8 | 2013-06-04 12:37:50 -0400 | [diff] [blame] | 59 | return 0; |
| 60 | } |
| 61 | |
| 62 | handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line, |
| 63 | int type, int blocks, int rsv_blocks) |
| 64 | { |
| 65 | journal_t *journal; |
| 66 | int err; |
| 67 | |
| 68 | trace_ext4_journal_start(sb, blocks, rsv_blocks, _RET_IP_); |
| 69 | err = ext4_journal_check_start(sb); |
| 70 | if (err < 0) |
| 71 | return ERR_PTR(err); |
| 72 | |
| 73 | journal = EXT4_SB(sb)->s_journal; |
| 74 | if (!journal) |
| 75 | return ext4_get_nojournal(); |
| 76 | return jbd2__journal_start(journal, blocks, rsv_blocks, GFP_NOFS, |
| 77 | type, line); |
Theodore Ts'o | 722887d | 2013-02-08 13:00:31 -0500 | [diff] [blame] | 78 | } |
| 79 | |
| 80 | int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle) |
| 81 | { |
| 82 | struct super_block *sb; |
| 83 | int err; |
| 84 | int rc; |
| 85 | |
| 86 | if (!ext4_handle_valid(handle)) { |
| 87 | ext4_put_nojournal(handle); |
| 88 | return 0; |
| 89 | } |
| 90 | sb = handle->h_transaction->t_journal->j_private; |
| 91 | err = handle->h_err; |
| 92 | rc = jbd2_journal_stop(handle); |
| 93 | |
| 94 | if (!err) |
| 95 | err = rc; |
| 96 | if (err) |
| 97 | __ext4_std_error(sb, where, line, err); |
| 98 | return err; |
| 99 | } |
| 100 | |
Jan Kara | 5fe2fe8 | 2013-06-04 12:37:50 -0400 | [diff] [blame] | 101 | handle_t *__ext4_journal_start_reserved(handle_t *handle, unsigned int line, |
| 102 | int type) |
| 103 | { |
| 104 | struct super_block *sb; |
| 105 | int err; |
| 106 | |
| 107 | if (!ext4_handle_valid(handle)) |
| 108 | return ext4_get_nojournal(); |
| 109 | |
| 110 | sb = handle->h_journal->j_private; |
| 111 | trace_ext4_journal_start_reserved(sb, handle->h_buffer_credits, |
| 112 | _RET_IP_); |
| 113 | err = ext4_journal_check_start(sb); |
| 114 | if (err < 0) { |
| 115 | jbd2_journal_free_reserved(handle); |
| 116 | return ERR_PTR(err); |
| 117 | } |
| 118 | |
| 119 | err = jbd2_journal_start_reserved(handle, type, line); |
| 120 | if (err < 0) |
| 121 | return ERR_PTR(err); |
| 122 | return handle; |
| 123 | } |
| 124 | |
Theodore Ts'o | 722887d | 2013-02-08 13:00:31 -0500 | [diff] [blame] | 125 | void ext4_journal_abort_handle(const char *caller, unsigned int line, |
| 126 | const char *err_fn, struct buffer_head *bh, |
| 127 | handle_t *handle, int err) |
| 128 | { |
| 129 | char nbuf[16]; |
| 130 | const char *errstr = ext4_decode_error(NULL, err, nbuf); |
| 131 | |
| 132 | BUG_ON(!ext4_handle_valid(handle)); |
| 133 | |
| 134 | if (bh) |
| 135 | BUFFER_TRACE(bh, "abort"); |
| 136 | |
| 137 | if (!handle->h_err) |
| 138 | handle->h_err = err; |
| 139 | |
| 140 | if (is_handle_aborted(handle)) |
| 141 | return; |
| 142 | |
| 143 | printk(KERN_ERR "EXT4-fs: %s:%d: aborting transaction: %s in %s\n", |
| 144 | caller, line, errstr, err_fn); |
| 145 | |
| 146 | jbd2_journal_abort_handle(handle); |
| 147 | } |
| 148 | |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 149 | int __ext4_journal_get_write_access(const char *where, unsigned int line, |
| 150 | handle_t *handle, struct buffer_head *bh) |
Andrew Morton | 8984d13 | 2006-12-06 20:37:15 -0800 | [diff] [blame] | 151 | { |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 152 | int err = 0; |
| 153 | |
Theodore Ts'o | b10a44c | 2013-04-03 22:00:52 -0400 | [diff] [blame] | 154 | might_sleep(); |
| 155 | |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 156 | if (ext4_handle_valid(handle)) { |
| 157 | err = jbd2_journal_get_write_access(handle, bh); |
| 158 | if (err) |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 159 | ext4_journal_abort_handle(where, line, __func__, bh, |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 160 | handle, err); |
| 161 | } |
Andrew Morton | 8984d13 | 2006-12-06 20:37:15 -0800 | [diff] [blame] | 162 | return err; |
| 163 | } |
| 164 | |
Theodore Ts'o | d6797d1 | 2009-11-22 20:52:12 -0500 | [diff] [blame] | 165 | /* |
| 166 | * The ext4 forget function must perform a revoke if we are freeing data |
| 167 | * which has been journaled. Metadata (eg. indirect blocks) must be |
| 168 | * revoked in all cases. |
| 169 | * |
| 170 | * "bh" may be NULL: a metadata block may have been freed from memory |
| 171 | * but there may still be a record of it in the journal, and that record |
| 172 | * still needs to be revoked. |
| 173 | * |
| 174 | * If the handle isn't valid we're not journaling, but we still need to |
| 175 | * call into ext4_journal_revoke() to put the buffer head. |
| 176 | */ |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 177 | int __ext4_forget(const char *where, unsigned int line, handle_t *handle, |
| 178 | int is_metadata, struct inode *inode, |
| 179 | struct buffer_head *bh, ext4_fsblk_t blocknr) |
Theodore Ts'o | d6797d1 | 2009-11-22 20:52:12 -0500 | [diff] [blame] | 180 | { |
| 181 | int err; |
| 182 | |
| 183 | might_sleep(); |
| 184 | |
| 185 | trace_ext4_forget(inode, is_metadata, blocknr); |
| 186 | BUFFER_TRACE(bh, "enter"); |
| 187 | |
| 188 | jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, " |
| 189 | "data mode %x\n", |
| 190 | bh, is_metadata, inode->i_mode, |
| 191 | test_opt(inode->i_sb, DATA_FLAGS)); |
| 192 | |
Theodore Ts'o | e4684b3 | 2009-11-24 11:05:59 -0500 | [diff] [blame] | 193 | /* In the no journal case, we can just do a bforget and return */ |
| 194 | if (!ext4_handle_valid(handle)) { |
| 195 | bforget(bh); |
| 196 | return 0; |
| 197 | } |
| 198 | |
Theodore Ts'o | d6797d1 | 2009-11-22 20:52:12 -0500 | [diff] [blame] | 199 | /* Never use the revoke function if we are doing full data |
| 200 | * journaling: there is no need to, and a V1 superblock won't |
| 201 | * support it. Otherwise, only skip the revoke on un-journaled |
| 202 | * data blocks. */ |
| 203 | |
| 204 | if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA || |
| 205 | (!is_metadata && !ext4_should_journal_data(inode))) { |
| 206 | if (bh) { |
| 207 | BUFFER_TRACE(bh, "call jbd2_journal_forget"); |
Theodore Ts'o | b7e57e7 | 2009-11-22 21:00:13 -0500 | [diff] [blame] | 208 | err = jbd2_journal_forget(handle, bh); |
| 209 | if (err) |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 210 | ext4_journal_abort_handle(where, line, __func__, |
| 211 | bh, handle, err); |
Theodore Ts'o | b7e57e7 | 2009-11-22 21:00:13 -0500 | [diff] [blame] | 212 | return err; |
Theodore Ts'o | d6797d1 | 2009-11-22 20:52:12 -0500 | [diff] [blame] | 213 | } |
| 214 | return 0; |
| 215 | } |
| 216 | |
| 217 | /* |
| 218 | * data!=journal && (is_metadata || should_journal_data(inode)) |
| 219 | */ |
Theodore Ts'o | e4684b3 | 2009-11-24 11:05:59 -0500 | [diff] [blame] | 220 | BUFFER_TRACE(bh, "call jbd2_journal_revoke"); |
| 221 | err = jbd2_journal_revoke(handle, blocknr, bh); |
| 222 | if (err) { |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 223 | ext4_journal_abort_handle(where, line, __func__, |
| 224 | bh, handle, err); |
Theodore Ts'o | c398eda | 2010-07-27 11:56:40 -0400 | [diff] [blame] | 225 | __ext4_abort(inode->i_sb, where, line, |
| 226 | "error %d when attempting revoke", err); |
Theodore Ts'o | e4684b3 | 2009-11-24 11:05:59 -0500 | [diff] [blame] | 227 | } |
Theodore Ts'o | d6797d1 | 2009-11-22 20:52:12 -0500 | [diff] [blame] | 228 | BUFFER_TRACE(bh, "exit"); |
| 229 | return err; |
| 230 | } |
| 231 | |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 232 | int __ext4_journal_get_create_access(const char *where, unsigned int line, |
Andrew Morton | 8984d13 | 2006-12-06 20:37:15 -0800 | [diff] [blame] | 233 | handle_t *handle, struct buffer_head *bh) |
| 234 | { |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 235 | int err = 0; |
| 236 | |
| 237 | if (ext4_handle_valid(handle)) { |
| 238 | err = jbd2_journal_get_create_access(handle, bh); |
| 239 | if (err) |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 240 | ext4_journal_abort_handle(where, line, __func__, |
| 241 | bh, handle, err); |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 242 | } |
Andrew Morton | 8984d13 | 2006-12-06 20:37:15 -0800 | [diff] [blame] | 243 | return err; |
| 244 | } |
| 245 | |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 246 | int __ext4_handle_dirty_metadata(const char *where, unsigned int line, |
| 247 | handle_t *handle, struct inode *inode, |
| 248 | struct buffer_head *bh) |
Andrew Morton | 8984d13 | 2006-12-06 20:37:15 -0800 | [diff] [blame] | 249 | { |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 250 | int err = 0; |
| 251 | |
Theodore Ts'o | b10a44c | 2013-04-03 22:00:52 -0400 | [diff] [blame] | 252 | might_sleep(); |
| 253 | |
Theodore Ts'o | 13fca32 | 2013-04-21 16:45:54 -0400 | [diff] [blame] | 254 | set_buffer_meta(bh); |
| 255 | set_buffer_prio(bh); |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 256 | if (ext4_handle_valid(handle)) { |
| 257 | err = jbd2_journal_dirty_metadata(handle, bh); |
Jan Kara | 91aa11f | 2013-08-12 09:53:28 -0400 | [diff] [blame] | 258 | /* Errors can only happen if there is a bug */ |
| 259 | if (WARN_ON_ONCE(err)) { |
| 260 | ext4_journal_abort_handle(where, line, __func__, bh, |
| 261 | handle, err); |
Theodore Ts'o | 66a4cb1 | 2014-03-12 16:38:03 -0400 | [diff] [blame] | 262 | if (inode == NULL) { |
| 263 | pr_err("EXT4: jbd2_journal_dirty_metadata " |
| 264 | "failed: handle type %u started at " |
| 265 | "line %u, credits %u/%u, errcode %d", |
| 266 | handle->h_type, |
| 267 | handle->h_line_no, |
| 268 | handle->h_requested_credits, |
| 269 | handle->h_buffer_credits, err); |
| 270 | return err; |
| 271 | } |
Theodore Ts'o | ae1495b | 2013-12-02 09:31:36 -0500 | [diff] [blame] | 272 | ext4_error_inode(inode, where, line, |
| 273 | bh->b_blocknr, |
| 274 | "journal_dirty_metadata failed: " |
| 275 | "handle type %u started at line %u, " |
| 276 | "credits %u/%u, errcode %d", |
| 277 | handle->h_type, |
| 278 | handle->h_line_no, |
| 279 | handle->h_requested_credits, |
| 280 | handle->h_buffer_credits, err); |
Theodore Ts'o | 9ea7a0d | 2011-09-04 10:18:14 -0400 | [diff] [blame] | 281 | } |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 282 | } else { |
Curt Wohlgemuth | 73b50c1 | 2010-02-16 15:06:29 -0500 | [diff] [blame] | 283 | if (inode) |
Theodore Ts'o | fe188c0 | 2009-09-12 13:41:55 -0400 | [diff] [blame] | 284 | mark_buffer_dirty_inode(bh, inode); |
| 285 | else |
| 286 | mark_buffer_dirty(bh); |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 287 | if (inode && inode_needs_sync(inode)) { |
| 288 | sync_dirty_buffer(bh); |
| 289 | if (buffer_req(bh) && !buffer_uptodate(bh)) { |
Theodore Ts'o | 1c13d5c | 2010-07-27 11:56:03 -0400 | [diff] [blame] | 290 | struct ext4_super_block *es; |
| 291 | |
| 292 | es = EXT4_SB(inode->i_sb)->s_es; |
| 293 | es->s_last_error_block = |
| 294 | cpu_to_le64(bh->b_blocknr); |
Theodore Ts'o | c398eda | 2010-07-27 11:56:40 -0400 | [diff] [blame] | 295 | ext4_error_inode(inode, where, line, |
| 296 | bh->b_blocknr, |
| 297 | "IO error syncing itable block"); |
Frank Mayhar | 0390131 | 2009-01-07 00:06:22 -0500 | [diff] [blame] | 298 | err = -EIO; |
| 299 | } |
| 300 | } |
| 301 | } |
Andrew Morton | 8984d13 | 2006-12-06 20:37:15 -0800 | [diff] [blame] | 302 | return err; |
| 303 | } |
Theodore Ts'o | a037515 | 2010-06-11 23:14:04 -0400 | [diff] [blame] | 304 | |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 305 | int __ext4_handle_dirty_super(const char *where, unsigned int line, |
Artem Bityutskiy | b50924c | 2012-07-22 20:37:31 -0400 | [diff] [blame] | 306 | handle_t *handle, struct super_block *sb) |
Theodore Ts'o | a037515 | 2010-06-11 23:14:04 -0400 | [diff] [blame] | 307 | { |
| 308 | struct buffer_head *bh = EXT4_SB(sb)->s_sbh; |
| 309 | int err = 0; |
| 310 | |
Theodore Ts'o | 06db49e | 2012-10-10 01:06:58 -0400 | [diff] [blame] | 311 | ext4_superblock_csum_set(sb); |
Theodore Ts'o | a037515 | 2010-06-11 23:14:04 -0400 | [diff] [blame] | 312 | if (ext4_handle_valid(handle)) { |
| 313 | err = jbd2_journal_dirty_metadata(handle, bh); |
| 314 | if (err) |
Theodore Ts'o | 90c7201 | 2010-06-29 14:53:24 -0400 | [diff] [blame] | 315 | ext4_journal_abort_handle(where, line, __func__, |
| 316 | bh, handle, err); |
Theodore Ts'o | 06db49e | 2012-10-10 01:06:58 -0400 | [diff] [blame] | 317 | } else |
Darrick J. Wong | a9c47317 | 2012-04-29 18:29:10 -0400 | [diff] [blame] | 318 | mark_buffer_dirty(bh); |
Theodore Ts'o | a037515 | 2010-06-11 23:14:04 -0400 | [diff] [blame] | 319 | return err; |
| 320 | } |