forked from luck/tmp_suning_uos_patched
[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: 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
Linus Torvalds
parent
a920e9416b
commit
dab291af8d
48
fs/Kconfig
48
fs/Kconfig
|
|
@ -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"
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user