[PATCH] jbd2: enable building of jbd2 and have ext4 use it rather than jbd
authorMingming Cao <cmm@us.ibm.com>
Wed, 11 Oct 2006 08:21:01 +0000 (01:21 -0700)
committerLinus Torvalds <torvalds@g5.osdl.org>
Wed, 11 Oct 2006 18:14:16 +0000 (11:14 -0700)
Reworked from a patch by Mingming Cao and Randy Dunlap

Signed-off-By: Randy Dunlap <rdunlap@xenotime.net>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Dave Kleikamp <shaggy@austin.ibm.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
20 files changed:
fs/Kconfig
fs/Makefile
fs/ext4/acl.c
fs/ext4/balloc.c
fs/ext4/bitmap.c
fs/ext4/dir.c
fs/ext4/file.c
fs/ext4/fsync.c
fs/ext4/hash.c
fs/ext4/ialloc.c
fs/ext4/inode.c
fs/ext4/ioctl.c
fs/ext4/namei.c
fs/ext4/resize.c
fs/ext4/super.c
fs/ext4/symlink.c
fs/ext4/xattr.c
fs/ext4/xattr_security.c
fs/ext4/xattr_trusted.c
fs/ext4/xattr_user.c

index ac9ba1c3093534d622bd0557da649359813587d0..db4d13324c369eac7d1a77551679071aea7d07de 100644 (file)
@@ -143,24 +143,24 @@ config EXT3_FS_SECURITY
 config EXT4DEV_FS
        tristate "Ext4dev/ext4 extended fs support development (EXPERIMENTAL)"
        depends on EXPERIMENTAL
-        select JBD
-        help
+       select JBD2
+       help
          Ext4dev is a predecessor filesystem of the next generation
          extended fs ext4, based on ext3 filesystem code. It will be
          renamed ext4 fs later, once ext4dev is mature and stabilized.
 
-          Unlike the change from ext2 filesystem to ext3 filesystem,
-          the on-disk format of ext4dev is not the same as ext3 any more:
+         Unlike the change from ext2 filesystem to ext3 filesystem,
+         the on-disk format of ext4dev is not the same as ext3 any more:
          it is based on extent maps and it supports 48-bit physical block
-          numbers. These combined on-disk format changes will allow
+         numbers. These combined on-disk format changes will allow
          ext4dev/ext4 to handle more than 16 TB filesystem volumes --
          a hard limit that ext3 cannot overcome without changing the
-          on-disk format.
+         on-disk format.
 
          Other than extent maps and 48-bit block numbers, ext4dev also is
-          likely to have other new features such as persistent preallocation,
+         likely to have other new features such as persistent preallocation,
          high resolution time stamps, and larger file support etc.  These
-          features will be added to ext4dev gradually.
+         features will be added to ext4dev gradually.
 
          To compile this file system support as a module, choose M here. The
          module will be called ext4dev.  Be aware, however, that the filesystem
@@ -239,6 +239,38 @@ config JBD_DEBUG
          generated.  To turn debugging off again, do
          "echo 0 > /proc/sys/fs/jbd-debug".
 
+config JBD2
+       tristate
+       help
+         This is a generic journaling layer for block devices that support
+         both 32-bit and 64-bit block numbers.  It is currently used by
+         the ext4dev/ext4 filesystem, but it could also be used to add
+         journal support to other file systems or block devices such
+         as RAID or LVM.
+
+         If you are using ext4dev/ext4, you need to say Y here. If you are not
+         using ext4dev/ext4 then you will probably want to say N.
+
+         To compile this device as a module, choose M here. The module will be
+         called jbd2.  If you are compiling ext4dev/ext4 into the kernel,
+         you cannot compile this code as a module.
+
+config JBD2_DEBUG
+       bool "JBD2 (ext4dev/ext4) debugging support"
+       depends on JBD2
+       help
+         If you are using the ext4dev/ext4 journaled file system (or
+         potentially any other filesystem/device using JBD2), this option
+         allows you to enable debugging output while the system is running,
+         in order to help track down any problems you are having.
+         By default, the debugging output will be turned off.
+
+         If you select Y here, then you will be able to turn on debugging
+         with "echo N > /proc/sys/fs/jbd2-debug", where N is a number between
+         1 and 5. The higher the number, the more debugging output is
+         generated.  To turn debugging off again, do
+         "echo 0 > /proc/sys/fs/jbd2-debug".
+
 config FS_MBCACHE
 # Meta block cache for Extended Attributes (ext2/ext3/ext4)
        tristate
index 64396af37b2a1febd33e10cff58773d186f4c8ca..9a5ce9323bfd0c65ffed56f597294b29db75efa9 100644 (file)
@@ -64,6 +64,7 @@ obj-$(CONFIG_REISERFS_FS)     += reiserfs/
 obj-$(CONFIG_EXT3_FS)          += ext3/ # Before ext2 so root fs can be ext3
 obj-$(CONFIG_EXT4DEV_FS)       += ext4/ # Before ext2 so root fs can be ext4dev
 obj-$(CONFIG_JBD)              += jbd/
+obj-$(CONFIG_JBD2)             += jbd2/
 obj-$(CONFIG_EXT2_FS)          += ext2/
 obj-$(CONFIG_CRAMFS)           += cramfs/
 obj-$(CONFIG_RAMFS)            += ramfs/
index d143489aeb4c02537e9cd252e5a4a690b3c4acc0..0a965dd5664ef4e5b343e9227a36a4f3f1fee7f2 100644 (file)
@@ -9,7 +9,7 @@
 #include <linux/slab.h>
 #include <linux/capability.h>
 #include <linux/fs.h>
-#include <linux/ext4_jbd.h>
+#include <linux/ext4_jbd2.h>
 #include <linux/ext4_fs.h>
 #include "xattr.h"
 #include "acl.h"
index 357e4e50374a3e7ce2a87bdafc73b7a9c0773baf..e9e98449137bb04827fe1fa5c29f5b3c6b5a1985 100644 (file)
@@ -14,9 +14,9 @@
 #include <linux/time.h>
 #include <linux/capability.h>
 #include <linux/fs.h>
-#include <linux/jbd.h>
+#include <linux/jbd2.h>
 #include <linux/ext4_fs.h>
-#include <linux/ext4_jbd.h>
+#include <linux/ext4_jbd2.h>
 #include <linux/quotaops.h>
 #include <linux/buffer_head.h>
 
@@ -526,12 +526,12 @@ do_more:
                 * transaction.
                 *
                 * Ideally we would want to allow that to happen, but to
-                * do so requires making journal_forget() capable of
+                * do so requires making jbd2_journal_forget() capable of
                 * revoking the queued write of a data block, which
                 * implies blocking on the journal lock.  *forget()
                 * cannot block due to truncate races.
                 *
-                * Eventually we can fix this by making journal_forget()
+                * Eventually we can fix this by making jbd2_journal_forget()
                 * return a status indicating whether or not it was able
                 * to revoke the buffer.  On successful revoke, it is
                 * safe not to set the allocation bit in the committed
@@ -1382,7 +1382,7 @@ int ext4_should_retry_alloc(struct super_block *sb, int *retries)
 
        jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
 
-       return journal_force_commit_nested(EXT4_SB(sb)->s_journal);
+       return jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal);
 }
 
 /**
index f4b35706f39c15fe01f994a939850d972d2349f7..11e93c169bcfdf5474b2bbcb76a8fed2af61e66e 100644 (file)
@@ -8,7 +8,7 @@
  */
 
 #include <linux/buffer_head.h>
-#include <linux/jbd.h>
+#include <linux/jbd2.h>
 #include <linux/ext4_fs.h>
 
 #ifdef EXT4FS_DEBUG
index ec114d7886cc650e92da5b96389bacd10fce4b5a..9833d5d00c46c308c1432361d4d71eb3ef0f2e82 100644 (file)
@@ -22,7 +22,7 @@
  */
 
 #include <linux/fs.h>
-#include <linux/jbd.h>
+#include <linux/jbd2.h>
 #include <linux/ext4_fs.h>
 #include <linux/buffer_head.h>
 #include <linux/smp_lock.h>
index d938fbe1e08bdb42717c4de8cd8e12974c3a86a9..0b622c0624b71ad288d1b56257ca59d942f70f86 100644 (file)
@@ -20,9 +20,9 @@
 
 #include <linux/time.h>
 #include <linux/fs.h>
-#include <linux/jbd.h>
+#include <linux/jbd2.h>
 #include <linux/ext4_fs.h>
-#include <linux/ext4_jbd.h>
+#include <linux/ext4_jbd2.h>
 #include "xattr.h"
 #include "acl.h"
 
index 272faa27761d9c188bd0281439e51a458b070950..2a167d7131fa38feec17d647bbbdefbb98b6b601 100644 (file)
@@ -26,9 +26,9 @@
 #include <linux/fs.h>
 #include <linux/sched.h>
 #include <linux/writeback.h>
-#include <linux/jbd.h>
+#include <linux/jbd2.h>
 #include <linux/ext4_fs.h>
-#include <linux/ext4_jbd.h>
+#include <linux/ext4_jbd2.h>
 
 /*
  * akpm: A new design for ext4_sync_file().
index d15bb4274428baf5eea7e83225d8b10d88440e16..a67966385e0639a9323c155021ed677993136ba3 100644 (file)
@@ -10,7 +10,7 @@
  */
 
 #include <linux/fs.h>
-#include <linux/jbd.h>
+#include <linux/jbd2.h>
 #include <linux/sched.h>
 #include <linux/ext4_fs.h>
 #include <linux/cryptohash.h>
index 4b92066ca08fec76f6ace792b1efc828ec794809..34d39ae966f71102fc181cfb0800fdad29ce6709 100644 (file)
@@ -14,9 +14,9 @@
 
 #include <linux/time.h>
 #include <linux/fs.h>
-#include <linux/jbd.h>
+#include <linux/jbd2.h>
 #include <linux/ext4_fs.h>
-#include <linux/ext4_jbd.h>
+#include <linux/ext4_jbd2.h>
 #include <linux/stat.h>
 #include <linux/string.h>
 #include <linux/quotaops.h>
@@ -497,7 +497,7 @@ repeat_in_this_group:
                                goto got;
                        }
                        /* we lost it */
-                       journal_release_buffer(handle, bitmap_bh);
+                       jbd2_journal_release_buffer(handle, bitmap_bh);
 
                        if (++ino < EXT4_INODES_PER_GROUP(sb))
                                goto repeat_in_this_group;
index 7275d60dcc598307872491aeb73b6b57a2a8616f..0d96c7d3bb5b9ce9a691995b492f2ff2701ab253 100644 (file)
@@ -25,8 +25,8 @@
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/time.h>
-#include <linux/ext4_jbd.h>
-#include <linux/jbd.h>
+#include <linux/ext4_jbd2.h>
+#include <linux/jbd2.h>
 #include <linux/smp_lock.h>
 #include <linux/highuid.h>
 #include <linux/pagemap.h>
@@ -84,7 +84,7 @@ int ext4_forget(handle_t *handle, int is_metadata, struct inode *inode,
        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 journal_forget");
+                       BUFFER_TRACE(bh, "call jbd2_journal_forget");
                        return ext4_journal_forget(handle, bh);
                }
                return 0;
@@ -657,7 +657,7 @@ static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
 failed:
        /* Allocation failed, free what we already allocated */
        for (i = 1; i <= n ; i++) {
-               BUFFER_TRACE(branch[i].bh, "call journal_forget");
+               BUFFER_TRACE(branch[i].bh, "call jbd2_journal_forget");
                ext4_journal_forget(handle, branch[i].bh);
        }
        for (i = 0; i <indirect_blks; i++)
@@ -758,7 +758,7 @@ static int ext4_splice_branch(handle_t *handle, struct inode *inode,
 
 err_out:
        for (i = 1; i <= num; i++) {
-               BUFFER_TRACE(where[i].bh, "call journal_forget");
+               BUFFER_TRACE(where[i].bh, "call jbd2_journal_forget");
                ext4_journal_forget(handle, where[i].bh);
                ext4_free_blocks(handle,inode,le32_to_cpu(where[i-1].key),1);
        }
@@ -1119,7 +1119,7 @@ static int walk_page_buffers(     handle_t *handle,
  * To preserve ordering, it is essential that the hole instantiation and
  * the data write be encapsulated in a single transaction.  We cannot
  * close off a transaction and start a new one between the ext4_get_block()
- * and the commit_write().  So doing the journal_start at the start of
+ * and the commit_write().  So doing the jbd2_journal_start at the start of
  * prepare_write() is the right place.
  *
  * Also, this function can nest inside ext4_writepage() ->
@@ -1135,7 +1135,7 @@ static int walk_page_buffers(     handle_t *handle,
  * transaction open and was blocking on the quota lock - a ranking
  * violation.
  *
- * So what we do is to rely on the fact that journal_stop/journal_start
+ * So what we do is to rely on the fact that jbd2_journal_stop/journal_start
  * will _not_ run commit under these circumstances because handle->h_ref
  * is elevated.  We'll still have enough credits for the tiny quotafile
  * write.
@@ -1184,7 +1184,7 @@ out:
 
 int ext4_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
 {
-       int err = journal_dirty_data(handle, bh);
+       int err = jbd2_journal_dirty_data(handle, bh);
        if (err)
                ext4_journal_abort_handle(__FUNCTION__, __FUNCTION__,
                                                bh, handle,err);
@@ -1333,9 +1333,9 @@ static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
 
                EXT4_I(inode)->i_state &= ~EXT4_STATE_JDATA;
                journal = EXT4_JOURNAL(inode);
-               journal_lock_updates(journal);
-               err = journal_flush(journal);
-               journal_unlock_updates(journal);
+               jbd2_journal_lock_updates(journal);
+               err = jbd2_journal_flush(journal);
+               jbd2_journal_unlock_updates(journal);
 
                if (err)
                        return 0;
@@ -1356,7 +1356,7 @@ static int bput_one(handle_t *handle, struct buffer_head *bh)
        return 0;
 }
 
-static int journal_dirty_data_fn(handle_t *handle, struct buffer_head *bh)
+static int jbd2_journal_dirty_data_fn(handle_t *handle, struct buffer_head *bh)
 {
        if (buffer_mapped(bh))
                return ext4_journal_dirty_data(handle, bh);
@@ -1464,7 +1464,7 @@ static int ext4_ordered_writepage(struct page *page,
         */
        if (ret == 0) {
                err = walk_page_buffers(handle, page_bufs, 0, PAGE_CACHE_SIZE,
-                                       NULL, journal_dirty_data_fn);
+                                       NULL, jbd2_journal_dirty_data_fn);
                if (!ret)
                        ret = err;
        }
@@ -1595,7 +1595,7 @@ static void ext4_invalidatepage(struct page *page, unsigned long offset)
        if (offset == 0)
                ClearPageChecked(page);
 
-       journal_invalidatepage(journal, page, offset);
+       jbd2_journal_invalidatepage(journal, page, offset);
 }
 
 static int ext4_releasepage(struct page *page, gfp_t wait)
@@ -1605,7 +1605,7 @@ static int ext4_releasepage(struct page *page, gfp_t wait)
        WARN_ON(PageChecked(page));
        if (!page_has_buffers(page))
                return 0;
-       return journal_try_to_free_buffers(journal, page, wait);
+       return jbd2_journal_try_to_free_buffers(journal, page, wait);
 }
 
 /*
@@ -1982,11 +1982,11 @@ static void ext4_clear_blocks(handle_t *handle, struct inode *inode,
 
        /*
         * Any buffers which are on the journal will be in memory. We find
-        * them on the hash table so journal_revoke() will run journal_forget()
+        * them on the hash table so jbd2_journal_revoke() will run jbd2_journal_forget()
         * on them.  We've already detached each block from the file, so
-        * bforget() in journal_forget() should be safe.
+        * bforget() in jbd2_journal_forget() should be safe.
         *
-        * AKPM: turn on bforget in journal_forget()!!!
+        * AKPM: turn on bforget in jbd2_journal_forget()!!!
         */
        for (p = first; p < last; p++) {
                u32 nr = le32_to_cpu(*p);
@@ -2132,11 +2132,11 @@ static void ext4_free_branches(handle_t *handle, struct inode *inode,
                         * We've probably journalled the indirect block several
                         * times during the truncate.  But it's no longer
                         * needed and we now drop it from the transaction via
-                        * journal_revoke().
+                        * jbd2_journal_revoke().
                         *
                         * That's easy if it's exclusively part of this
                         * transaction.  But if it's part of the committing
-                        * transaction then journal_forget() will simply
+                        * transaction then jbd2_journal_forget() will simply
                         * brelse() it.  That means that if the underlying
                         * block is reallocated in ext4_get_block(),
                         * unmap_underlying_metadata() will find this block
@@ -2251,7 +2251,7 @@ void ext4_truncate(struct inode *inode)
 
        /*
         * We have to lock the EOF page here, because lock_page() nests
-        * outside journal_start().
+        * outside jbd2_journal_start().
         */
        if ((inode->i_size & (blocksize - 1)) == 0) {
                /* Block boundary? Nothing to do */
@@ -3035,7 +3035,7 @@ int ext4_mark_iloc_dirty(handle_t *handle,
        /* the do_update_inode consumes one bh->b_count */
        get_bh(iloc->bh);
 
-       /* ext4_do_update_inode() does journal_dirty_metadata */
+       /* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
        err = ext4_do_update_inode(handle, inode, iloc);
        put_bh(iloc->bh);
        return err;
@@ -3153,7 +3153,7 @@ static int ext4_pin_inode(handle_t *handle, struct inode *inode)
                err = ext4_get_inode_loc(inode, &iloc);
                if (!err) {
                        BUFFER_TRACE(iloc.bh, "get_write_access");
-                       err = journal_get_write_access(handle, iloc.bh);
+                       err = jbd2_journal_get_write_access(handle, iloc.bh);
                        if (!err)
                                err = ext4_journal_dirty_metadata(handle,
                                                                  iloc.bh);
@@ -3185,8 +3185,8 @@ int ext4_change_inode_journal_flag(struct inode *inode, int val)
        if (is_journal_aborted(journal) || IS_RDONLY(inode))
                return -EROFS;
 
-       journal_lock_updates(journal);
-       journal_flush(journal);
+       jbd2_journal_lock_updates(journal);
+       jbd2_journal_flush(journal);
 
        /*
         * OK, there are no updates running now, and all cached data is
@@ -3202,7 +3202,7 @@ int ext4_change_inode_journal_flag(struct inode *inode, int val)
                EXT4_I(inode)->i_flags &= ~EXT4_JOURNAL_DATA_FL;
        ext4_set_aops(inode);
 
-       journal_unlock_updates(journal);
+       jbd2_journal_unlock_updates(journal);
 
        /* Finally we can mark the inode as dirty. */
 
index a567af161b06af1d10c3840bf1da0e8989848ac4..a63dce2117b8e9d9f08d4d8e38dbed9b45eaa358 100644 (file)
@@ -8,10 +8,10 @@
  */
 
 #include <linux/fs.h>
-#include <linux/jbd.h>
+#include <linux/jbd2.h>
 #include <linux/capability.h>
 #include <linux/ext4_fs.h>
-#include <linux/ext4_jbd.h>
+#include <linux/ext4_jbd2.h>
 #include <linux/time.h>
 #include <linux/compat.h>
 #include <linux/smp_lock.h>
@@ -219,9 +219,9 @@ flags_err:
                        return -EFAULT;
 
                err = ext4_group_extend(sb, EXT4_SB(sb)->s_es, n_blocks_count);
-               journal_lock_updates(EXT4_SB(sb)->s_journal);
-               journal_flush(EXT4_SB(sb)->s_journal);
-               journal_unlock_updates(EXT4_SB(sb)->s_journal);
+               jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
+               jbd2_journal_flush(EXT4_SB(sb)->s_journal);
+               jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
 
                return err;
        }
@@ -241,9 +241,9 @@ flags_err:
                        return -EFAULT;
 
                err = ext4_group_add(sb, &input);
-               journal_lock_updates(EXT4_SB(sb)->s_journal);
-               journal_flush(EXT4_SB(sb)->s_journal);
-               journal_unlock_updates(EXT4_SB(sb)->s_journal);
+               jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
+               jbd2_journal_flush(EXT4_SB(sb)->s_journal);
+               jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
 
                return err;
        }
index 956b38113f62a6fe04ef4c38febe42df708d378e..f98b9994e36cefeec083e31cd63f741098bb64cd 100644 (file)
 
 #include <linux/fs.h>
 #include <linux/pagemap.h>
-#include <linux/jbd.h>
+#include <linux/jbd2.h>
 #include <linux/time.h>
 #include <linux/ext4_fs.h>
-#include <linux/ext4_jbd.h>
+#include <linux/ext4_jbd2.h>
 #include <linux/fcntl.h>
 #include <linux/stat.h>
 #include <linux/string.h>
index 4a47895d9d6d71defb09e84e10e6dd67da910e4c..5b2828d211805e5e51505e786f097a239c5b8e9d 100644 (file)
@@ -13,7 +13,7 @@
 
 #include <linux/sched.h>
 #include <linux/smp_lock.h>
-#include <linux/ext4_jbd.h>
+#include <linux/ext4_jbd2.h>
 
 #include <linux/errno.h>
 #include <linux/slab.h>
index 9e32a2a8d286f5e52419ba0186a7bb896f0472f3..f131bb69b62e3be26abf0601fe2b5427305bcebe 100644 (file)
@@ -20,9 +20,9 @@
 #include <linux/string.h>
 #include <linux/fs.h>
 #include <linux/time.h>
-#include <linux/jbd.h>
+#include <linux/jbd2.h>
 #include <linux/ext4_fs.h>
-#include <linux/ext4_jbd.h>
+#include <linux/ext4_jbd2.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/blkdev.h>
@@ -63,7 +63,7 @@ static void ext4_write_super (struct super_block * sb);
 static void ext4_write_super_lockfs(struct super_block *sb);
 
 /*
- * Wrappers for journal_start/end.
+ * Wrappers for jbd2_journal_start/end.
  *
  * The only special thing we need to do here is to make sure that all
  * journal_end calls result in the superblock being marked dirty, so
@@ -87,12 +87,12 @@ handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks)
                return ERR_PTR(-EROFS);
        }
 
-       return journal_start(journal, nblocks);
+       return jbd2_journal_start(journal, nblocks);
 }
 
 /*
  * The only special thing we need to do here is to make sure that all
- * journal_stop calls result in the superblock being marked dirty, so
+ * jbd2_journal_stop calls result in the superblock being marked dirty, so
  * that sync() will call the filesystem's write_super callback if
  * appropriate.
  */
@@ -104,7 +104,7 @@ int __ext4_journal_stop(const char *where, handle_t *handle)
 
        sb = handle->h_transaction->t_journal->j_private;
        err = handle->h_err;
-       rc = journal_stop(handle);
+       rc = jbd2_journal_stop(handle);
 
        if (!err)
                err = rc;
@@ -131,7 +131,7 @@ void ext4_journal_abort_handle(const char *caller, const char *err_fn,
        printk(KERN_ERR "%s: aborting transaction: %s in %s\n",
               caller, errstr, err_fn);
 
-       journal_abort_handle(handle);
+       jbd2_journal_abort_handle(handle);
 }
 
 /* Deal with the reporting of failure conditions on a filesystem such as
@@ -144,7 +144,7 @@ void ext4_journal_abort_handle(const char *caller, const char *err_fn,
  * be aborted, we can't rely on the current, or future, transactions to
  * write out the superblock safely.
  *
- * We'll just use the journal_abort() error code to record an error in
+ * We'll just use the jbd2_journal_abort() error code to record an error in
  * the journal instead.  On recovery, the journal will compain about
  * that error until we've noted it down and cleared it.
  */
@@ -164,7 +164,7 @@ static void ext4_handle_error(struct super_block *sb)
 
                EXT4_SB(sb)->s_mount_opt |= EXT4_MOUNT_ABORT;
                if (journal)
-                       journal_abort(journal, -EIO);
+                       jbd2_journal_abort(journal, -EIO);
        }
        if (test_opt (sb, ERRORS_RO)) {
                printk (KERN_CRIT "Remounting filesystem read-only\n");
@@ -203,7 +203,7 @@ static const char *ext4_decode_error(struct super_block * sb, int errno,
                errstr = "Out of memory";
                break;
        case -EROFS:
-               if (!sb || EXT4_SB(sb)->s_journal->j_flags & JFS_ABORT)
+               if (!sb || EXT4_SB(sb)->s_journal->j_flags & JBD2_ABORT)
                        errstr = "Journal has aborted";
                else
                        errstr = "Readonly filesystem";
@@ -279,7 +279,7 @@ void ext4_abort (struct super_block * sb, const char * function,
        EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
        sb->s_flags |= MS_RDONLY;
        EXT4_SB(sb)->s_mount_opt |= EXT4_MOUNT_ABORT;
-       journal_abort(EXT4_SB(sb)->s_journal, -EIO);
+       jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
 }
 
 void ext4_warning (struct super_block * sb, const char * function,
@@ -391,7 +391,7 @@ static void ext4_put_super (struct super_block * sb)
        int i;
 
        ext4_xattr_put_super(sb);
-       journal_destroy(sbi->s_journal);
+       jbd2_journal_destroy(sbi->s_journal);
        if (!(sb->s_flags & MS_RDONLY)) {
                EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
                es->s_state = cpu_to_le16(sbi->s_mount_state);
@@ -1722,8 +1722,8 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
                /* No mode set, assume a default based on the journal
                    capabilities: ORDERED_DATA if the journal can
                    cope, else JOURNAL_DATA */
-               if (journal_check_available_features
-                   (sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE))
+               if (jbd2_journal_check_available_features
+                   (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE))
                        set_opt(sbi->s_mount_opt, ORDERED_DATA);
                else
                        set_opt(sbi->s_mount_opt, JOURNAL_DATA);
@@ -1731,8 +1731,8 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
 
        case EXT4_MOUNT_ORDERED_DATA:
        case EXT4_MOUNT_WRITEBACK_DATA:
-               if (!journal_check_available_features
-                   (sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE)) {
+               if (!jbd2_journal_check_available_features
+                   (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
                        printk(KERN_ERR "EXT4-fs: Journal does not support "
                               "requested data journaling mode\n");
                        goto failed_mount4;
@@ -1749,7 +1749,7 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
                }
        }
        /*
-        * The journal_load will have done any necessary log recovery,
+        * The jbd2_journal_load will have done any necessary log recovery,
         * so we can safely mount the rest of the filesystem now.
         */
 
@@ -1797,7 +1797,7 @@ cantfind_ext4:
        goto failed_mount;
 
 failed_mount4:
-       journal_destroy(sbi->s_journal);
+       jbd2_journal_destroy(sbi->s_journal);
 failed_mount3:
        percpu_counter_destroy(&sbi->s_freeblocks_counter);
        percpu_counter_destroy(&sbi->s_freeinodes_counter);
@@ -1837,9 +1837,9 @@ static void ext4_init_journal_params(struct super_block *sb, journal_t *journal)
 
        spin_lock(&journal->j_state_lock);
        if (test_opt(sb, BARRIER))
-               journal->j_flags |= JFS_BARRIER;
+               journal->j_flags |= JBD2_BARRIER;
        else
-               journal->j_flags &= ~JFS_BARRIER;
+               journal->j_flags &= ~JBD2_BARRIER;
        spin_unlock(&journal->j_state_lock);
 }
 
@@ -1873,7 +1873,7 @@ static journal_t *ext4_get_journal(struct super_block *sb,
                return NULL;
        }
 
-       journal = journal_init_inode(journal_inode);
+       journal = jbd2_journal_init_inode(journal_inode);
        if (!journal) {
                printk(KERN_ERR "EXT4-fs: Could not load journal inode\n");
                iput(journal_inode);
@@ -1945,7 +1945,7 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,
        start = sb_block + 1;
        brelse(bh);     /* we're done with the superblock */
 
-       journal = journal_init_dev(bdev, sb->s_bdev,
+       journal = jbd2_journal_init_dev(bdev, sb->s_bdev,
                                        start, len, blocksize);
        if (!journal) {
                printk(KERN_ERR "EXT4-fs: failed to create device journal\n");
@@ -1968,7 +1968,7 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,
        ext4_init_journal_params(sb, journal);
        return journal;
 out_journal:
-       journal_destroy(journal);
+       jbd2_journal_destroy(journal);
 out_bdev:
        ext4_blkdev_put(bdev);
        return NULL;
@@ -2029,22 +2029,22 @@ static int ext4_load_journal(struct super_block *sb,
        }
 
        if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) {
-               err = journal_update_format(journal);
+               err = jbd2_journal_update_format(journal);
                if (err)  {
                        printk(KERN_ERR "EXT4-fs: error updating journal.\n");
-                       journal_destroy(journal);
+                       jbd2_journal_destroy(journal);
                        return err;
                }
        }
 
        if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER))
-               err = journal_wipe(journal, !really_read_only);
+               err = jbd2_journal_wipe(journal, !really_read_only);
        if (!err)
-               err = journal_load(journal);
+               err = jbd2_journal_load(journal);
 
        if (err) {
                printk(KERN_ERR "EXT4-fs: error loading journal.\n");
-               journal_destroy(journal);
+               jbd2_journal_destroy(journal);
                return err;
        }
 
@@ -2081,9 +2081,9 @@ static int ext4_create_journal(struct super_block * sb,
        printk(KERN_INFO "EXT4-fs: creating new journal on inode %u\n",
               journal_inum);
 
-       if (journal_create(journal)) {
+       if (jbd2_journal_create(journal)) {
                printk(KERN_ERR "EXT4-fs: error creating journal.\n");
-               journal_destroy(journal);
+               jbd2_journal_destroy(journal);
                return -EIO;
        }
 
@@ -2130,15 +2130,15 @@ static void ext4_mark_recovery_complete(struct super_block * sb,
 {
        journal_t *journal = EXT4_SB(sb)->s_journal;
 
-       journal_lock_updates(journal);
-       journal_flush(journal);
+       jbd2_journal_lock_updates(journal);
+       jbd2_journal_flush(journal);
        if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER) &&
            sb->s_flags & MS_RDONLY) {
                EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
                sb->s_dirt = 0;
                ext4_commit_super(sb, es, 1);
        }
-       journal_unlock_updates(journal);
+       jbd2_journal_unlock_updates(journal);
 }
 
 /*
@@ -2160,7 +2160,7 @@ static void ext4_clear_journal_err(struct super_block * sb,
         * journal by a prior ext4_error() or ext4_abort()
         */
 
-       j_errno = journal_errno(journal);
+       j_errno = jbd2_journal_errno(journal);
        if (j_errno) {
                char nbuf[16];
 
@@ -2174,7 +2174,7 @@ static void ext4_clear_journal_err(struct super_block * sb,
                es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
                ext4_commit_super (sb, es, 1);
 
-               journal_clear_err(journal);
+               jbd2_journal_clear_err(journal);
        }
 }
 
@@ -2217,9 +2217,9 @@ static int ext4_sync_fs(struct super_block *sb, int wait)
        tid_t target;
 
        sb->s_dirt = 0;
-       if (journal_start_commit(EXT4_SB(sb)->s_journal, &target)) {
+       if (jbd2_journal_start_commit(EXT4_SB(sb)->s_journal, &target)) {
                if (wait)
-                       log_wait_commit(EXT4_SB(sb)->s_journal, target);
+                       jbd2_log_wait_commit(EXT4_SB(sb)->s_journal, target);
        }
        return 0;
 }
@@ -2236,8 +2236,8 @@ static void ext4_write_super_lockfs(struct super_block *sb)
                journal_t *journal = EXT4_SB(sb)->s_journal;
 
                /* Now we set up the journal barrier. */
-               journal_lock_updates(journal);
-               journal_flush(journal);
+               jbd2_journal_lock_updates(journal);
+               jbd2_journal_flush(journal);
 
                /* Journal blocked and flushed, clear needs_recovery flag. */
                EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
@@ -2257,7 +2257,7 @@ static void ext4_unlockfs(struct super_block *sb)
                EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
                ext4_commit_super(sb, EXT4_SB(sb)->s_es, 1);
                unlock_super(sb);
-               journal_unlock_updates(EXT4_SB(sb)->s_journal);
+               jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
        }
 }
 
@@ -2438,9 +2438,9 @@ static int ext4_statfs (struct dentry * dentry, struct kstatfs * buf)
  * is locked for write. Otherwise the are possible deadlocks:
  * Process 1                         Process 2
  * ext4_create()                     quota_sync()
- *   journal_start()                   write_dquot()
+ *   jbd2_journal_start()                   write_dquot()
  *   DQUOT_INIT()                        down(dqio_mutex)
- *     down(dqio_mutex)                    journal_start()
+ *     down(dqio_mutex)                    jbd2_journal_start()
  *
  */
 
index 9e4c75f912f7640831d19043aa928065cd9d22b6..fcf527286d7517999fede004d2e321b1356f0c3a 100644 (file)
@@ -18,7 +18,7 @@
  */
 
 #include <linux/fs.h>
-#include <linux/jbd.h>
+#include <linux/jbd2.h>
 #include <linux/ext4_fs.h>
 #include <linux/namei.h>
 #include "xattr.h"
index d3a40815410128650b0f2aab847621b48fb4fa9f..90f7d5c0bae419f7a3be81f8dc2a4748a67311e0 100644 (file)
@@ -53,7 +53,7 @@
 #include <linux/init.h>
 #include <linux/fs.h>
 #include <linux/slab.h>
-#include <linux/ext4_jbd.h>
+#include <linux/ext4_jbd2.h>
 #include <linux/ext4_fs.h>
 #include <linux/mbcache.h>
 #include <linux/quotaops.h>
index d84b1dabeb16815e48b520c97b22acdbbedc72f0..b6a6861951f9d8e5be9a0c60b1ef72a30b74ef4b 100644 (file)
@@ -7,7 +7,7 @@
 #include <linux/string.h>
 #include <linux/fs.h>
 #include <linux/smp_lock.h>
-#include <linux/ext4_jbd.h>
+#include <linux/ext4_jbd2.h>
 #include <linux/ext4_fs.h>
 #include <linux/security.h>
 #include "xattr.h"
index 11bd58c95a61b9b22f0734ea56e2e5f98f119ed1..b76f2dbc82daf64f80b2457e76addcad71c1621f 100644 (file)
@@ -10,7 +10,7 @@
 #include <linux/capability.h>
 #include <linux/fs.h>
 #include <linux/smp_lock.h>
-#include <linux/ext4_jbd.h>
+#include <linux/ext4_jbd2.h>
 #include <linux/ext4_fs.h>
 #include "xattr.h"
 
index 9c5a665e0837c0fcc2ec5551aea8b7481b0271d0..c53cded0761ac3f01284affae0c29eed7270ad11 100644 (file)
@@ -9,7 +9,7 @@
 #include <linux/string.h>
 #include <linux/fs.h>
 #include <linux/smp_lock.h>
-#include <linux/ext4_jbd.h>
+#include <linux/ext4_jbd2.h>
 #include <linux/ext4_fs.h>
 #include "xattr.h"