| /* | |
| * Interface between ext4 and JBD | |
| */ | |
| #include "ext4_jbd2.h" | |
| #include <trace/events/ext4.h> | |
| int __ext4_journal_get_write_access(const char *where, unsigned int line, | |
| handle_t *handle, struct buffer_head *bh) | |
| { | |
| int err = 0; | |
| if (ext4_handle_valid(handle)) { | |
| err = jbd2_journal_get_write_access(handle, bh); | |
| if (err) | |
| ext4_journal_abort_handle(where, line, __func__, bh, | |
| handle, err); | |
| } | |
| return err; | |
| } | |
| /* | |
| * The ext4 forget function must perform a revoke if we are freeing data | |
| * which has been journaled. Metadata (eg. indirect blocks) must be | |
| * revoked in all cases. | |
| * | |
| * "bh" may be NULL: a metadata block may have been freed from memory | |
| * but there may still be a record of it in the journal, and that record | |
| * still needs to be revoked. | |
| * | |
| * If the handle isn't valid we're not journaling, but we still need to | |
| * call into ext4_journal_revoke() to put the buffer head. | |
| */ | |
| int __ext4_forget(const char *where, unsigned int line, handle_t *handle, | |
| int is_metadata, struct inode *inode, | |
| struct buffer_head *bh, ext4_fsblk_t blocknr) | |
| { | |
| int err; | |
| might_sleep(); | |
| trace_ext4_forget(inode, is_metadata, blocknr); | |
| BUFFER_TRACE(bh, "enter"); | |
| jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, " | |
| "data mode %x\n", | |
| bh, is_metadata, inode->i_mode, | |
| test_opt(inode->i_sb, DATA_FLAGS)); | |
| /* In the no journal case, we can just do a bforget and return */ | |
| if (!ext4_handle_valid(handle)) { | |
| bforget(bh); | |
| return 0; | |
| } | |
| /* Never use the revoke function if we are doing full data | |
| * journaling: there is no need to, and a V1 superblock won't | |
| * support it. Otherwise, only skip the revoke on un-journaled | |
| * data blocks. */ | |
| if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA || | |
| (!is_metadata && !ext4_should_journal_data(inode))) { | |
| if (bh) { | |
| BUFFER_TRACE(bh, "call jbd2_journal_forget"); | |
| err = jbd2_journal_forget(handle, bh); | |
| if (err) | |
| ext4_journal_abort_handle(where, line, __func__, | |
| bh, handle, err); | |
| return err; | |
| } | |
| return 0; | |
| } | |
| /* | |
| * data!=journal && (is_metadata || should_journal_data(inode)) | |
| */ | |
| BUFFER_TRACE(bh, "call jbd2_journal_revoke"); | |
| err = jbd2_journal_revoke(handle, blocknr, bh); | |
| if (err) { | |
| ext4_journal_abort_handle(where, line, __func__, | |
| bh, handle, err); | |
| __ext4_abort(inode->i_sb, where, line, | |
| "error %d when attempting revoke", err); | |
| } | |
| BUFFER_TRACE(bh, "exit"); | |
| return err; | |
| } | |
| int __ext4_journal_get_create_access(const char *where, unsigned int line, | |
| handle_t *handle, struct buffer_head *bh) | |
| { | |
| int err = 0; | |
| if (ext4_handle_valid(handle)) { | |
| err = jbd2_journal_get_create_access(handle, bh); | |
| if (err) | |
| ext4_journal_abort_handle(where, line, __func__, | |
| bh, handle, err); | |
| } | |
| return err; | |
| } | |
| int __ext4_handle_dirty_metadata(const char *where, unsigned int line, | |
| handle_t *handle, struct inode *inode, | |
| struct buffer_head *bh) | |
| { | |
| int err = 0; | |
| if (ext4_handle_valid(handle)) { | |
| err = jbd2_journal_dirty_metadata(handle, bh); | |
| if (err) | |
| ext4_journal_abort_handle(where, line, __func__, | |
| bh, handle, err); | |
| } else { | |
| if (inode) | |
| mark_buffer_dirty_inode(bh, inode); | |
| else | |
| mark_buffer_dirty(bh); | |
| if (inode && inode_needs_sync(inode)) { | |
| sync_dirty_buffer(bh); | |
| if (buffer_req(bh) && !buffer_uptodate(bh)) { | |
| struct ext4_super_block *es; | |
| es = EXT4_SB(inode->i_sb)->s_es; | |
| es->s_last_error_block = | |
| cpu_to_le64(bh->b_blocknr); | |
| ext4_error_inode(inode, where, line, | |
| bh->b_blocknr, | |
| "IO error syncing itable block"); | |
| err = -EIO; | |
| } | |
| } | |
| } | |
| return err; | |
| } | |
| int __ext4_handle_dirty_super(const char *where, unsigned int line, | |
| handle_t *handle, struct super_block *sb) | |
| { | |
| struct buffer_head *bh = EXT4_SB(sb)->s_sbh; | |
| int err = 0; | |
| if (ext4_handle_valid(handle)) { | |
| err = jbd2_journal_dirty_metadata(handle, bh); | |
| if (err) | |
| ext4_journal_abort_handle(where, line, __func__, | |
| bh, handle, err); | |
| } else | |
| sb->s_dirt = 1; | |
| return err; | |
| } |