1 /* 2 * Interface between ext4 and JBD 3 */ 4 5 #include "ext4_jbd2.h" 6 7 #include <trace/events/ext4.h> 8 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 */ 41 static int ext4_journal_check_start(struct super_block *sb) 42 { 43 journal_t *journal; 44 45 might_sleep(); 46 if (sb->s_flags & MS_RDONLY) 47 return -EROFS; 48 WARN_ON(sb->s_writers.frozen == SB_FREEZE_COMPLETE); 49 journal = EXT4_SB(sb)->s_journal; 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 */ 55 if (journal && is_journal_aborted(journal)) { 56 ext4_abort(sb, "Detected aborted journal"); 57 return -EROFS; 58 } 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); 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 91 err = handle->h_err; 92 if (!handle->h_transaction) { 93 rc = jbd2_journal_stop(handle); 94 return err ? err : rc; 95 } 96 97 sb = handle->h_transaction->t_journal->j_private; 98 rc = jbd2_journal_stop(handle); 99 100 if (!err) 101 err = rc; 102 if (err) 103 __ext4_std_error(sb, where, line, err); 104 return err; 105 } 106 107 handle_t *__ext4_journal_start_reserved(handle_t *handle, unsigned int line, 108 int type) 109 { 110 struct super_block *sb; 111 int err; 112 113 if (!ext4_handle_valid(handle)) 114 return ext4_get_nojournal(); 115 116 sb = handle->h_journal->j_private; 117 trace_ext4_journal_start_reserved(sb, handle->h_buffer_credits, 118 _RET_IP_); 119 err = ext4_journal_check_start(sb); 120 if (err < 0) { 121 jbd2_journal_free_reserved(handle); 122 return ERR_PTR(err); 123 } 124 125 err = jbd2_journal_start_reserved(handle, type, line); 126 if (err < 0) 127 return ERR_PTR(err); 128 return handle; 129 } 130 131 static void ext4_journal_abort_handle(const char *caller, unsigned int line, 132 const char *err_fn, 133 struct buffer_head *bh, 134 handle_t *handle, int err) 135 { 136 char nbuf[16]; 137 const char *errstr = ext4_decode_error(NULL, err, nbuf); 138 139 BUG_ON(!ext4_handle_valid(handle)); 140 141 if (bh) 142 BUFFER_TRACE(bh, "abort"); 143 144 if (!handle->h_err) 145 handle->h_err = err; 146 147 if (is_handle_aborted(handle)) 148 return; 149 150 printk(KERN_ERR "EXT4-fs: %s:%d: aborting transaction: %s in %s\n", 151 caller, line, errstr, err_fn); 152 153 jbd2_journal_abort_handle(handle); 154 } 155 156 int __ext4_journal_get_write_access(const char *where, unsigned int line, 157 handle_t *handle, struct buffer_head *bh) 158 { 159 int err = 0; 160 161 might_sleep(); 162 163 if (ext4_handle_valid(handle)) { 164 err = jbd2_journal_get_write_access(handle, bh); 165 if (err) 166 ext4_journal_abort_handle(where, line, __func__, bh, 167 handle, err); 168 } 169 return err; 170 } 171 172 /* 173 * The ext4 forget function must perform a revoke if we are freeing data 174 * which has been journaled. Metadata (eg. indirect blocks) must be 175 * revoked in all cases. 176 * 177 * "bh" may be NULL: a metadata block may have been freed from memory 178 * but there may still be a record of it in the journal, and that record 179 * still needs to be revoked. 180 * 181 * If the handle isn't valid we're not journaling, but we still need to 182 * call into ext4_journal_revoke() to put the buffer head. 183 */ 184 int __ext4_forget(const char *where, unsigned int line, handle_t *handle, 185 int is_metadata, struct inode *inode, 186 struct buffer_head *bh, ext4_fsblk_t blocknr) 187 { 188 int err; 189 190 might_sleep(); 191 192 trace_ext4_forget(inode, is_metadata, blocknr); 193 BUFFER_TRACE(bh, "enter"); 194 195 jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, " 196 "data mode %x\n", 197 bh, is_metadata, inode->i_mode, 198 test_opt(inode->i_sb, DATA_FLAGS)); 199 200 /* In the no journal case, we can just do a bforget and return */ 201 if (!ext4_handle_valid(handle)) { 202 bforget(bh); 203 return 0; 204 } 205 206 /* Never use the revoke function if we are doing full data 207 * journaling: there is no need to, and a V1 superblock won't 208 * support it. Otherwise, only skip the revoke on un-journaled 209 * data blocks. */ 210 211 if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA || 212 (!is_metadata && !ext4_should_journal_data(inode))) { 213 if (bh) { 214 BUFFER_TRACE(bh, "call jbd2_journal_forget"); 215 err = jbd2_journal_forget(handle, bh); 216 if (err) 217 ext4_journal_abort_handle(where, line, __func__, 218 bh, handle, err); 219 return err; 220 } 221 return 0; 222 } 223 224 /* 225 * data!=journal && (is_metadata || should_journal_data(inode)) 226 */ 227 BUFFER_TRACE(bh, "call jbd2_journal_revoke"); 228 err = jbd2_journal_revoke(handle, blocknr, bh); 229 if (err) { 230 ext4_journal_abort_handle(where, line, __func__, 231 bh, handle, err); 232 __ext4_abort(inode->i_sb, where, line, 233 "error %d when attempting revoke", err); 234 } 235 BUFFER_TRACE(bh, "exit"); 236 return err; 237 } 238 239 int __ext4_journal_get_create_access(const char *where, unsigned int line, 240 handle_t *handle, struct buffer_head *bh) 241 { 242 int err = 0; 243 244 if (ext4_handle_valid(handle)) { 245 err = jbd2_journal_get_create_access(handle, bh); 246 if (err) 247 ext4_journal_abort_handle(where, line, __func__, 248 bh, handle, err); 249 } 250 return err; 251 } 252 253 int __ext4_handle_dirty_metadata(const char *where, unsigned int line, 254 handle_t *handle, struct inode *inode, 255 struct buffer_head *bh) 256 { 257 int err = 0; 258 259 might_sleep(); 260 261 set_buffer_meta(bh); 262 set_buffer_prio(bh); 263 if (ext4_handle_valid(handle)) { 264 err = jbd2_journal_dirty_metadata(handle, bh); 265 /* Errors can only happen due to aborted journal or a nasty bug */ 266 if (!is_handle_aborted(handle) && WARN_ON_ONCE(err)) { 267 ext4_journal_abort_handle(where, line, __func__, bh, 268 handle, err); 269 if (inode == NULL) { 270 pr_err("EXT4: jbd2_journal_dirty_metadata " 271 "failed: handle type %u started at " 272 "line %u, credits %u/%u, errcode %d", 273 handle->h_type, 274 handle->h_line_no, 275 handle->h_requested_credits, 276 handle->h_buffer_credits, err); 277 return err; 278 } 279 ext4_error_inode(inode, where, line, 280 bh->b_blocknr, 281 "journal_dirty_metadata failed: " 282 "handle type %u started at line %u, " 283 "credits %u/%u, errcode %d", 284 handle->h_type, 285 handle->h_line_no, 286 handle->h_requested_credits, 287 handle->h_buffer_credits, err); 288 } 289 } else { 290 if (inode) 291 mark_buffer_dirty_inode(bh, inode); 292 else 293 mark_buffer_dirty(bh); 294 if (inode && inode_needs_sync(inode)) { 295 sync_dirty_buffer(bh); 296 if (buffer_req(bh) && !buffer_uptodate(bh)) { 297 struct ext4_super_block *es; 298 299 es = EXT4_SB(inode->i_sb)->s_es; 300 es->s_last_error_block = 301 cpu_to_le64(bh->b_blocknr); 302 ext4_error_inode(inode, where, line, 303 bh->b_blocknr, 304 "IO error syncing itable block"); 305 err = -EIO; 306 } 307 } 308 } 309 return err; 310 } 311 312 int __ext4_handle_dirty_super(const char *where, unsigned int line, 313 handle_t *handle, struct super_block *sb) 314 { 315 struct buffer_head *bh = EXT4_SB(sb)->s_sbh; 316 int err = 0; 317 318 ext4_superblock_csum_set(sb); 319 if (ext4_handle_valid(handle)) { 320 err = jbd2_journal_dirty_metadata(handle, bh); 321 if (err) 322 ext4_journal_abort_handle(where, line, __func__, 323 bh, handle, err); 324 } else 325 mark_buffer_dirty(bh); 326 return err; 327 } 328