switch open-coded instances of d_make_root() to new helper

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/arch/powerpc/platforms/cell/spufs/inode.c b/arch/powerpc/platforms/cell/spufs/inode.c
index d4a094c..17b3211 100644 (file)
--- a/arch/powerpc/platforms/cell/spufs/inode.c
+++ b/arch/powerpc/platforms/cell/spufs/inode.c
@@ -757,9 +757,9 @@ spufs_create_root(struct super_block *sb, void *data)
                goto out_iput;
 
        ret = -ENOMEM;
-       sb->s_root = d_alloc_root(inode);
+       sb->s_root = d_make_root(inode);
        if (!sb->s_root)
-               goto out_iput;
+               goto out;
 
        return 0;
 out_iput:

diff --git a/arch/s390/hypfs/inode.c b/arch/s390/hypfs/inode.c
index 8a2a887..6a2cb56 100644 (file)
--- a/arch/s390/hypfs/inode.c
+++ b/arch/s390/hypfs/inode.c
@@ -293,11 +293,9 @@ static int hypfs_fill_super(struct super_block *sb, void *data, int silent)
                return -ENOMEM;
        root_inode->i_op = &simple_dir_inode_operations;
        root_inode->i_fop = &simple_dir_operations;
-       sb->s_root = root_dentry = d_alloc_root(root_inode);
-       if (!root_dentry) {
-               iput(root_inode);
+       sb->s_root = root_dentry = d_make_root(root_inode);
+       if (!root_dentry)
                return -ENOMEM;
-       }
        if (MACHINE_IS_VM)
                rc = hypfs_vm_create_files(sb, root_dentry);
        else

diff --git a/drivers/misc/ibmasm/ibmasmfs.c b/drivers/misc/ibmasm/ibmasmfs.c
index 3536175..15f24f3 100644 (file)
--- a/drivers/misc/ibmasm/ibmasmfs.c
+++ b/drivers/misc/ibmasm/ibmasmfs.c
@@ -129,11 +129,9 @@ static int ibmasmfs_fill_super (struct super_block *sb, void *data, int silent)
        root->i_op = &simple_dir_inode_operations;
        root->i_fop = ibmasmfs_dir_ops;
 
-       root_dentry = d_alloc_root(root);
-       if (!root_dentry) {
-               iput(root);
+       root_dentry = d_make_root(root);
+       if (!root_dentry)
                return -ENOMEM;
-       }
        sb->s_root = root_dentry;
 
        ibmasmfs_create_files(sb, root_dentry);

diff --git a/drivers/oprofile/oprofilefs.c b/drivers/oprofile/oprofilefs.c
index 2f0aa0f..277bb70 100644 (file)
--- a/drivers/oprofile/oprofilefs.c
+++ b/drivers/oprofile/oprofilefs.c
@@ -251,11 +251,9 @@ static int oprofilefs_fill_super(struct super_block *sb, void *data, int silent)
                return -ENOMEM;
        root_inode->i_op = &simple_dir_inode_operations;
        root_inode->i_fop = &simple_dir_operations;
-       root_dentry = d_alloc_root(root_inode);
-       if (!root_dentry) {
-               iput(root_inode);
+       root_dentry = d_make_root(root_inode);
+       if (!root_dentry)
                return -ENOMEM;
-       }
 
        sb->s_root = root_dentry;
 

diff --git a/drivers/usb/core/inode.c b/drivers/usb/core/inode.c
index 9e186f3..bdaef8e 100644 (file)
--- a/drivers/usb/core/inode.c
+++ b/drivers/usb/core/inode.c
@@ -462,16 +462,9 @@ static int usbfs_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_op = &usbfs_ops;
        sb->s_time_gran = 1;
        inode = usbfs_get_inode(sb, S_IFDIR | 0755, 0);
-
-       if (!inode) {
-               dbg("%s: could not get inode!",__func__);
-               return -ENOMEM;
-       }
-
-       root = d_alloc_root(inode);
+       root = d_make_root(inode);
        if (!root) {
                dbg("%s: could not get root dentry!",__func__);
-               iput(inode);
                return -ENOMEM;
        }
        sb->s_root = root;

diff --git a/drivers/usb/gadget/f_fs.c b/drivers/usb/gadget/f_fs.c
index f63dc6c..d825b24 100644 (file)
--- a/drivers/usb/gadget/f_fs.c
+++ b/drivers/usb/gadget/f_fs.c
@@ -1063,13 +1063,9 @@ static int ffs_sb_fill(struct super_block *sb, void *_data, int silent)
                                  &simple_dir_operations,
                                  &simple_dir_inode_operations,
                                  &data->perms);
-       if (unlikely(!inode))
+       sb->s_root = d_make_root(inode);
+       if (unlikely(!sb->s_root))
                goto Enomem;
-       sb->s_root = d_alloc_root(inode);
-       if (unlikely(!sb->s_root)) {
-               iput(inode);
-               goto Enomem;
-       }
 
        /* EP0 file */
        if (unlikely(!ffs_sb_create_file(sb, "ep0", ffs,

diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index ae04266..c95eea4 100644 (file)
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -2059,10 +2059,8 @@ gadgetfs_fill_super (struct super_block *sb, void *opts, int silent)
        if (!inode)
                goto Enomem;
        inode->i_op = &simple_dir_inode_operations;
-       if (!(sb->s_root = d_alloc_root (inode))) {
-               iput(inode);
+       if (!(sb->s_root = d_make_root (inode)))
                goto Enomem;
-       }
 
        /* the ep0 file is named after the controller we expect;
         * user mode code can use it for sanity checks, like we do.

diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index 7b0cd87..10b7d3c 100644 (file)
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -155,9 +155,8 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
                goto release_sb;
        }
 
-       root = d_alloc_root(inode);
+       root = d_make_root(inode);
        if (!root) {
-               iput(inode);
                retval = -ENOMEM;
                goto release_sb;
        }

diff --git a/fs/adfs/super.c b/fs/adfs/super.c
index 8e3b36a..06fdcc9 100644 (file)
--- a/fs/adfs/super.c
+++ b/fs/adfs/super.c
@@ -483,10 +483,9 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
 
        sb->s_d_op = &adfs_dentry_operations;
        root = adfs_iget(sb, &root_obj);
-       sb->s_root = d_alloc_root(root);
+       sb->s_root = d_make_root(root);
        if (!sb->s_root) {
                int i;
-               iput(root);
                for (i = 0; i < asb->s_map_size; i++)
                        brelse(asb->s_map[i].dm_bh);
                kfree(asb->s_map);

diff --git a/fs/affs/super.c b/fs/affs/super.c
index 8ba73fe..0782653 100644 (file)
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -473,7 +473,7 @@ got_root:
        root_inode = affs_iget(sb, root_block);
        if (IS_ERR(root_inode)) {
                ret = PTR_ERR(root_inode);
-               goto out_error_noinode;
+               goto out_error;
        }
 
        if (AFFS_SB(sb)->s_flags & SF_INTL)
@@ -481,7 +481,7 @@ got_root:
        else
                sb->s_d_op = &affs_dentry_operations;
 
-       sb->s_root = d_alloc_root(root_inode);
+       sb->s_root = d_make_root(root_inode);
        if (!sb->s_root) {
                printk(KERN_ERR "AFFS: Get root inode failed\n");
                goto out_error;
@@ -494,9 +494,6 @@ got_root:
         * Begin the cascaded cleanup ...
         */
 out_error:
-       if (root_inode)
-               iput(root_inode);
-out_error_noinode:
        kfree(sbi->s_bitmap);
        affs_brelse(root_bh);
        kfree(sbi->s_prefix);

diff --git a/fs/afs/super.c b/fs/afs/super.c
index 983ec59..f02b31e 100644 (file)
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -301,7 +301,6 @@ static int afs_fill_super(struct super_block *sb,
 {
        struct afs_super_info *as = sb->s_fs_info;
        struct afs_fid fid;
-       struct dentry *root = NULL;
        struct inode *inode = NULL;
        int ret;
 
@@ -327,18 +326,16 @@ static int afs_fill_super(struct super_block *sb,
                set_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(inode)->flags);
 
        ret = -ENOMEM;
-       root = d_alloc_root(inode);
-       if (!root)
+       sb->s_root = d_make_root(inode);
+       if (!sb->s_root)
                goto error;
 
        sb->s_d_op = &afs_fs_dentry_operations;
-       sb->s_root = root;
 
        _leave(" = 0");
        return 0;
 
 error:
-       iput(inode);
        _leave(" = %d", ret);
        return ret;
 }

diff --git a/fs/autofs4/inode.c b/fs/autofs4/inode.c
index 06858d9..d8dc002 100644 (file)
--- a/fs/autofs4/inode.c
+++ b/fs/autofs4/inode.c
@@ -247,12 +247,9 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent)
        if (!ino)
                goto fail_free;
        root_inode = autofs4_get_inode(s, S_IFDIR | 0755);
-       if (!root_inode)
-               goto fail_ino;
-
-       root = d_alloc_root(root_inode);
+       root = d_make_root(root_inode);
        if (!root)
-               goto fail_iput;
+               goto fail_ino;
        pipe = NULL;
 
        root->d_fsdata = ino;
@@ -317,9 +314,6 @@ fail_fput:
 fail_dput:
        dput(root);
        goto fail_free;
-fail_iput:
-       printk("autofs: get root dentry failed\n");
-       iput(root_inode);
 fail_ino:
        kfree(ino);
 fail_free:

diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index 6e6d536..e18da23 100644 (file)
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -852,9 +852,8 @@ befs_fill_super(struct super_block *sb, void *data, int silent)
                ret = PTR_ERR(root);
                goto unacquire_priv_sbp;
        }
-       sb->s_root = d_alloc_root(root);
+       sb->s_root = d_make_root(root);
        if (!sb->s_root) {
-               iput(root);
                befs_error(sb, "get root inode failed");
                goto unacquire_priv_sbp;
        }

diff --git a/fs/bfs/inode.c b/fs/bfs/inode.c
index b0391bc..e23dc7c 100644 (file)
--- a/fs/bfs/inode.c
+++ b/fs/bfs/inode.c
@@ -367,9 +367,8 @@ static int bfs_fill_super(struct super_block *s, void *data, int silent)
                ret = PTR_ERR(inode);
                goto out2;
        }
-       s->s_root = d_alloc_root(inode);
+       s->s_root = d_make_root(inode);
        if (!s->s_root) {
-               iput(inode);
                ret = -ENOMEM;
                goto out2;
        }

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 3ce97b2..81df3fe 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -629,7 +629,6 @@ static int btrfs_fill_super(struct super_block *sb,
                            void *data, int silent)
 {
        struct inode *inode;
-       struct dentry *root_dentry;
        struct btrfs_fs_info *fs_info = btrfs_sb(sb);
        struct btrfs_key key;
        int err;
@@ -660,15 +659,12 @@ static int btrfs_fill_super(struct super_block *sb,
                goto fail_close;
        }
 
-       root_dentry = d_alloc_root(inode);
-       if (!root_dentry) {
-               iput(inode);
+       sb->s_root = d_make_root(inode);
+       if (!sb->s_root) {
                err = -ENOMEM;
                goto fail_close;
        }
 
-       sb->s_root = root_dentry;
-
        save_mount_options(sb, data);
        cleancache_init_fs(sb);
        sb->s_flags |= MS_ACTIVE;

diff --git a/fs/ceph/super.c b/fs/ceph/super.c
index 00de2c9..256f852 100644 (file)
--- a/fs/ceph/super.c
+++ b/fs/ceph/super.c
@@ -655,9 +655,8 @@ static struct dentry *open_root_dentry(struct ceph_fs_client *fsc,
                dout("open_root_inode success\n");
                if (ceph_ino(inode) == CEPH_INO_ROOT &&
                    fsc->sb->s_root == NULL) {
-                       root = d_alloc_root(inode);
+                       root = d_make_root(inode);
                        if (!root) {
-                               iput(inode);
                                root = ERR_PTR(-ENOMEM);
                                goto out;
                        }

diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 8b7d7ff..418fc42 100644 (file)
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -122,11 +122,9 @@ cifs_read_super(struct super_block *sb)
                goto out_no_root;
        }
 
-       sb->s_root = d_alloc_root(inode);
-
+       sb->s_root = d_make_root(inode);
        if (!sb->s_root) {
                rc = -ENOMEM;
-               iput(inode);
                goto out_no_root;
        }
 

diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index 32dafc8..05156c1 100644 (file)
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -213,9 +213,8 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent)
 
        printk("coda_read_super: rootinode is %ld dev %s\n", 
               root->i_ino, root->i_sb->s_id);
-       sb->s_root = d_alloc_root(root);
+       sb->s_root = d_make_root(root);
        if (!sb->s_root) {
-               iput(root);
                error = -EINVAL;
                goto error;
        }

diff --git a/fs/configfs/mount.c b/fs/configfs/mount.c
index 276e15c..07f6045 100644 (file)
--- a/fs/configfs/mount.c
+++ b/fs/configfs/mount.c
@@ -91,10 +91,9 @@ static int configfs_fill_super(struct super_block *sb, void *data, int silent)
                return -ENOMEM;
        }
 
-       root = d_alloc_root(inode);
+       root = d_make_root(inode);
        if (!root) {
                pr_debug("%s: could not get root dentry!\n",__func__);
-               iput(inode);
                return -ENOMEM;
        }
        config_group_init(&configfs_root_group);

diff --git a/fs/cramfs/inode.c b/fs/cramfs/inode.c
index a2ee8f9..853480d 100644 (file)
--- a/fs/cramfs/inode.c
+++ b/fs/cramfs/inode.c
@@ -318,11 +318,9 @@ static int cramfs_fill_super(struct super_block *sb, void *data, int silent)
        root = get_cramfs_inode(sb, &super.root, 0);
        if (IS_ERR(root))
                goto out;
-       sb->s_root = d_alloc_root(root);
-       if (!sb->s_root) {
-               iput(root);
+       sb->s_root = d_make_root(root);
+       if (!sb->s_root)
                goto out;
-       }
        return 0;
 out:
        kfree(sbi);

diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
index c4e2a58..57dae0b 100644 (file)
--- a/fs/devpts/inode.c
+++ b/fs/devpts/inode.c
@@ -309,12 +309,11 @@ devpts_fill_super(struct super_block *s, void *data, int silent)
        inode->i_fop = &simple_dir_operations;
        set_nlink(inode, 2);
 
-       s->s_root = d_alloc_root(inode);
+       s->s_root = d_make_root(inode);
        if (s->s_root)
                return 0;
 
        printk(KERN_ERR "devpts: get root dentry failed\n");
-       iput(inode);
 
 fail:
        return -ENOMEM;

diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index b4a6bef..6e0e017 100644 (file)
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -550,9 +550,8 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags
        if (IS_ERR(inode))
                goto out_free;
 
-       s->s_root = d_alloc_root(inode);
+       s->s_root = d_make_root(inode);
        if (!s->s_root) {
-               iput(inode);
                rc = -ENOMEM;
                goto out_free;
        }

diff --git a/fs/efs/super.c b/fs/efs/super.c
index 9811064..e755ec7 100644 (file)
--- a/fs/efs/super.c
+++ b/fs/efs/super.c
@@ -317,10 +317,9 @@ static int efs_fill_super(struct super_block *s, void *d, int silent)
                goto out_no_fs;
        }
 
-       s->s_root = d_alloc_root(root);
+       s->s_root = d_make_root(root);
        if (!(s->s_root)) {
                printk(KERN_ERR "EFS: get root dentry failed\n");
-               iput(root);
                ret = -ENOMEM;
                goto out_no_fs;
        }

diff --git a/fs/exofs/super.c b/fs/exofs/super.c
index 6cafcad..7f2b590 100644 (file)
--- a/fs/exofs/super.c
+++ b/fs/exofs/super.c
@@ -819,9 +819,8 @@ static int exofs_fill_super(struct super_block *sb, void *data, int silent)
                ret = PTR_ERR(root);
                goto free_sbi;
        }
-       sb->s_root = d_alloc_root(root);
+       sb->s_root = d_make_root(root);
        if (!sb->s_root) {
-               iput(root);
                EXOFS_ERR("ERROR: get root inode failed\n");
                ret = -ENOMEM;
                goto free_sbi;

diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 9f6766a..e1025c7 100644 (file)
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -1088,9 +1088,8 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
                goto failed_mount3;
        }
 
-       sb->s_root = d_alloc_root(root);
+       sb->s_root = d_make_root(root);
        if (!sb->s_root) {
-               iput(root);
                ext2_msg(sb, KERN_ERR, "error: get root inode failed");
                ret = -ENOMEM;
                goto failed_mount3;

diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 726c7ef..e0b45b9 100644 (file)
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -2046,10 +2046,9 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
                ext3_msg(sb, KERN_ERR, "error: corrupt root inode, run e2fsck");
                goto failed_mount3;
        }
-       sb->s_root = d_alloc_root(root);
+       sb->s_root = d_make_root(root);
        if (!sb->s_root) {
                ext3_msg(sb, KERN_ERR, "error: get root dentry failed");
-               iput(root);
                ret = -ENOMEM;
                goto failed_mount3;
        }

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 502c61f..d2baea7 100644 (file)
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -3735,9 +3735,8 @@ no_journal:
                iput(root);
                goto failed_mount4;
        }
-       sb->s_root = d_alloc_root(root);
+       sb->s_root = d_make_root(root);
        if (!sb->s_root) {
-               iput(root);
                ext4_msg(sb, KERN_ERR, "get root dentry failed");
                ret = -ENOMEM;
                goto failed_mount4;

diff --git a/fs/freevxfs/vxfs_super.c b/fs/freevxfs/vxfs_super.c
index 9d1c995..d4fabd2 100644 (file)
--- a/fs/freevxfs/vxfs_super.c
+++ b/fs/freevxfs/vxfs_super.c
@@ -224,9 +224,8 @@ static int vxfs_fill_super(struct super_block *sbp, void *dp, int silent)
                ret = PTR_ERR(root);
                goto out;
        }
-       sbp->s_root = d_alloc_root(root);
+       sbp->s_root = d_make_root(root);
        if (!sbp->s_root) {
-               iput(root);
                printk(KERN_WARNING "vxfs: unable to get root dentry.\n");
                goto out_free_ilist;
        }

diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 64cf8d0..4aec599 100644 (file)
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -988,14 +988,9 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
 
        err = -ENOMEM;
        root = fuse_get_root_inode(sb, d.rootmode);
-       if (!root)
+       root_dentry = d_make_root(root);
+       if (!root_dentry)
                goto err_put_conn;
-
-       root_dentry = d_alloc_root(root);
-       if (!root_dentry) {
-               iput(root);
-               goto err_put_conn;
-       }
        /* only now - we want root dentry with NULL ->d_op */
        sb->s_d_op = &fuse_dentry_operations;
 

diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index 24f609c..10e848c 100644 (file)
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -431,10 +431,9 @@ static int gfs2_lookup_root(struct super_block *sb, struct dentry **dptr,
                fs_err(sdp, "can't read in %s inode: %ld\n", name, PTR_ERR(inode));
                return PTR_ERR(inode);
        }
-       dentry = d_alloc_root(inode);
+       dentry = d_make_root(inode);
        if (!dentry) {
                fs_err(sdp, "can't alloc %s dentry\n", name);
-               iput(inode);
                return -ENOMEM;
        }
        *dptr = dentry;

diff --git a/fs/hfs/super.c b/fs/hfs/super.c
index 8137fb3..7b4c537 100644 (file)
--- a/fs/hfs/super.c
+++ b/fs/hfs/super.c
@@ -430,15 +430,13 @@ static int hfs_fill_super(struct super_block *sb, void *data, int silent)
 
        sb->s_d_op = &hfs_dentry_operations;
        res = -ENOMEM;
-       sb->s_root = d_alloc_root(root_inode);
+       sb->s_root = d_make_root(root_inode);
        if (!sb->s_root)
-               goto bail_iput;
+               goto bail_no_root;
 
        /* everything's okay */
        return 0;
 
-bail_iput:
-       iput(root_inode);
 bail_no_root:
        printk(KERN_ERR "hfs: get root inode failed.\n");
 bail:

diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index e130bd4..588d458 100644 (file)
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -966,9 +966,9 @@ static int hostfs_fill_sb_common(struct super_block *sb, void *d, int silent)
        }
 
        err = -ENOMEM;
-       sb->s_root = d_alloc_root(root_inode);
+       sb->s_root = d_make_root(root_inode);
        if (sb->s_root == NULL)
-               goto out_put;
+               goto out;
 
        return 0;
 

diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c
index 3690467..54f6ecc 100644 (file)
--- a/fs/hpfs/super.c
+++ b/fs/hpfs/super.c
@@ -625,11 +625,9 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
        hpfs_init_inode(root);
        hpfs_read_inode(root);
        unlock_new_inode(root);
-       s->s_root = d_alloc_root(root);
-       if (!s->s_root) {
-               iput(root);
+       s->s_root = d_make_root(root);
+       if (!s->s_root)
                goto bail0;
-       }
 
        /*
         * find the root directory's . pointer & finish filling in the inode

diff --git a/fs/hppfs/hppfs.c b/fs/hppfs/hppfs.c
index d92f4ce..a80e45a 100644 (file)
--- a/fs/hppfs/hppfs.c
+++ b/fs/hppfs/hppfs.c
@@ -726,17 +726,12 @@ static int hppfs_fill_super(struct super_block *sb, void *d, int silent)
 
        err = -ENOMEM;
        root_inode = get_inode(sb, dget(proc_mnt->mnt_root));
-       if (!root_inode)
-               goto out_mntput;
-
-       sb->s_root = d_alloc_root(root_inode);
+       sb->s_root = d_make_root(root_inode);
        if (!sb->s_root)
-               goto out_iput;
+               goto out_mntput;
 
        return 0;
 
- out_iput:
-       iput(root_inode);
  out_mntput:
        mntput(proc_mnt);
  out:

diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 1e85a7a..81932fa 100644 (file)
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -831,8 +831,6 @@ bad_val:
 static int
 hugetlbfs_fill_super(struct super_block *sb, void *data, int silent)
 {
-       struct inode * inode;
-       struct dentry * root;
        int ret;
        struct hugetlbfs_config config;
        struct hugetlbfs_sb_info *sbinfo;
@@ -865,16 +863,9 @@ hugetlbfs_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_magic = HUGETLBFS_MAGIC;
        sb->s_op = &hugetlbfs_ops;
        sb->s_time_gran = 1;
-       inode = hugetlbfs_get_root(sb, &config);
-       if (!inode)
-               goto out_free;
-
-       root = d_alloc_root(inode);
-       if (!root) {
-               iput(inode);
+       sb->s_root = d_make_root(hugetlbfs_get_root(sb, &config));
+       if (!sb->s_root)
                goto out_free;
-       }
-       sb->s_root = root;
        return 0;
 out_free:
        kfree(sbinfo);

diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index bd62c76..29037c3 100644 (file)
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -947,9 +947,8 @@ root_found:
        s->s_d_op = &isofs_dentry_ops[table];
 
        /* get the root dentry */
-       s->s_root = d_alloc_root(inode);
+       s->s_root = d_make_root(inode);
        if (!(s->s_root)) {
-               iput(inode);
                error = -ENOMEM;
                goto out_no_inode;
        }

diff --git a/fs/jffs2/fs.c b/fs/jffs2/fs.c
index 2e01238..c0d5c9d 100644 (file)
--- a/fs/jffs2/fs.c
+++ b/fs/jffs2/fs.c
@@ -561,9 +561,9 @@ int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
        ret = -ENOMEM;
 
        D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
-       sb->s_root = d_alloc_root(root_i);
+       sb->s_root = d_make_root(root_i);
        if (!sb->s_root)
-               goto out_root_i;
+               goto out_root;
 
        sb->s_maxbytes = 0xFFFFFFFF;
        sb->s_blocksize = PAGE_CACHE_SIZE;
@@ -573,8 +573,6 @@ int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
                jffs2_start_garbage_collect_thread(c);
        return 0;
 
- out_root_i:
-       iput(root_i);
 out_root:
        jffs2_free_ino_caches(c);
        jffs2_free_raw_node_refs(c);

diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index 4661ad7..b3bb955 100644 (file)
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -522,7 +522,7 @@ static int jfs_fill_super(struct super_block *sb, void *data, int silent)
                ret = PTR_ERR(inode);
                goto out_no_rw;
        }
-       sb->s_root = d_alloc_root(inode);
+       sb->s_root = d_make_root(inode);
        if (!sb->s_root)
                goto out_no_root;
 
@@ -540,7 +540,6 @@ static int jfs_fill_super(struct super_block *sb, void *data, int silent)
 
 out_no_root:
        jfs_err("jfs_read_super: get root dentry failed");
-       iput(inode);
 
 out_no_rw:
        rc = jfs_umount(sb);

diff --git a/fs/libfs.c b/fs/libfs.c
index 5b2dbb3..7c895a7 100644 (file)
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -491,11 +491,9 @@ int simple_fill_super(struct super_block *s, unsigned long magic,
        inode->i_op = &simple_dir_inode_operations;
        inode->i_fop = &simple_dir_operations;
        set_nlink(inode, 2);
-       root = d_alloc_root(inode);
-       if (!root) {
-               iput(inode);
+       root = d_make_root(inode);
+       if (!root)
                return -ENOMEM;
-       }
        for (i = 0; !files->name || files->name[0]; i++, files++) {
                if (!files->name)
                        continue;

diff --git a/fs/logfs/super.c b/fs/logfs/super.c
index b1a491a..7de18c3 100644 (file)
--- a/fs/logfs/super.c
+++ b/fs/logfs/super.c
@@ -315,11 +315,9 @@ static int logfs_get_sb_final(struct super_block *sb)
        if (IS_ERR(rootdir))
                goto fail;
 
-       sb->s_root = d_alloc_root(rootdir);
-       if (!sb->s_root) {
-               iput(rootdir);
+       sb->s_root = d_make_root(rootdir);
+       if (!sb->s_root)
                goto fail;
-       }
 
        /* at that point we know that ->put_super() will be called */
        super->s_erase_page = alloc_pages(GFP_KERNEL, 0);

diff --git a/fs/ncpfs/inode.c b/fs/ncpfs/inode.c
index 3d1e34f..49df0e7 100644 (file)
--- a/fs/ncpfs/inode.c
+++ b/fs/ncpfs/inode.c
@@ -716,13 +716,11 @@ static int ncp_fill_super(struct super_block *sb, void *raw_data, int silent)
         if (!root_inode)
                goto out_disconnect;
        DPRINTK("ncp_fill_super: root vol=%d\n", NCP_FINFO(root_inode)->volNumber);
-       sb->s_root = d_alloc_root(root_inode);
+       sb->s_root = d_make_root(root_inode);
         if (!sb->s_root)
-               goto out_no_root;
+               goto out_disconnect;
        return 0;
 
-out_no_root:
-       iput(root_inode);
 out_disconnect:
        ncp_lock_server(server);
        ncp_disconnect(server);

diff --git a/fs/nfs/getroot.c b/fs/nfs/getroot.c
index dcb6154..801d6d8 100644 (file)
--- a/fs/nfs/getroot.c
+++ b/fs/nfs/getroot.c
@@ -49,11 +49,9 @@ static int nfs_superblock_set_dummy_root(struct super_block *sb, struct inode *i
 {
        /* The mntroot acts as the dummy root dentry for this superblock */
        if (sb->s_root == NULL) {
-               sb->s_root = d_alloc_root(inode);
-               if (sb->s_root == NULL) {
-                       iput(inode);
+               sb->s_root = d_make_root(inode);
+               if (sb->s_root == NULL)
                        return -ENOMEM;
-               }
                ihold(inode);
                /*
                 * Ensure that this dentry is invisible to d_find_alias().

diff --git a/fs/nilfs2/super.c b/fs/nilfs2/super.c
index 1fc9ad3..1099a76 100644 (file)
--- a/fs/nilfs2/super.c
+++ b/fs/nilfs2/super.c
@@ -917,9 +917,8 @@ static int nilfs_get_root_dentry(struct super_block *sb,
        if (root->cno == NILFS_CPTREE_CURRENT_CNO) {
                dentry = d_find_alias(inode);
                if (!dentry) {
-                       dentry = d_alloc_root(inode);
+                       dentry = d_make_root(inode);
                        if (!dentry) {
-                               iput(inode);
                                ret = -ENOMEM;
                                goto failed_dentry;
                        }

diff --git a/fs/ocfs2/dlmfs/dlmfs.c b/fs/ocfs2/dlmfs/dlmfs.c
index abfac0d..3b5825e 100644 (file)
--- a/fs/ocfs2/dlmfs/dlmfs.c
+++ b/fs/ocfs2/dlmfs/dlmfs.c
@@ -582,24 +582,14 @@ static int dlmfs_fill_super(struct super_block * sb,
                            void * data,
                            int silent)
 {
-       struct inode * inode;
-       struct dentry * root;
-
        sb->s_maxbytes = MAX_LFS_FILESIZE;
        sb->s_blocksize = PAGE_CACHE_SIZE;
        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
        sb->s_magic = DLMFS_MAGIC;
        sb->s_op = &dlmfs_ops;
-       inode = dlmfs_get_root_inode(sb);
-       if (!inode)
-               return -ENOMEM;
-
-       root = d_alloc_root(inode);
-       if (!root) {
-               iput(inode);
+       sb->s_root = d_make_root(dlmfs_get_root_inode(sb));
+       if (!sb->s_root)
                return -ENOMEM;
-       }
-       sb->s_root = root;
        return 0;
 }
 

diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index 2b1184f..337687c 100644 (file)
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -1166,9 +1166,8 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
                goto read_super_error;
        }
 
-       root = d_alloc_root(inode);
+       root = d_make_root(inode);
        if (!root) {
-               iput(inode);
                status = -ENOMEM;
                mlog_errno(status);
                goto read_super_error;

diff --git a/fs/omfs/inode.c b/fs/omfs/inode.c
index 6065bb0..dbc8422 100644 (file)
--- a/fs/omfs/inode.c
+++ b/fs/omfs/inode.c
@@ -539,11 +539,9 @@ static int omfs_fill_super(struct super_block *sb, void *data, int silent)
                goto out_brelse_bh2;
        }
 
-       sb->s_root = d_alloc_root(root);
-       if (!sb->s_root) {
-               iput(root);
+       sb->s_root = d_make_root(root);
+       if (!sb->s_root)
                goto out_brelse_bh2;
-       }
        printk(KERN_DEBUG "omfs: Mounted volume %s\n", omfs_rb->r_name);
 
        ret = 0;

diff --git a/fs/openpromfs/inode.c b/fs/openpromfs/inode.c
index a88c03b..bc49c97 100644 (file)
--- a/fs/openpromfs/inode.c
+++ b/fs/openpromfs/inode.c
@@ -408,13 +408,12 @@ static int openprom_fill_super(struct super_block *s, void *data, int silent)
        oi->type = op_inode_node;
        oi->u.node = of_find_node_by_path("/");
 
-       s->s_root = d_alloc_root(root_inode);
+       s->s_root = d_make_root(root_inode);
        if (!s->s_root)
                goto out_no_root_dentry;
        return 0;
 
 out_no_root_dentry:
-       iput(root_inode);
        ret = -ENOMEM;
 out_no_root:
        printk("openprom_fill_super: get root inode failed\n");

diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index a70af3a..8461a7b 100644 (file)
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -486,8 +486,6 @@ struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de)
 
 int proc_fill_super(struct super_block *s)
 {
-       struct inode * root_inode;
-
        s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
        s->s_blocksize = 1024;
        s->s_blocksize_bits = 10;
@@ -496,17 +494,10 @@ int proc_fill_super(struct super_block *s)
        s->s_time_gran = 1;
        
        pde_get(&proc_root);
-       root_inode = proc_get_inode(s, &proc_root);
-       if (!root_inode)
-               goto out_no_root;
-       s->s_root = d_alloc_root(root_inode);
-       if (!s->s_root) {
-               iput(root_inode);
-               goto out_no_root;
-       }
-       return 0;
+       s->s_root = d_make_root(proc_get_inode(s, &proc_root));
+       if (s->s_root)
+               return 0;
 
-out_no_root:
        printk("proc_read_super: get root inode failed\n");
        pde_put(&proc_root);
        return -ENOMEM;

diff --git a/fs/pstore/inode.c b/fs/pstore/inode.c
index b3b426e..ec7d1fb 100644 (file)
--- a/fs/pstore/inode.c
+++ b/fs/pstore/inode.c
@@ -303,7 +303,7 @@ int pstore_fill_super(struct super_block *sb, void *data, int silent)
        /* override ramfs "dir" options so we catch unlink(2) */
        inode->i_op = &pstore_dir_inode_operations;
 
-       root = d_alloc_root(inode);
+       root = d_make_root(inode);
        sb->s_root = root;
        if (!root) {
                err = -ENOMEM;
@@ -314,7 +314,6 @@ int pstore_fill_super(struct super_block *sb, void *data, int silent)
 
        return 0;
 fail:
-       iput(inode);
        return err;
 }
 

diff --git a/fs/qnx4/inode.c b/fs/qnx4/inode.c
index 6b00954..db18d86 100644 (file)
--- a/fs/qnx4/inode.c
+++ b/fs/qnx4/inode.c
@@ -260,15 +260,13 @@ static int qnx4_fill_super(struct super_block *s, void *data, int silent)
        }
 
        ret = -ENOMEM;
-       s->s_root = d_alloc_root(root);
+       s->s_root = d_make_root(root);
        if (s->s_root == NULL)
-               goto outi;
+               goto outb;
 
        brelse(bh);
        return 0;
 
-      outi:
-       iput(root);
       outb:
        kfree(qs->BitMap);
       out:

diff --git a/fs/ramfs/inode.c b/fs/ramfs/inode.c
index aec766a..b6612d2 100644 (file)
--- a/fs/ramfs/inode.c
+++ b/fs/ramfs/inode.c
@@ -210,7 +210,6 @@ int ramfs_fill_super(struct super_block *sb, void *data, int silent)
 {
        struct ramfs_fs_info *fsi;
        struct inode *inode = NULL;
-       struct dentry *root;
        int err;
 
        save_mount_options(sb, data);
@@ -234,14 +233,8 @@ int ramfs_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_time_gran         = 1;
 
        inode = ramfs_get_inode(sb, NULL, S_IFDIR | fsi->mount_opts.mode, 0);
-       if (!inode) {
-               err = -ENOMEM;
-               goto fail;
-       }
-
-       root = d_alloc_root(inode);
-       sb->s_root = root;
-       if (!root) {
+       sb->s_root = d_make_root(inode);
+       if (!sb->s_root) {
                err = -ENOMEM;
                goto fail;
        }
@@ -250,7 +243,6 @@ int ramfs_fill_super(struct super_block *sb, void *data, int silent)
 fail:
        kfree(fsi);
        sb->s_fs_info = NULL;
-       iput(inode);
        return err;
 }
 

diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index e12d8b9..208dfd1 100644 (file)
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -1874,11 +1874,9 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
                unlock_new_inode(root_inode);
        }
 
-       s->s_root = d_alloc_root(root_inode);
-       if (!s->s_root) {
-               iput(root_inode);
+       s->s_root = d_make_root(root_inode);
+       if (!s->s_root)
                goto error;
-       }
        // define and initialize hash function
        sbi->s_hash_function = hash_function(s);
        if (sbi->s_hash_function == NULL) {

diff --git a/fs/romfs/super.c b/fs/romfs/super.c
index bb36ab7..e64f6b5 100644 (file)
--- a/fs/romfs/super.c
+++ b/fs/romfs/super.c
@@ -538,14 +538,12 @@ static int romfs_fill_super(struct super_block *sb, void *data, int silent)
        if (IS_ERR(root))
                goto error;
 
-       sb->s_root = d_alloc_root(root);
+       sb->s_root = d_make_root(root);
        if (!sb->s_root)
-               goto error_i;
+               goto error;
 
        return 0;
 
-error_i:
-       iput(root);
 error:
        return -EINVAL;
 error_rsb_inval:

diff --git a/fs/squashfs/super.c b/fs/squashfs/super.c
index ecaa2f7..970b116 100644 (file)
--- a/fs/squashfs/super.c
+++ b/fs/squashfs/super.c
@@ -316,11 +316,10 @@ check_directory_table:
        }
        insert_inode_hash(root);
 
-       sb->s_root = d_alloc_root(root);
+       sb->s_root = d_make_root(root);
        if (sb->s_root == NULL) {
                ERROR("Root inode create failed\n");
                err = -ENOMEM;
-               iput(root);
                goto failed_mount;
        }
 

diff --git a/fs/sysfs/mount.c b/fs/sysfs/mount.c
index e34f0d9..2243f8e 100644 (file)
--- a/fs/sysfs/mount.c
+++ b/fs/sysfs/mount.c
@@ -61,10 +61,9 @@ static int sysfs_fill_super(struct super_block *sb, void *data, int silent)
        }
 
        /* instantiate and link root dentry */
-       root = d_alloc_root(inode);
+       root = d_make_root(inode);
        if (!root) {
                pr_debug("%s: could not get root dentry!\n",__func__);
-               iput(inode);
                return -ENOMEM;
        }
        root->d_fsdata = &sysfs_root;

diff --git a/fs/sysv/super.c b/fs/sysv/super.c
index f467740..7491c33 100644 (file)
--- a/fs/sysv/super.c
+++ b/fs/sysv/super.c
@@ -341,9 +341,8 @@ static int complete_read_super(struct super_block *sb, int silent, int size)
                printk("SysV FS: get root inode failed\n");
                return 0;
        }
-       sb->s_root = d_alloc_root(root_inode);
+       sb->s_root = d_make_root(root_inode);
        if (!sb->s_root) {
-               iput(root_inode);
                printk("SysV FS: get root dentry failed\n");
                return 0;
        }

diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
index 63765d5..76e4e05 100644 (file)
--- a/fs/ubifs/super.c
+++ b/fs/ubifs/super.c
@@ -2076,15 +2076,13 @@ static int ubifs_fill_super(struct super_block *sb, void *data, int silent)
                goto out_umount;
        }
 
-       sb->s_root = d_alloc_root(root);
+       sb->s_root = d_make_root(root);
        if (!sb->s_root)
-               goto out_iput;
+               goto out_umount;
 
        mutex_unlock(&c->umount_mutex);
        return 0;
 
-out_iput:
-       iput(root);
 out_umount:
        ubifs_umount(c);
 out_unlock:

diff --git a/fs/udf/super.c b/fs/udf/super.c
index 8d8b253..85067b4 100644 (file)
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -2037,10 +2037,9 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
        }
 
        /* Allocate a dentry for the root inode */
-       sb->s_root = d_alloc_root(inode);
+       sb->s_root = d_make_root(inode);
        if (!sb->s_root) {
                udf_err(sb, "Couldn't allocate root dentry\n");
-               iput(inode);
                goto error_out;
        }
        sb->s_maxbytes = MAX_LFS_FILESIZE;

diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index ec25d09..f636f6b 100644 (file)
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -1164,10 +1164,10 @@ magic_found:
                ret = PTR_ERR(inode);
                goto failed;
        }
-       sb->s_root = d_alloc_root(inode);
+       sb->s_root = d_make_root(inode);
        if (!sb->s_root) {
                ret = -ENOMEM;
-               goto dalloc_failed;
+               goto failed;
        }
 
        ufs_setup_cstotal(sb);
@@ -1181,8 +1181,6 @@ magic_found:
        UFSD("EXIT\n");
        return 0;
 
-dalloc_failed:
-       iput(inode);
 failed:
        if (ubh)
                ubh_brelse_uspi (uspi);

diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 0e4c5c0..baf40e3 100644 (file)
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -1362,10 +1362,10 @@ xfs_fs_fill_super(
                error = EINVAL;
                goto out_syncd_stop;
        }
-       sb->s_root = d_alloc_root(root);
+       sb->s_root = d_make_root(root);
        if (!sb->s_root) {
                error = ENOMEM;
-               goto out_iput;
+               goto out_syncd_stop;
        }
 
        return 0;
@@ -1384,8 +1384,6 @@ xfs_fs_fill_super(
  out:
        return -error;
 
- out_iput:
-       iput(root);
  out_syncd_stop:
        xfs_syncd_stop(mp);
  out_unmount:

diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index 86ee272..28bd64d 100644 (file)
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -188,30 +188,20 @@ static int mqueue_fill_super(struct super_block *sb, void *data, int silent)
 {
        struct inode *inode;
        struct ipc_namespace *ns = data;
-       int error;
 
        sb->s_blocksize = PAGE_CACHE_SIZE;
        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
        sb->s_magic = MQUEUE_MAGIC;
        sb->s_op = &mqueue_super_ops;
 
-       inode = mqueue_get_inode(sb, ns, S_IFDIR | S_ISVTX | S_IRWXUGO,
-                               NULL);
-       if (IS_ERR(inode)) {
-               error = PTR_ERR(inode);
-               goto out;
-       }
+       inode = mqueue_get_inode(sb, ns, S_IFDIR | S_ISVTX | S_IRWXUGO, NULL);
+       if (IS_ERR(inode))
+               return PTR_ERR(inode);
 
-       sb->s_root = d_alloc_root(inode);
-       if (!sb->s_root) {
-               iput(inode);
-               error = -ENOMEM;
-               goto out;
-       }
-       error = 0;
-
-out:
-       return error;
+       sb->s_root = d_make_root(inode);
+       if (!sb->s_root)
+               return -ENOMEM;
+       return 0;
 }
 
 static struct dentry *mqueue_mount(struct file_system_type *fs_type,

diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index a5d3b53..711c1a3 100644 (file)
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -1472,7 +1472,6 @@ static int cgroup_get_rootdir(struct super_block *sb)
 
        struct inode *inode =
                cgroup_new_inode(S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR, sb);
-       struct dentry *dentry;
 
        if (!inode)
                return -ENOMEM;
@@ -1481,12 +1480,9 @@ static int cgroup_get_rootdir(struct super_block *sb)
        inode->i_op = &cgroup_dir_inode_operations;
        /* directories start off with i_nlink == 2 (for "." entry) */
        inc_nlink(inode);
-       dentry = d_alloc_root(inode);
-       if (!dentry) {
-               iput(inode);
+       sb->s_root = d_make_root(inode);
+       if (!sb->s_root)
                return -ENOMEM;
-       }
-       sb->s_root = dentry;
        /* for everything else we want ->d_op set */
        sb->s_d_op = &cgroup_dops;
        return 0;

diff --git a/mm/shmem.c b/mm/shmem.c
index 269d049..154243f 100644 (file)
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -2232,14 +2232,12 @@ int shmem_fill_super(struct super_block *sb, void *data, int silent)
                goto failed;
        inode->i_uid = sbinfo->uid;
        inode->i_gid = sbinfo->gid;
-       root = d_alloc_root(inode);
+       root = d_make_root(inode);
        if (!root)
-               goto failed_iput;
+               goto failed;
        sb->s_root = root;
        return 0;
 
-failed_iput:
-       iput(inode);
 failed:
        shmem_put_super(sb);
        return err;

diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index 63a7a7a..7d6dd6e 100644 (file)
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -1033,13 +1033,9 @@ rpc_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_time_gran = 1;
 
        inode = rpc_get_inode(sb, S_IFDIR | 0755);
-       if (!inode)
-               return -ENOMEM;
-       sb->s_root = root = d_alloc_root(inode);
-       if (!root) {
-               iput(inode);
+       sb->s_root = root = d_make_root(inode);
+       if (!root)
                return -ENOMEM;
-       }
        if (rpc_populate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF, NULL))
                return -ENOMEM;
        return 0;