AcoSail/kernel_optimize_test
8
0
Fork 0
forked from luck/tmp_suning_uos_patched
Code Pull Requests Activity

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

Browse Source 
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>
This commit is contained in:
Mingming Cao 2006-10-11 01:21:01 -07:00 committed by Linus Torvalds
parent a920e9416b
commit dab291af8d
20 changed files with 141 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
fs/Kconfig
View File

@ -143,24 +143,24 @@ config EXT3_FS_SECURITY
config EXT4DEV_FS config EXT4DEV_FS
tristate "Ext4dev/ext4 extended fs support development (EXPERIMENTAL)" tristate "Ext4dev/ext4 extended fs support development (EXPERIMENTAL)"
depends on EXPERIMENTAL depends on EXPERIMENTAL
select JBD select JBD2
help help
Ext4dev is a predecessor filesystem of the next generation Ext4dev is a predecessor filesystem of the next generation
extended fs ext4, based on ext3 filesystem code. It will be extended fs ext4, based on ext3 filesystem code. It will be
renamed ext4 fs later, once ext4dev is mature and stabilized. renamed ext4 fs later, once ext4dev is mature and stabilized.
Unlike the change from ext2 filesystem to ext3 filesystem, Unlike the change from ext2 filesystem to ext3 filesystem,
the on-disk format of ext4dev is not the same as ext3 any more: 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 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 -- ext4dev/ext4 to handle more than 16 TB filesystem volumes --
a hard limit that ext3 cannot overcome without changing the 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 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 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 To compile this file system support as a module, choose M here. The
module will be called ext4dev. Be aware, however, that the filesystem 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 generated. To turn debugging off again, do
"echo 0 > /proc/sys/fs/jbd-debug". "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 config FS_MBCACHE
# Meta block cache for Extended Attributes (ext2/ext3/ext4) # Meta block cache for Extended Attributes (ext2/ext3/ext4)
tristate tristate

1
fs/Makefile
View 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_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_EXT4DEV_FS) += ext4/ # Before ext2 so root fs can be ext4dev
obj-$(CONFIG_JBD) += jbd/ obj-$(CONFIG_JBD) += jbd/
obj-$(CONFIG_JBD2) += jbd2/
obj-$(CONFIG_EXT2_FS) += ext2/ obj-$(CONFIG_EXT2_FS) += ext2/
obj-$(CONFIG_CRAMFS) += cramfs/ obj-$(CONFIG_CRAMFS) += cramfs/
obj-$(CONFIG_RAMFS) += ramfs/ obj-$(CONFIG_RAMFS) += ramfs/

2
fs/ext4/acl.c
View File

@ -9,7 +9,7 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/capability.h> #include <linux/capability.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/ext4_jbd.h> #include <linux/ext4_jbd2.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#include "xattr.h" #include "xattr.h"
#include "acl.h" #include "acl.h"

10
fs/ext4/balloc.c
View File

@ -14,9 +14,9 @@
#include <linux/time.h> #include <linux/time.h>
#include <linux/capability.h> #include <linux/capability.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/jbd.h> #include <linux/jbd2.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#include <linux/ext4_jbd.h> #include <linux/ext4_jbd2.h>
#include <linux/quotaops.h> #include <linux/quotaops.h>
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
@ -526,12 +526,12 @@ void ext4_free_blocks_sb(handle_t *handle, struct super_block *sb,
* transaction. * transaction.
* *
* Ideally we would want to allow that to happen, but to * 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 * revoking the queued write of a data block, which
* implies blocking on the journal lock. *forget() * implies blocking on the journal lock. *forget()
* cannot block due to truncate races. * 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 * return a status indicating whether or not it was able
* to revoke the buffer. On successful revoke, it is * to revoke the buffer. On successful revoke, it is
* safe not to set the allocation bit in the committed * 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); 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);
} }
/** /**

2
fs/ext4/bitmap.c
View File

@ -8,7 +8,7 @@
*/ */
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
#include <linux/jbd.h> #include <linux/jbd2.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#ifdef EXT4FS_DEBUG #ifdef EXT4FS_DEBUG

2
fs/ext4/dir.c
View File

@ -22,7 +22,7 @@
*/ */
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/jbd.h> #include <linux/jbd2.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>

4
fs/ext4/file.c
View File

@ -20,9 +20,9 @@
#include <linux/time.h> #include <linux/time.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/jbd.h> #include <linux/jbd2.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#include <linux/ext4_jbd.h> #include <linux/ext4_jbd2.h>
#include "xattr.h" #include "xattr.h"
#include "acl.h" #include "acl.h"

4
fs/ext4/fsync.c
View File

@ -26,9 +26,9 @@
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/writeback.h> #include <linux/writeback.h>
#include <linux/jbd.h> #include <linux/jbd2.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#include <linux/ext4_jbd.h> #include <linux/ext4_jbd2.h>
/* /*
* akpm: A new design for ext4_sync_file(). * akpm: A new design for ext4_sync_file().

2
fs/ext4/hash.c
View File

@ -10,7 +10,7 @@
*/ */
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/jbd.h> #include <linux/jbd2.h>
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#include <linux/cryptohash.h> #include <linux/cryptohash.h>

6
fs/ext4/ialloc.c
View File

@ -14,9 +14,9 @@
#include <linux/time.h> #include <linux/time.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/jbd.h> #include <linux/jbd2.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#include <linux/ext4_jbd.h> #include <linux/ext4_jbd2.h>
#include <linux/stat.h> #include <linux/stat.h>
#include <linux/string.h> #include <linux/string.h>
#include <linux/quotaops.h> #include <linux/quotaops.h>
@ -497,7 +497,7 @@ struct inode *ext4_new_inode(handle_t *handle, struct inode * dir, int mode)
goto got; goto got;
} }
/* we lost it */ /* we lost it */
journal_release_buffer(handle, bitmap_bh); jbd2_journal_release_buffer(handle, bitmap_bh);
if (++ino < EXT4_INODES_PER_GROUP(sb)) if (++ino < EXT4_INODES_PER_GROUP(sb))
goto repeat_in_this_group; goto repeat_in_this_group;

52
fs/ext4/inode.c
View File

@ -25,8 +25,8 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/time.h> #include <linux/time.h>
#include <linux/ext4_jbd.h> #include <linux/ext4_jbd2.h>
#include <linux/jbd.h> #include <linux/jbd2.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
#include <linux/highuid.h> #include <linux/highuid.h>
#include <linux/pagemap.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 || if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA ||
(!is_metadata && !ext4_should_journal_data(inode))) { (!is_metadata && !ext4_should_journal_data(inode))) {
if (bh) { if (bh) {
BUFFER_TRACE(bh, "call journal_forget"); BUFFER_TRACE(bh, "call jbd2_journal_forget");
return ext4_journal_forget(handle, bh); return ext4_journal_forget(handle, bh);
} }
return 0; return 0;
@ -657,7 +657,7 @@ static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
failed: failed:
/* Allocation failed, free what we already allocated */ /* Allocation failed, free what we already allocated */
for (i = 1; i <= n ; i++) { 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); ext4_journal_forget(handle, branch[i].bh);
} }
for (i = 0; i <indirect_blks; i++) for (i = 0; i <indirect_blks; i++)
@ -758,7 +758,7 @@ static int ext4_splice_branch(handle_t *handle, struct inode *inode,
err_out: err_out:
for (i = 1; i <= num; i++) { 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_journal_forget(handle, where[i].bh);
ext4_free_blocks(handle,inode,le32_to_cpu(where[i-1].key),1); 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 * To preserve ordering, it is essential that the hole instantiation and
* the data write be encapsulated in a single transaction. We cannot * 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() * 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. * prepare_write() is the right place.
* *
* Also, this function can nest inside ext4_writepage() -> * 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 * transaction open and was blocking on the quota lock - a ranking
* violation. * 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 * will _not_ run commit under these circumstances because handle->h_ref
* is elevated. We'll still have enough credits for the tiny quotafile * is elevated. We'll still have enough credits for the tiny quotafile
* write. * 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 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) if (err)
ext4_journal_abort_handle(__FUNCTION__, __FUNCTION__, ext4_journal_abort_handle(__FUNCTION__, __FUNCTION__,
bh, handle,err); 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; EXT4_I(inode)->i_state &= ~EXT4_STATE_JDATA;
journal = EXT4_JOURNAL(inode); journal = EXT4_JOURNAL(inode);
journal_lock_updates(journal); jbd2_journal_lock_updates(journal);
err = journal_flush(journal); err = jbd2_journal_flush(journal);
journal_unlock_updates(journal); jbd2_journal_unlock_updates(journal);
if (err) if (err)
return 0; return 0;
@ -1356,7 +1356,7 @@ static int bput_one(handle_t *handle, struct buffer_head *bh)
return 0; 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)) if (buffer_mapped(bh))
return ext4_journal_dirty_data(handle, bh); return ext4_journal_dirty_data(handle, bh);
@ -1464,7 +1464,7 @@ static int ext4_ordered_writepage(struct page *page,
*/ */
if (ret == 0) { if (ret == 0) {
err = walk_page_buffers(handle, page_bufs, 0, PAGE_CACHE_SIZE, err = walk_page_buffers(handle, page_bufs, 0, PAGE_CACHE_SIZE,
NULL, journal_dirty_data_fn); NULL, jbd2_journal_dirty_data_fn);
if (!ret) if (!ret)
ret = err; ret = err;
} }
@ -1595,7 +1595,7 @@ static void ext4_invalidatepage(struct page *page, unsigned long offset)
if (offset == 0) if (offset == 0)
ClearPageChecked(page); ClearPageChecked(page);
journal_invalidatepage(journal, page, offset); jbd2_journal_invalidatepage(journal, page, offset);
} }
static int ext4_releasepage(struct page *page, gfp_t wait) 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)); WARN_ON(PageChecked(page));
if (!page_has_buffers(page)) if (!page_has_buffers(page))
return 0; 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 * 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 * 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++) { for (p = first; p < last; p++) {
u32 nr = le32_to_cpu(*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 * We've probably journalled the indirect block several
* times during the truncate. But it's no longer * times during the truncate. But it's no longer
* needed and we now drop it from the transaction via * 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 * That's easy if it's exclusively part of this
* transaction. But if it's part of the committing * 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 * brelse() it. That means that if the underlying
* block is reallocated in ext4_get_block(), * block is reallocated in ext4_get_block(),
* unmap_underlying_metadata() will find this 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 * 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) { if ((inode->i_size & (blocksize - 1)) == 0) {
/* Block boundary? Nothing to do */ /* 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 */ /* the do_update_inode consumes one bh->b_count */
get_bh(iloc->bh); 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); err = ext4_do_update_inode(handle, inode, iloc);
put_bh(iloc->bh); put_bh(iloc->bh);
return err; return err;
@ -3153,7 +3153,7 @@ static int ext4_pin_inode(handle_t *handle, struct inode *inode)
err = ext4_get_inode_loc(inode, &iloc); err = ext4_get_inode_loc(inode, &iloc);
if (!err) { if (!err) {
BUFFER_TRACE(iloc.bh, "get_write_access"); 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) if (!err)
err = ext4_journal_dirty_metadata(handle, err = ext4_journal_dirty_metadata(handle,
iloc.bh); 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)) if (is_journal_aborted(journal) || IS_RDONLY(inode))
return -EROFS; return -EROFS;
journal_lock_updates(journal); jbd2_journal_lock_updates(journal);
journal_flush(journal); jbd2_journal_flush(journal);
/* /*
* OK, there are no updates running now, and all cached data is * 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_I(inode)->i_flags &= ~EXT4_JOURNAL_DATA_FL;
ext4_set_aops(inode); ext4_set_aops(inode);
journal_unlock_updates(journal); jbd2_journal_unlock_updates(journal);
/* Finally we can mark the inode as dirty. */ /* Finally we can mark the inode as dirty. */

16
fs/ext4/ioctl.c
View File

@ -8,10 +8,10 @@
*/ */
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/jbd.h> #include <linux/jbd2.h>
#include <linux/capability.h> #include <linux/capability.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#include <linux/ext4_jbd.h> #include <linux/ext4_jbd2.h>
#include <linux/time.h> #include <linux/time.h>
#include <linux/compat.h> #include <linux/compat.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
@ -219,9 +219,9 @@ int ext4_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
return -EFAULT; return -EFAULT;
err = ext4_group_extend(sb, EXT4_SB(sb)->s_es, n_blocks_count); err = ext4_group_extend(sb, EXT4_SB(sb)->s_es, n_blocks_count);
journal_lock_updates(EXT4_SB(sb)->s_journal); jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
journal_flush(EXT4_SB(sb)->s_journal); jbd2_journal_flush(EXT4_SB(sb)->s_journal);
journal_unlock_updates(EXT4_SB(sb)->s_journal); jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
return err; return err;
} }
@ -241,9 +241,9 @@ int ext4_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
return -EFAULT; return -EFAULT;
err = ext4_group_add(sb, &input); err = ext4_group_add(sb, &input);
journal_lock_updates(EXT4_SB(sb)->s_journal); jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
journal_flush(EXT4_SB(sb)->s_journal); jbd2_journal_flush(EXT4_SB(sb)->s_journal);
journal_unlock_updates(EXT4_SB(sb)->s_journal); jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
return err; return err;
} }

4
fs/ext4/namei.c
View File

@ -26,10 +26,10 @@
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/pagemap.h> #include <linux/pagemap.h>
#include <linux/jbd.h> #include <linux/jbd2.h>
#include <linux/time.h> #include <linux/time.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#include <linux/ext4_jbd.h> #include <linux/ext4_jbd2.h>
#include <linux/fcntl.h> #include <linux/fcntl.h>
#include <linux/stat.h> #include <linux/stat.h>
#include <linux/string.h> #include <linux/string.h>

2
fs/ext4/resize.c
View File

@ -13,7 +13,7 @@
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
#include <linux/ext4_jbd.h> #include <linux/ext4_jbd2.h>
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/slab.h> #include <linux/slab.h>

84
fs/ext4/super.c
View File

@ -20,9 +20,9 @@
#include <linux/string.h> #include <linux/string.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/time.h> #include <linux/time.h>
#include <linux/jbd.h> #include <linux/jbd2.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#include <linux/ext4_jbd.h> #include <linux/ext4_jbd2.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/blkdev.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); 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 * 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 * 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 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 * 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 * that sync() will call the filesystem's write_super callback if
* appropriate. * appropriate.
*/ */
@ -104,7 +104,7 @@ int __ext4_journal_stop(const char *where, handle_t *handle)
sb = handle->h_transaction->t_journal->j_private; sb = handle->h_transaction->t_journal->j_private;
err = handle->h_err; err = handle->h_err;
rc = journal_stop(handle); rc = jbd2_journal_stop(handle);
if (!err) if (!err)
err = rc; 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", printk(KERN_ERR "%s: aborting transaction: %s in %s\n",
caller, errstr, err_fn); 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 /* 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 * be aborted, we can't rely on the current, or future, transactions to
* write out the superblock safely. * 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 * the journal instead. On recovery, the journal will compain about
* that error until we've noted it down and cleared it. * 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; EXT4_SB(sb)->s_mount_opt |= EXT4_MOUNT_ABORT;
if (journal) if (journal)
journal_abort(journal, -EIO); jbd2_journal_abort(journal, -EIO);
} }
if (test_opt (sb, ERRORS_RO)) { if (test_opt (sb, ERRORS_RO)) {
printk (KERN_CRIT "Remounting filesystem read-only\n"); 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"; errstr = "Out of memory";
break; break;
case -EROFS: 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"; errstr = "Journal has aborted";
else else
errstr = "Readonly filesystem"; 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; EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
sb->s_flags |= MS_RDONLY; sb->s_flags |= MS_RDONLY;
EXT4_SB(sb)->s_mount_opt |= EXT4_MOUNT_ABORT; 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, 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; int i;
ext4_xattr_put_super(sb); ext4_xattr_put_super(sb);
journal_destroy(sbi->s_journal); jbd2_journal_destroy(sbi->s_journal);
if (!(sb->s_flags & MS_RDONLY)) { if (!(sb->s_flags & MS_RDONLY)) {
EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER); EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
es->s_state = cpu_to_le16(sbi->s_mount_state); 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 /* No mode set, assume a default based on the journal
capabilities: ORDERED_DATA if the journal can capabilities: ORDERED_DATA if the journal can
cope, else JOURNAL_DATA */ cope, else JOURNAL_DATA */
if (journal_check_available_features if (jbd2_journal_check_available_features
(sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE)) (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE))
set_opt(sbi->s_mount_opt, ORDERED_DATA); set_opt(sbi->s_mount_opt, ORDERED_DATA);
else else
set_opt(sbi->s_mount_opt, JOURNAL_DATA); 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_ORDERED_DATA:
case EXT4_MOUNT_WRITEBACK_DATA: case EXT4_MOUNT_WRITEBACK_DATA:
if (!journal_check_available_features if (!jbd2_journal_check_available_features
(sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE)) { (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
printk(KERN_ERR "EXT4-fs: Journal does not support " printk(KERN_ERR "EXT4-fs: Journal does not support "
"requested data journaling mode\n"); "requested data journaling mode\n");
goto failed_mount4; 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. * 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; goto failed_mount;
failed_mount4: failed_mount4:
journal_destroy(sbi->s_journal); jbd2_journal_destroy(sbi->s_journal);
failed_mount3: failed_mount3:
percpu_counter_destroy(&sbi->s_freeblocks_counter); percpu_counter_destroy(&sbi->s_freeblocks_counter);
percpu_counter_destroy(&sbi->s_freeinodes_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); spin_lock(&journal->j_state_lock);
if (test_opt(sb, BARRIER)) if (test_opt(sb, BARRIER))
journal->j_flags |= JFS_BARRIER; journal->j_flags |= JBD2_BARRIER;
else else
journal->j_flags &= ~JFS_BARRIER; journal->j_flags &= ~JBD2_BARRIER;
spin_unlock(&journal->j_state_lock); spin_unlock(&journal->j_state_lock);
} }
@ -1873,7 +1873,7 @@ static journal_t *ext4_get_journal(struct super_block *sb,
return NULL; return NULL;
} }
journal = journal_init_inode(journal_inode); journal = jbd2_journal_init_inode(journal_inode);
if (!journal) { if (!journal) {
printk(KERN_ERR "EXT4-fs: Could not load journal inode\n"); printk(KERN_ERR "EXT4-fs: Could not load journal inode\n");
iput(journal_inode); iput(journal_inode);
@ -1945,7 +1945,7 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,
start = sb_block + 1; start = sb_block + 1;
brelse(bh); /* we're done with the superblock */ 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); start, len, blocksize);
if (!journal) { if (!journal) {
printk(KERN_ERR "EXT4-fs: failed to create device journal\n"); 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); ext4_init_journal_params(sb, journal);
return journal; return journal;
out_journal: out_journal:
journal_destroy(journal); jbd2_journal_destroy(journal);
out_bdev: out_bdev:
ext4_blkdev_put(bdev); ext4_blkdev_put(bdev);
return NULL; return NULL;
@ -2029,22 +2029,22 @@ static int ext4_load_journal(struct super_block *sb,
} }
if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) { if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) {
err = journal_update_format(journal); err = jbd2_journal_update_format(journal);
if (err) { if (err) {
printk(KERN_ERR "EXT4-fs: error updating journal.\n"); printk(KERN_ERR "EXT4-fs: error updating journal.\n");
journal_destroy(journal); jbd2_journal_destroy(journal);
return err; return err;
} }
} }
if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) 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) if (!err)
err = journal_load(journal); err = jbd2_journal_load(journal);
if (err) { if (err) {
printk(KERN_ERR "EXT4-fs: error loading journal.\n"); printk(KERN_ERR "EXT4-fs: error loading journal.\n");
journal_destroy(journal); jbd2_journal_destroy(journal);
return err; 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", printk(KERN_INFO "EXT4-fs: creating new journal on inode %u\n",
journal_inum); journal_inum);
if (journal_create(journal)) { if (jbd2_journal_create(journal)) {
printk(KERN_ERR "EXT4-fs: error creating journal.\n"); printk(KERN_ERR "EXT4-fs: error creating journal.\n");
journal_destroy(journal); jbd2_journal_destroy(journal);
return -EIO; 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_t *journal = EXT4_SB(sb)->s_journal;
journal_lock_updates(journal); jbd2_journal_lock_updates(journal);
journal_flush(journal); jbd2_journal_flush(journal);
if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER) && if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER) &&
sb->s_flags & MS_RDONLY) { sb->s_flags & MS_RDONLY) {
EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER); EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
sb->s_dirt = 0; sb->s_dirt = 0;
ext4_commit_super(sb, es, 1); 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() * journal by a prior ext4_error() or ext4_abort()
*/ */
j_errno = journal_errno(journal); j_errno = jbd2_journal_errno(journal);
if (j_errno) { if (j_errno) {
char nbuf[16]; 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); es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
ext4_commit_super (sb, es, 1); 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; tid_t target;
sb->s_dirt = 0; 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) if (wait)
log_wait_commit(EXT4_SB(sb)->s_journal, target); jbd2_log_wait_commit(EXT4_SB(sb)->s_journal, target);
} }
return 0; return 0;
} }
@ -2236,8 +2236,8 @@ static void ext4_write_super_lockfs(struct super_block *sb)
journal_t *journal = EXT4_SB(sb)->s_journal; journal_t *journal = EXT4_SB(sb)->s_journal;
/* Now we set up the journal barrier. */ /* Now we set up the journal barrier. */
journal_lock_updates(journal); jbd2_journal_lock_updates(journal);
journal_flush(journal); jbd2_journal_flush(journal);
/* Journal blocked and flushed, clear needs_recovery flag. */ /* Journal blocked and flushed, clear needs_recovery flag. */
EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER); 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_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
ext4_commit_super(sb, EXT4_SB(sb)->s_es, 1); ext4_commit_super(sb, EXT4_SB(sb)->s_es, 1);
unlock_super(sb); 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: * is locked for write. Otherwise the are possible deadlocks:
* Process 1 Process 2 * Process 1 Process 2
* ext4_create() quota_sync() * ext4_create() quota_sync()
* journal_start() write_dquot() * jbd2_journal_start() write_dquot()
* DQUOT_INIT() down(dqio_mutex) * DQUOT_INIT() down(dqio_mutex)
* down(dqio_mutex) journal_start() * down(dqio_mutex) jbd2_journal_start()
* *
*/ */

2
fs/ext4/symlink.c
View File

@ -18,7 +18,7 @@
*/ */
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/jbd.h> #include <linux/jbd2.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#include <linux/namei.h> #include <linux/namei.h>
#include "xattr.h" #include "xattr.h"

2
fs/ext4/xattr.c
View File

@ -53,7 +53,7 @@
#include <linux/init.h> #include <linux/init.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/ext4_jbd.h> #include <linux/ext4_jbd2.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#include <linux/mbcache.h> #include <linux/mbcache.h>
#include <linux/quotaops.h> #include <linux/quotaops.h>

2
fs/ext4/xattr_security.c
View File

@ -7,7 +7,7 @@
#include <linux/string.h> #include <linux/string.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
#include <linux/ext4_jbd.h> #include <linux/ext4_jbd2.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#include <linux/security.h> #include <linux/security.h>
#include "xattr.h" #include "xattr.h"

2
fs/ext4/xattr_trusted.c
View File

@ -10,7 +10,7 @@
#include <linux/capability.h> #include <linux/capability.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
#include <linux/ext4_jbd.h> #include <linux/ext4_jbd2.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#include "xattr.h" #include "xattr.h"

2
fs/ext4/xattr_user.c
View File

@ -9,7 +9,7 @@
#include <linux/string.h> #include <linux/string.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
#include <linux/ext4_jbd.h> #include <linux/ext4_jbd2.h>
#include <linux/ext4_fs.h> #include <linux/ext4_fs.h>
#include "xattr.h" #include "xattr.h"