ext4_jbd2.c

Go to the documentation of this file.

/*
 * 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) {
            /* Errors can only happen if there is a bug */
            handle->h_err = err;
            __ext4_journal_stop(where, line, handle);
        }
    } 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;

    ext4_superblock_csum_set(sb);
    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
        mark_buffer_dirty(bh);
    return err;
}