提交 dab291af 编写于 作者: M Mingming Cao 提交者: Linus Torvalds

[PATCH] jbd2: enable building of jbd2 and have ext4 use it rather than jbd

Reworked from a patch by Mingming Cao and Randy Dunlap
Signed-off-By: NRandy Dunlap <rdunlap@xenotime.net>
Signed-off-by: NMingming Cao <cmm@us.ibm.com>
Signed-off-by: NDave Kleikamp <shaggy@austin.ibm.com>
Signed-off-by: NAndrew Morton <akpm@osdl.org>
Signed-off-by: NLinus Torvalds <torvalds@osdl.org>
上级 a920e941
......@@ -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
......
......@@ -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/
......
......@@ -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"
......
......@@ -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 @@ void ext4_free_blocks_sb(handle_t *handle, struct super_block *sb,
* 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);
}
/**
......
......@@ -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
......
......@@ -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>
......
......@@ -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"
......
......@@ -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().
......
......@@ -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>
......
......@@ -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 @@ struct inode *ext4_new_inode(handle_t *handle, struct inode * dir, int mode)
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;
......
......@@ -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 @@ static int ext4_prepare_write(struct file *file, struct page *page,
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. */
......
......@@ -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 @@ int ext4_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
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 @@ int ext4_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
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;
}
......
......@@ -26,10 +26,10 @@
#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>
......
......@@ -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>
......
......@@ -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 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
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()
*
*/
......
......@@ -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"
......
......@@ -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>
......
......@@ -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"
......
......@@ -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"
......
......@@ -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"
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册