[PATCH 00/32] Remove iget() and read_inode() [try #2] - Kernel

This is a discussion on [PATCH 00/32] Remove iget() and read_inode() [try #2] - Kernel ; Sam Ravnborg wrote: > One like one variant, another like another variant. > Both fails to say why. It's shorter, more compact, and of course requires the least amount of change (especially as I can automate it with a command ...

+ Reply to Thread
Page 3 of 3 FirstFirst 1 2 3
Results 41 to 43 of 43

Thread: [PATCH 00/32] Remove iget() and read_inode() [try #2]

  1. Re: [PATCH 01/32] Add an ERR_CAST() macro to complement ERR_PTR and co. [try #2]

    Sam Ravnborg wrote:

    > One like one variant, another like another variant.
    > Both fails to say why.


    It's shorter, more compact, and of course requires the least amount of change
    (especially as I can automate it with a command line perl script).

    David
    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  2. Re: [PATCH 14/32] IGET: Stop EXT3 from using iget() and read_inode() [try #2]

    > Stop the EXT3 filesystem from using iget() and read_inode(). Replace
    > ext3_read_inode() with ext3_iget(), and call that instead of iget().
    > ext3_iget() then uses iget_locked() directly and returns a proper error code
    > instead of an inode in the event of an error.
    >
    > ext3_fill_super() returns any error incurred when getting the root inode
    > instead of EINVAL.
    >
    > Signed-off-by: David Howells

    Acked-by: Jan Kara

    > ---
    >
    > fs/ext3/ialloc.c | 58 ++++++++++++++++++++++++++++-------------------
    > fs/ext3/inode.c | 25 +++++++++++++++-----
    > fs/ext3/namei.c | 29 +++++++-----------------
    > fs/ext3/resize.c | 7 ++----
    > fs/ext3/super.c | 40 ++++++++++++++++++--------------
    > include/linux/ext3_fs.h | 2 +-
    > 6 files changed, 89 insertions(+), 72 deletions(-)
    >
    > diff --git a/fs/ext3/ialloc.c b/fs/ext3/ialloc.c
    > index e45dbd6..5724adb 100644
    > --- a/fs/ext3/ialloc.c
    > +++ b/fs/ext3/ialloc.c
    > @@ -645,14 +645,15 @@ struct inode *ext3_orphan_get(struct super_block *sb, unsigned long ino)
    > unsigned long max_ino = le32_to_cpu(EXT3_SB(sb)->s_es->s_inodes_count);
    > unsigned long block_group;
    > int bit;
    > - struct buffer_head *bitmap_bh = NULL;
    > + struct buffer_head *bitmap_bh;
    > struct inode *inode = NULL;
    > + long err = -EIO;
    >
    > /* Error cases - e2fsck has already cleaned up for us */
    > if (ino > max_ino) {
    > ext3_warning(sb, __FUNCTION__,
    > "bad orphan ino %lu! e2fsck was run?", ino);
    > - goto out;
    > + goto error;
    > }
    >
    > block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
    > @@ -661,38 +662,49 @@ struct inode *ext3_orphan_get(struct super_block *sb, unsigned long ino)
    > if (!bitmap_bh) {
    > ext3_warning(sb, __FUNCTION__,
    > "inode bitmap error for orphan %lu", ino);
    > - goto out;
    > + goto error;
    > }
    >
    > /* Having the inode bit set should be a 100% indicator that this
    > * is a valid orphan (no e2fsck run on fs). Orphans also include
    > * inodes that were being truncated, so we can't check i_nlink==0.
    > */
    > - if (!ext3_test_bit(bit, bitmap_bh->b_data) ||
    > - !(inode = iget(sb, ino)) || is_bad_inode(inode) ||
    > - NEXT_ORPHAN(inode) > max_ino) {
    > - ext3_warning(sb, __FUNCTION__,
    > - "bad orphan inode %lu! e2fsck was run?", ino);
    > - printk(KERN_NOTICE "ext3_test_bit(bit=%d, block=%llu) = %d\n",
    > - bit, (unsigned long long)bitmap_bh->b_blocknr,
    > - ext3_test_bit(bit, bitmap_bh->b_data));
    > - printk(KERN_NOTICE "inode=%p\n", inode);
    > - if (inode) {
    > - printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
    > - is_bad_inode(inode));
    > - printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
    > - NEXT_ORPHAN(inode));
    > - printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
    > - }
    > + if (!ext3_test_bit(bit, bitmap_bh->b_data))
    > + goto bad_orphan;
    > +
    > + inode = ext3_iget(sb, ino);
    > + if (IS_ERR(inode))
    > + goto iget_failed;
    > +
    > + if (NEXT_ORPHAN(inode) > max_ino)
    > + goto bad_orphan;
    > + brelse(bitmap_bh);
    > + return inode;
    > +
    > +iget_failed:
    > + err = PTR_ERR(inode);
    > + inode = NULL;
    > +bad_orphan:
    > + ext3_warning(sb, __FUNCTION__,
    > + "bad orphan inode %lu! e2fsck was run?", ino);
    > + printk(KERN_NOTICE "ext3_test_bit(bit=%d, block=%llu) = %d\n",
    > + bit, (unsigned long long)bitmap_bh->b_blocknr,
    > + ext3_test_bit(bit, bitmap_bh->b_data));
    > + printk(KERN_NOTICE "inode=%p\n", inode);
    > + if (inode) {
    > + printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
    > + is_bad_inode(inode));
    > + printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
    > + NEXT_ORPHAN(inode));
    > + printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
    > /* Avoid freeing blocks if we got a bad deleted inode */
    > - if (inode && inode->i_nlink == 0)
    > + if (inode->i_nlink == 0)
    > inode->i_blocks = 0;
    > iput(inode);
    > - inode = NULL;
    > }
    > -out:
    > brelse(bitmap_bh);
    > - return inode;
    > +error:
    > + return ERR_PTR(err);
    > }
    >
    > unsigned long ext3_count_free_inodes (struct super_block * sb)
    > diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
    > index de4e316..6c74622 100644
    > --- a/fs/ext3/inode.c
    > +++ b/fs/ext3/inode.c
    > @@ -2591,21 +2591,31 @@ void ext3_get_inode_flags(struct ext3_inode_info *ei)
    > ei->i_flags |= EXT3_DIRSYNC_FL;
    > }
    >
    > -void ext3_read_inode(struct inode * inode)
    > +struct inode *ext3_iget(struct super_block *sb, unsigned long ino)
    > {
    > struct ext3_iloc iloc;
    > struct ext3_inode *raw_inode;
    > - struct ext3_inode_info *ei = EXT3_I(inode);
    > + struct ext3_inode_info *ei;
    > struct buffer_head *bh;
    > + struct inode *inode;
    > + long ret;
    > int block;
    >
    > + inode = iget_locked(sb, ino);
    > + if (!inode)
    > + return ERR_PTR(-ENOMEM);
    > + if (!(inode->i_state & I_NEW))
    > + return inode;
    > +
    > + ei = EXT3_I(inode);
    > #ifdef CONFIG_EXT3_FS_POSIX_ACL
    > ei->i_acl = EXT3_ACL_NOT_CACHED;
    > ei->i_default_acl = EXT3_ACL_NOT_CACHED;
    > #endif
    > ei->i_block_alloc_info = NULL;
    >
    > - if (__ext3_get_inode_loc(inode, &iloc, 0))
    > + ret = __ext3_get_inode_loc(inode, &iloc, 0);
    > + if (ret < 0)
    > goto bad_inode;
    > bh = iloc.bh;
    > raw_inode = ext3_raw_inode(&iloc);
    > @@ -2636,6 +2646,7 @@ void ext3_read_inode(struct inode * inode)
    > !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ORPHAN_FS)) {
    > /* this inode is deleted */
    > brelse (bh);
    > + ret = -ESTALE;
    > goto bad_inode;
    > }
    > /* The only unlinked inodes we let through here have
    > @@ -2679,6 +2690,7 @@ void ext3_read_inode(struct inode * inode)
    > if (EXT3_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
    > EXT3_INODE_SIZE(inode->i_sb)) {
    > brelse (bh);
    > + ret = -EIO;
    > goto bad_inode;
    > }
    > if (ei->i_extra_isize == 0) {
    > @@ -2720,11 +2732,12 @@ void ext3_read_inode(struct inode * inode)
    > }
    > brelse (iloc.bh);
    > ext3_set_inode_flags(inode);
    > - return;
    > + unlock_new_inode(inode);
    > + return inode;
    >
    > bad_inode:
    > - make_bad_inode(inode);
    > - return;
    > + iget_failed(inode);
    > + return ERR_PTR(ret);
    > }
    >
    > /*
    > diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
    > index c1fa190..6919a18 100644
    > --- a/fs/ext3/namei.c
    > +++ b/fs/ext3/namei.c
    > @@ -1046,17 +1046,11 @@ static struct dentry *ext3_lookup(struct inode * dir, struct dentry *dentry, str
    > if (!ext3_valid_inum(dir->i_sb, ino)) {
    > ext3_error(dir->i_sb, "ext3_lookup",
    > "bad inode number: %lu", ino);
    > - inode = NULL;
    > - } else
    > - inode = iget(dir->i_sb, ino);
    > -
    > - if (!inode)
    > - return ERR_PTR(-EACCES);
    > -
    > - if (is_bad_inode(inode)) {
    > - iput(inode);
    > - return ERR_PTR(-ENOENT);
    > + return ERR_PTR(-EIO);
    > }
    > + inode = ext3_iget(dir->i_sb, ino);
    > + if (IS_ERR(inode))
    > + return ERR_CAST(inode);
    > }
    > return d_splice_alias(inode, dentry);
    > }
    > @@ -1085,18 +1079,13 @@ struct dentry *ext3_get_parent(struct dentry *child)
    > if (!ext3_valid_inum(child->d_inode->i_sb, ino)) {
    > ext3_error(child->d_inode->i_sb, "ext3_get_parent",
    > "bad inode number: %lu", ino);
    > - inode = NULL;
    > - } else
    > - inode = iget(child->d_inode->i_sb, ino);
    > -
    > - if (!inode)
    > - return ERR_PTR(-EACCES);
    > -
    > - if (is_bad_inode(inode)) {
    > - iput(inode);
    > - return ERR_PTR(-ENOENT);
    > + return ERR_PTR(-EIO);
    > }
    >
    > + inode = ext3_iget(child->d_inode->i_sb, ino);
    > + if (IS_ERR(inode))
    > + return ERR_CAST(inode);
    > +
    > parent = d_alloc_anon(inode);
    > if (!parent) {
    > iput(inode);
    > diff --git a/fs/ext3/resize.c b/fs/ext3/resize.c
    > index 2c97e09..60b6530 100644
    > --- a/fs/ext3/resize.c
    > +++ b/fs/ext3/resize.c
    > @@ -748,12 +748,11 @@ int ext3_group_add(struct super_block *sb, struct ext3_new_group_data *input)
    > "No reserved GDT blocks, can't resize");
    > return -EPERM;
    > }
    > - inode = iget(sb, EXT3_RESIZE_INO);
    > - if (!inode || is_bad_inode(inode)) {
    > + inode = ext3_iget(sb, EXT3_RESIZE_INO);
    > + if (IS_ERR(inode)) {
    > ext3_warning(sb, __FUNCTION__,
    > "Error opening resize inode");
    > - iput(inode);
    > - return -ENOENT;
    > + return PTR_ERR(inode);
    > }
    > }
    >
    > diff --git a/fs/ext3/super.c b/fs/ext3/super.c
    > index 9537316..add683b 100644
    > --- a/fs/ext3/super.c
    > +++ b/fs/ext3/super.c
    > @@ -583,11 +583,10 @@ static struct dentry *ext3_get_dentry(struct super_block *sb, void *vobjp)
    > * Currently we don't know the generation for parent directory, so
    > * a generation of 0 means "accept any"
    > */
    > - inode = iget(sb, ino);
    > - if (inode == NULL)
    > - return ERR_PTR(-ENOMEM);
    > - if (is_bad_inode(inode) ||
    > - (generation && inode->i_generation != generation)) {
    > + inode = ext3_iget(sb, ino);
    > + if (IS_ERR(inode))
    > + return ERR_CAST(inode);
    > + if (generation && inode->i_generation != generation) {
    > iput(inode);
    > return ERR_PTR(-ESTALE);
    > }
    > @@ -649,7 +648,6 @@ static struct quotactl_ops ext3_qctl_operations = {
    > static const struct super_operations ext3_sops = {
    > .alloc_inode = ext3_alloc_inode,
    > .destroy_inode = ext3_destroy_inode,
    > - .read_inode = ext3_read_inode,
    > .write_inode = ext3_write_inode,
    > .dirty_inode = ext3_dirty_inode,
    > .delete_inode = ext3_delete_inode,
    > @@ -1309,8 +1307,8 @@ static void ext3_orphan_cleanup (struct super_block * sb,
    > while (es->s_last_orphan) {
    > struct inode *inode;
    >
    > - if (!(inode =
    > - ext3_orphan_get(sb, le32_to_cpu(es->s_last_orphan)))) {
    > + inode = ext3_orphan_get(sb, le32_to_cpu(es->s_last_orphan));
    > + if (IS_ERR(inode)) {
    > es->s_last_orphan = 0;
    > break;
    > }
    > @@ -1415,6 +1413,7 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
    > int db_count;
    > int i;
    > int needs_recovery;
    > + int ret = -EINVAL;
    > __le32 features;
    >
    > sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
    > @@ -1770,19 +1769,24 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
    > * so we can safely mount the rest of the filesystem now.
    > */
    >
    > - root = iget(sb, EXT3_ROOT_INO);
    > - sb->s_root = d_alloc_root(root);
    > - if (!sb->s_root) {
    > + root = ext3_iget(sb, EXT3_ROOT_INO);
    > + if (IS_ERR(root)) {
    > printk(KERN_ERR "EXT3-fs: get root inode failed\n");
    > - iput(root);
    > + ret = PTR_ERR(root);
    > goto failed_mount4;
    > }
    > if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
    > - dput(sb->s_root);
    > - sb->s_root = NULL;
    > + iput(root);
    > printk(KERN_ERR "EXT3-fs: corrupt root inode, run e2fsck\n");
    > goto failed_mount4;
    > }
    > + sb->s_root = d_alloc_root(root);
    > + if (!sb->s_root) {
    > + printk(KERN_ERR "EXT3-fs: get root dentry failed\n");
    > + iput(root);
    > + ret = -ENOMEM;
    > + goto failed_mount4;
    > + }
    >
    > ext3_setup_super (sb, es, sb->s_flags & MS_RDONLY);
    > /*
    > @@ -1834,7 +1838,7 @@ out_fail:
    > sb->s_fs_info = NULL;
    > kfree(sbi);
    > lock_kernel();
    > - return -EINVAL;
    > + return ret;
    > }
    >
    > /*
    > @@ -1870,8 +1874,8 @@ static journal_t *ext3_get_journal(struct super_block *sb,
    > * things happen if we iget() an unused inode, as the subsequent
    > * iput() will try to delete it. */
    >
    > - journal_inode = iget(sb, journal_inum);
    > - if (!journal_inode) {
    > + journal_inode = ext3_iget(sb, journal_inum);
    > + if (IS_ERR(journal_inode)) {
    > printk(KERN_ERR "EXT3-fs: no journal found.\n");
    > return NULL;
    > }
    > @@ -1884,7 +1888,7 @@ static journal_t *ext3_get_journal(struct super_block *sb,
    >
    > jbd_debug(2, "Journal inode found at %p: %Ld bytes\n",
    > journal_inode, journal_inode->i_size);
    > - if (is_bad_inode(journal_inode) || !S_ISREG(journal_inode->i_mode)) {
    > + if (!S_ISREG(journal_inode->i_mode)) {
    > printk(KERN_ERR "EXT3-fs: invalid journal inode.\n");
    > iput(journal_inode);
    > return NULL;
    > diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
    > index ece49a8..a5ccfea 100644
    > --- a/include/linux/ext3_fs.h
    > +++ b/include/linux/ext3_fs.h
    > @@ -813,7 +813,7 @@ int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
    > sector_t iblock, unsigned long maxblocks, struct buffer_head *bh_result,
    > int create, int extend_disksize);
    >
    > -extern void ext3_read_inode (struct inode *);
    > +extern struct inode *ext3_iget (struct super_block *, unsigned long);
    > extern int ext3_write_inode (struct inode *, int);
    > extern int ext3_setattr (struct dentry *, struct iattr *);
    > extern void ext3_delete_inode (struct inode *);
    >
    > -
    > To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    > the body of a message to majordomo@vger.kernel.org
    > More majordomo info at http://vger.kernel.org/majordomo-info.html
    > Please read the FAQ at http://www.tux.org/lkml/

    --
    Jan Kara
    SuSE CR Labs
    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  3. Re: [PATCH 15/32] IGET: Stop EXT4 from using iget() and read_inode() [try #2]

    > Stop the EXT4 filesystem from using iget() and read_inode(). Replace
    > ext4_read_inode() with ext4_iget(), and call that instead of iget().
    > ext4_iget() then uses iget_locked() directly and returns a proper error code
    > instead of an inode in the event of an error.
    >
    > ext4_fill_super() returns any error incurred when getting the root inode
    > instead of EINVAL.
    >
    > Signed-off-by: David Howells

    Acked-by: Jan Kara

    > ---
    >
    > fs/ext4/ialloc.c | 58 ++++++++++++++++++++++++++++-------------------
    > fs/ext4/inode.c | 25 +++++++++++++++-----
    > fs/ext4/namei.c | 29 +++++++-----------------
    > fs/ext4/resize.c | 7 ++----
    > fs/ext4/super.c | 36 ++++++++++++++++-------------
    > include/linux/ext4_fs.h | 2 +-
    > 6 files changed, 87 insertions(+), 70 deletions(-)
    >
    > diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
    > index 427f830..4fba007 100644
    > --- a/fs/ext4/ialloc.c
    > +++ b/fs/ext4/ialloc.c
    > @@ -659,14 +659,15 @@ struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)
    > unsigned long max_ino = le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count);
    > unsigned long block_group;
    > int bit;
    > - struct buffer_head *bitmap_bh = NULL;
    > + struct buffer_head *bitmap_bh;
    > struct inode *inode = NULL;
    > + long err = -EIO;
    >
    > /* Error cases - e2fsck has already cleaned up for us */
    > if (ino > max_ino) {
    > ext4_warning(sb, __FUNCTION__,
    > "bad orphan ino %lu! e2fsck was run?", ino);
    > - goto out;
    > + goto error;
    > }
    >
    > block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
    > @@ -675,38 +676,49 @@ struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)
    > if (!bitmap_bh) {
    > ext4_warning(sb, __FUNCTION__,
    > "inode bitmap error for orphan %lu", ino);
    > - goto out;
    > + goto error;
    > }
    >
    > /* Having the inode bit set should be a 100% indicator that this
    > * is a valid orphan (no e2fsck run on fs). Orphans also include
    > * inodes that were being truncated, so we can't check i_nlink==0.
    > */
    > - if (!ext4_test_bit(bit, bitmap_bh->b_data) ||
    > - !(inode = iget(sb, ino)) || is_bad_inode(inode) ||
    > - NEXT_ORPHAN(inode) > max_ino) {
    > - ext4_warning(sb, __FUNCTION__,
    > - "bad orphan inode %lu! e2fsck was run?", ino);
    > - printk(KERN_NOTICE "ext4_test_bit(bit=%d, block=%llu) = %d\n",
    > - bit, (unsigned long long)bitmap_bh->b_blocknr,
    > - ext4_test_bit(bit, bitmap_bh->b_data));
    > - printk(KERN_NOTICE "inode=%p\n", inode);
    > - if (inode) {
    > - printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
    > - is_bad_inode(inode));
    > - printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
    > - NEXT_ORPHAN(inode));
    > - printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
    > - }
    > + if (!ext4_test_bit(bit, bitmap_bh->b_data))
    > + goto bad_orphan;
    > +
    > + inode = ext4_iget(sb, ino);
    > + if (IS_ERR(inode))
    > + goto iget_failed;
    > +
    > + if (NEXT_ORPHAN(inode) > max_ino)
    > + goto bad_orphan;
    > + brelse(bitmap_bh);
    > + return inode;
    > +
    > +iget_failed:
    > + err = PTR_ERR(inode);
    > + inode = NULL;
    > +bad_orphan:
    > + ext4_warning(sb, __FUNCTION__,
    > + "bad orphan inode %lu! e2fsck was run?", ino);
    > + printk(KERN_NOTICE "ext4_test_bit(bit=%d, block=%llu) = %d\n",
    > + bit, (unsigned long long)bitmap_bh->b_blocknr,
    > + ext4_test_bit(bit, bitmap_bh->b_data));
    > + printk(KERN_NOTICE "inode=%p\n", inode);
    > + if (inode) {
    > + printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
    > + is_bad_inode(inode));
    > + printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
    > + NEXT_ORPHAN(inode));
    > + printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
    > /* Avoid freeing blocks if we got a bad deleted inode */
    > - if (inode && inode->i_nlink == 0)
    > + if (inode->i_nlink == 0)
    > inode->i_blocks = 0;
    > iput(inode);
    > - inode = NULL;
    > }
    > -out:
    > brelse(bitmap_bh);
    > - return inode;
    > +error:
    > + return ERR_PTR(err);
    > }
    >
    > unsigned long ext4_count_free_inodes (struct super_block * sb)
    > diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
    > index a4848e0..c4fb1eb 100644
    > --- a/fs/ext4/inode.c
    > +++ b/fs/ext4/inode.c
    > @@ -2595,21 +2595,31 @@ void ext4_get_inode_flags(struct ext4_inode_info *ei)
    > ei->i_flags |= EXT4_DIRSYNC_FL;
    > }
    >
    > -void ext4_read_inode(struct inode * inode)
    > +struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
    > {
    > struct ext4_iloc iloc;
    > struct ext4_inode *raw_inode;
    > - struct ext4_inode_info *ei = EXT4_I(inode);
    > + struct ext4_inode_info *ei;
    > struct buffer_head *bh;
    > + struct inode *inode;
    > + long ret;
    > int block;
    >
    > + inode = iget_locked(sb, ino);
    > + if (!inode)
    > + return ERR_PTR(-ENOMEM);
    > + if (!(inode->i_state & I_NEW))
    > + return inode;
    > +
    > + ei = EXT4_I(inode);
    > #ifdef CONFIG_EXT4DEV_FS_POSIX_ACL
    > ei->i_acl = EXT4_ACL_NOT_CACHED;
    > ei->i_default_acl = EXT4_ACL_NOT_CACHED;
    > #endif
    > ei->i_block_alloc_info = NULL;
    >
    > - if (__ext4_get_inode_loc(inode, &iloc, 0))
    > + ret = __ext4_get_inode_loc(inode, &iloc, 0);
    > + if (ret < 0)
    > goto bad_inode;
    > bh = iloc.bh;
    > raw_inode = ext4_raw_inode(&iloc);
    > @@ -2636,6 +2646,7 @@ void ext4_read_inode(struct inode * inode)
    > !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) {
    > /* this inode is deleted */
    > brelse (bh);
    > + ret = -ESTALE;
    > goto bad_inode;
    > }
    > /* The only unlinked inodes we let through here have
    > @@ -2683,6 +2694,7 @@ void ext4_read_inode(struct inode * inode)
    > if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
    > EXT4_INODE_SIZE(inode->i_sb)) {
    > brelse (bh);
    > + ret = -EIO;
    > goto bad_inode;
    > }
    > if (ei->i_extra_isize == 0) {
    > @@ -2729,11 +2741,12 @@ void ext4_read_inode(struct inode * inode)
    > }
    > brelse (iloc.bh);
    > ext4_set_inode_flags(inode);
    > - return;
    > + unlock_new_inode(inode);
    > + return inode;
    >
    > bad_inode:
    > - make_bad_inode(inode);
    > - return;
    > + iget_failed(inode);
    > + return ERR_PTR(ret);
    > }
    >
    > /*
    > diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
    > index 5fdb862..301f41f 100644
    > --- a/fs/ext4/namei.c
    > +++ b/fs/ext4/namei.c
    > @@ -1044,17 +1044,11 @@ static struct dentry *ext4_lookup(struct inode * dir, struct dentry *dentry, str
    > if (!ext4_valid_inum(dir->i_sb, ino)) {
    > ext4_error(dir->i_sb, "ext4_lookup",
    > "bad inode number: %lu", ino);
    > - inode = NULL;
    > - } else
    > - inode = iget(dir->i_sb, ino);
    > -
    > - if (!inode)
    > - return ERR_PTR(-EACCES);
    > -
    > - if (is_bad_inode(inode)) {
    > - iput(inode);
    > - return ERR_PTR(-ENOENT);
    > + return ERR_PTR(-EIO);
    > }
    > + inode = ext4_iget(dir->i_sb, ino);
    > + if (IS_ERR(inode))
    > + return ERR_CAST(inode);
    > }
    > return d_splice_alias(inode, dentry);
    > }
    > @@ -1083,18 +1077,13 @@ struct dentry *ext4_get_parent(struct dentry *child)
    > if (!ext4_valid_inum(child->d_inode->i_sb, ino)) {
    > ext4_error(child->d_inode->i_sb, "ext4_get_parent",
    > "bad inode number: %lu", ino);
    > - inode = NULL;
    > - } else
    > - inode = iget(child->d_inode->i_sb, ino);
    > -
    > - if (!inode)
    > - return ERR_PTR(-EACCES);
    > -
    > - if (is_bad_inode(inode)) {
    > - iput(inode);
    > - return ERR_PTR(-ENOENT);
    > + return ERR_PTR(-EIO);
    > }
    >
    > + inode = ext4_iget(child->d_inode->i_sb, ino);
    > + if (IS_ERR(inode))
    > + return ERR_CAST(inode);
    > +
    > parent = d_alloc_anon(inode);
    > if (!parent) {
    > iput(inode);
    > diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
    > index aa11d7d..345f901 100644
    > --- a/fs/ext4/resize.c
    > +++ b/fs/ext4/resize.c
    > @@ -757,12 +757,11 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
    > "No reserved GDT blocks, can't resize");
    > return -EPERM;
    > }
    > - inode = iget(sb, EXT4_RESIZE_INO);
    > - if (!inode || is_bad_inode(inode)) {
    > + inode = ext4_iget(sb, EXT4_RESIZE_INO);
    > + if (IS_ERR(inode)) {
    > ext4_warning(sb, __FUNCTION__,
    > "Error opening resize inode");
    > - iput(inode);
    > - return -ENOENT;
    > + return PTR_ERR(inode);
    > }
    > }
    >
    > diff --git a/fs/ext4/super.c b/fs/ext4/super.c
    > index 3c1397f..05434a1 100644
    > --- a/fs/ext4/super.c
    > +++ b/fs/ext4/super.c
    > @@ -634,11 +634,10 @@ static struct dentry *ext4_get_dentry(struct super_block *sb, void *vobjp)
    > * Currently we don't know the generation for parent directory, so
    > * a generation of 0 means "accept any"
    > */
    > - inode = iget(sb, ino);
    > - if (inode == NULL)
    > - return ERR_PTR(-ENOMEM);
    > - if (is_bad_inode(inode) ||
    > - (generation && inode->i_generation != generation)) {
    > + inode = ext4_iget(sb, ino);
    > + if (IS_ERR(inode))
    > + return ERR_CAST(inode);
    > + if (generation && inode->i_generation != generation) {
    > iput(inode);
    > return ERR_PTR(-ESTALE);
    > }
    > @@ -700,7 +699,6 @@ static struct quotactl_ops ext4_qctl_operations = {
    > static const struct super_operations ext4_sops = {
    > .alloc_inode = ext4_alloc_inode,
    > .destroy_inode = ext4_destroy_inode,
    > - .read_inode = ext4_read_inode,
    > .write_inode = ext4_write_inode,
    > .dirty_inode = ext4_dirty_inode,
    > .delete_inode = ext4_delete_inode,
    > @@ -1472,6 +1470,7 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
    > unsigned long journal_devnum = 0;
    > unsigned long def_mount_opts;
    > struct inode *root;
    > + int ret = -EINVAL;
    > int blocksize;
    > int hblock;
    > int db_count;
    > @@ -1862,19 +1861,24 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
    > * so we can safely mount the rest of the filesystem now.
    > */
    >
    > - root = iget(sb, EXT4_ROOT_INO);
    > - sb->s_root = d_alloc_root(root);
    > - if (!sb->s_root) {
    > + root = ext4_iget(sb, EXT4_ROOT_INO);
    > + if (IS_ERR(root)) {
    > printk(KERN_ERR "EXT4-fs: get root inode failed\n");
    > - iput(root);
    > + ret = PTR_ERR(root);
    > goto failed_mount4;
    > }
    > if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
    > - dput(sb->s_root);
    > - sb->s_root = NULL;
    > + iput(root);
    > printk(KERN_ERR "EXT4-fs: corrupt root inode, run e2fsck\n");
    > goto failed_mount4;
    > }
    > + sb->s_root = d_alloc_root(root);
    > + if (!sb->s_root) {
    > + printk(KERN_ERR "EXT4-fs: get root dentry failed\n");
    > + iput(root);
    > + ret = -ENOMEM;
    > + goto failed_mount4;
    > + }
    >
    > ext4_setup_super (sb, es, sb->s_flags & MS_RDONLY);
    >
    > @@ -1954,7 +1958,7 @@ out_fail:
    > sb->s_fs_info = NULL;
    > kfree(sbi);
    > lock_kernel();
    > - return -EINVAL;
    > + return ret;
    > }
    >
    > /*
    > @@ -1990,8 +1994,8 @@ static journal_t *ext4_get_journal(struct super_block *sb,
    > * things happen if we iget() an unused inode, as the subsequent
    > * iput() will try to delete it. */
    >
    > - journal_inode = iget(sb, journal_inum);
    > - if (!journal_inode) {
    > + journal_inode = ext4_iget(sb, journal_inum);
    > + if (IS_ERR(journal_inode)) {
    > printk(KERN_ERR "EXT4-fs: no journal found.\n");
    > return NULL;
    > }
    > @@ -2004,7 +2008,7 @@ static journal_t *ext4_get_journal(struct super_block *sb,
    >
    > jbd_debug(2, "Journal inode found at %p: %Ld bytes\n",
    > journal_inode, journal_inode->i_size);
    > - if (is_bad_inode(journal_inode) || !S_ISREG(journal_inode->i_mode)) {
    > + if (!S_ISREG(journal_inode->i_mode)) {
    > printk(KERN_ERR "EXT4-fs: invalid journal inode.\n");
    > iput(journal_inode);
    > return NULL;
    > diff --git a/include/linux/ext4_fs.h b/include/linux/ext4_fs.h
    > index cdee7aa..12354d5 100644
    > --- a/include/linux/ext4_fs.h
    > +++ b/include/linux/ext4_fs.h
    > @@ -944,7 +944,7 @@ int ext4_get_blocks_handle(handle_t *handle, struct inode *inode,
    > sector_t iblock, unsigned long maxblocks, struct buffer_head *bh_result,
    > int create, int extend_disksize);
    >
    > -extern void ext4_read_inode (struct inode *);
    > +extern struct inode *ext4_iget(struct super_block *, unsigned long);
    > extern int ext4_write_inode (struct inode *, int);
    > extern int ext4_setattr (struct dentry *, struct iattr *);
    > extern void ext4_delete_inode (struct inode *);
    >
    > -
    > To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    > the body of a message to majordomo@vger.kernel.org
    > More majordomo info at http://vger.kernel.org/majordomo-info.html
    > Please read the FAQ at http://www.tux.org/lkml/

    --
    Jan Kara
    SuSE CR Labs
    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

+ Reply to Thread
Page 3 of 3 FirstFirst 1 2 3