101 files changed, 1190 insertions, 790 deletions
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 5c5137c11484..6a28842052ea 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -573,7 +573,7 @@ static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
        v9ses = v9fs_inode2v9ses(dir);
        dfid = v9fs_fid_lookup(dentry->d_parent);
        if (IS_ERR(dfid))
-                return ERR_PTR(PTR_ERR(dfid));
+                return ERR_CAST(dfid);
        name = (char *) dentry->d_name.name;
        fid = p9_client_walk(dfid, 1, &name, 1);
diff --git a/fs/Kconfig b/fs/Kconfig
index ea5b35947623..3bf6ace1720c 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -463,40 +463,18 @@ config OCFS2_DEBUG_FS
          this option for debugging only as it is likely to decrease
          performance of the filesystem.
-config MINIX_FS
+endif # BLOCK
-        tristate "Minix fs support"
-        help
-          Minix is a simple operating system used in many classes about OS's.
-          The minix file system (method to organize files on a hard disk
-          partition or a floppy disk) was the original file system for Linux,
-          but has been superseded by the second extended file system ext2fs.
-          You don't want to use the minix file system on your hard disk
-          because of certain built-in restrictions, but it is sometimes found
-          on older Linux floppy disks.  This option will enlarge your kernel
-          by about 28 KB. If unsure, say N.
-          To compile this file system support as a module, choose M here: the
-          module will be called minix.  Note that the file system of your root
-          partition (the one containing the directory /) cannot be compiled as
-          a module.
-config ROMFS_FS
-        tristate "ROM file system support"
-        ---help---
-          This is a very small read-only file system mainly intended for
-          initial ram disks of installation disks, but it could be used for
-          other read-only media as well.  Read
-          <file:Documentation/filesystems/romfs.txt> for details.
-          To compile this file system support as a module, choose M here: the
-          module will be called romfs.  Note that the file system of your
-          root partition (the one containing the directory /) cannot be a
-          module.
-          If you don't know whether you need it, then you don't need it:
+config DNOTIFY
-          answer N.
+        bool "Dnotify support"
+        default y
+        help
+          Dnotify is a directory-based per-fd file change notification system
+          that uses signals to communicate events to user-space.  There exist
+          superior alternatives, but some applications may still rely on
+          dnotify.
-endif
+          If unsure, say Y.
 config INOTIFY
        bool "Inotify file change notification support"
@@ -577,17 +555,6 @@ config QUOTACTL
        depends on XFS_QUOTA || QUOTA
        default y
-config DNOTIFY
-        bool "Dnotify support"
-        default y
-        help
-          Dnotify is a directory-based per-fd file change notification system
-          that uses signals to communicate events to user-space.  There exist
-          superior alternatives, but some applications may still rely on
-          dnotify.
-          If unsure, say Y.
 config AUTOFS_FS
        tristate "Kernel automounter support"
        help
@@ -713,7 +680,7 @@ config UDF_NLS
        depends on (UDF_FS=m && NLS) || (UDF_FS=y && NLS=y)
 endmenu
-endif
+endif # BLOCK
 if BLOCK
 menu "DOS/FAT/NT Filesystems"
@@ -896,7 +863,7 @@ config NTFS_RW
          It is perfectly safe to say N here.
 endmenu
-endif
+endif # BLOCK
 menu "Pseudo filesystems"
@@ -1417,6 +1384,24 @@ config VXFS_FS
          To compile this as a module, choose M here: the module will be
          called freevxfs.  If unsure, say N.
+config MINIX_FS
+        tristate "Minix file system support"
+        depends on BLOCK
+        help
+          Minix is a simple operating system used in many classes about OS's.
+          The minix file system (method to organize files on a hard disk
+          partition or a floppy disk) was the original file system for Linux,
+          but has been superseded by the second extended file system ext2fs.
+          You don't want to use the minix file system on your hard disk
+          because of certain built-in restrictions, but it is sometimes found
+          on older Linux floppy disks.  This option will enlarge your kernel
+          by about 28 KB. If unsure, say N.
+          To compile this file system support as a module, choose M here: the
+          module will be called minix.  Note that the file system of your root
+          partition (the one containing the directory /) cannot be compiled as
+          a module.
 config HPFS_FS
        tristate "OS/2 HPFS file system support"
@@ -1434,7 +1419,6 @@ config HPFS_FS
          module will be called hpfs.  If unsure, say N.
 config QNX4FS_FS
        tristate "QNX4 file system support (read only)"
        depends on BLOCK
@@ -1461,6 +1445,22 @@ config QNX4FS_RW
          It's currently broken, so for now:
          answer N.
+config ROMFS_FS
+        tristate "ROM file system support"
+        depends on BLOCK
+        ---help---
+          This is a very small read-only file system mainly intended for
+          initial ram disks of installation disks, but it could be used for
+          other read-only media as well.  Read
+          <file:Documentation/filesystems/romfs.txt> for details.
+          To compile this file system support as a module, choose M here: the
+          module will be called romfs.  Note that the file system of your
+          root partition (the one containing the directory /) cannot be a
+          module.
+          If you don't know whether you need it, then you don't need it:
+          answer N.
 config SYSV_FS
@@ -1501,7 +1501,6 @@ config SYSV_FS
          If you haven't heard about all of this before, it's safe to say N.
 config UFS_FS
        tristate "UFS file system support (read only)"
        depends on BLOCK
diff --git a/fs/affs/affs.h b/fs/affs/affs.h
index 232c69493683..d5bd497ab9cb 100644
--- a/fs/affs/affs.h
+++ b/fs/affs/affs.h
@@ -174,7 +174,8 @@ extern void			 affs_put_inode(struct inode *inode);
 extern void                      affs_drop_inode(struct inode *inode);
 extern void                      affs_delete_inode(struct inode *inode);
 extern void                      affs_clear_inode(struct inode *inode);
-extern void                      affs_read_inode(struct inode *inode);
+extern struct inode             *affs_iget(struct super_block *sb,
+                                        unsigned long ino);
 extern int                       affs_write_inode(struct inode *inode, int);
 extern int                       affs_add_entry(struct inode *dir, struct inode *inode, struct dentry *dentry, s32 type);
diff --git a/fs/affs/amigaffs.c b/fs/affs/amigaffs.c
index f4de4b98004f..805573005de6 100644
--- a/fs/affs/amigaffs.c
+++ b/fs/affs/amigaffs.c
@@ -170,9 +170,11 @@ affs_remove_link(struct dentry *dentry)
                if (!link_bh)
                        goto done;
-                dir = iget(sb, be32_to_cpu(AFFS_TAIL(sb, link_bh)->parent));
+                dir = affs_iget(sb, be32_to_cpu(AFFS_TAIL(sb, link_bh)->parent));
-                if (!dir)
+                if (IS_ERR(dir)) {
+                        retval = PTR_ERR(dir);
                        goto done;
+                }
                affs_lock_dir(dir);
                affs_fix_dcache(dentry, link_ino);
diff --git a/fs/affs/inode.c b/fs/affs/inode.c
index 4609a6c13fe9..27fe6cbe43ae 100644
--- a/fs/affs/inode.c
+++ b/fs/affs/inode.c
@@ -15,20 +15,25 @@
 extern const struct inode_operations affs_symlink_inode_operations;
 extern struct timezone sys_tz;
-void
+struct inode *affs_iget(struct super_block *sb, unsigned long ino)
-affs_read_inode(struct inode *inode)
 {
-        struct super_block      *sb = inode->i_sb;
        struct affs_sb_info     *sbi = AFFS_SB(sb);
        struct buffer_head      *bh;
        struct affs_head        *head;
        struct affs_tail        *tail;
+        struct inode            *inode;
        u32                      block;
        u32                      size;
        u32                      prot;
        u16                      id;
-        pr_debug("AFFS: read_inode(%lu)\n",inode->i_ino);
+        inode = iget_locked(sb, ino);
+        if (!inode)
+                return ERR_PTR(-ENOMEM);
+        if (!(inode->i_state & I_NEW))
+                return inode;
+        pr_debug("AFFS: affs_iget(%lu)\n", inode->i_ino);
        block = inode->i_ino;
        bh = affs_bread(sb, block);
@@ -154,12 +159,13 @@ affs_read_inode(struct inode *inode)
                         sys_tz.tz_minuteswest * 60;
        inode->i_mtime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_atime.tv_nsec = 0;
        affs_brelse(bh);
-        return;
+        unlock_new_inode(inode);
+        return inode;
 bad_inode:
-        make_bad_inode(inode);
        affs_brelse(bh);
-        return;
+        iget_failed(inode);
+        return ERR_PTR(-EIO);
 }
 int
diff --git a/fs/affs/namei.c b/fs/affs/namei.c
index a42143ca0169..2218f1ee71ce 100644
--- a/fs/affs/namei.c
+++ b/fs/affs/namei.c
@@ -208,9 +208,8 @@ affs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
        affs_lock_dir(dir);
        bh = affs_find_entry(dir, dentry);
        affs_unlock_dir(dir);
-        if (IS_ERR(bh)) {
+        if (IS_ERR(bh))
-                return ERR_PTR(PTR_ERR(bh));
+                return ERR_CAST(bh);
-        }
        if (bh) {
                u32 ino = bh->b_blocknr;
@@ -223,10 +222,9 @@ affs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
                        ino = be32_to_cpu(AFFS_TAIL(sb, bh)->original);
                }
                affs_brelse(bh);
-                inode = iget(sb, ino);
+                inode = affs_iget(sb, ino);
-                if (!inode) {
+                if (IS_ERR(inode))
-                        return ERR_PTR(-EACCES);
+                        return ERR_PTR(PTR_ERR(inode));
-                }
        }
        dentry->d_op = AFFS_SB(sb)->s_flags & SF_INTL ? &affs_intl_dentry_operations : &affs_dentry_operations;
        d_add(dentry, inode);
diff --git a/fs/affs/super.c b/fs/affs/super.c
index b53e5d0ec65c..3c45d49c0d26 100644
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -113,7 +113,6 @@ static void destroy_inodecache(void)
 static const struct super_operations affs_sops = {
        .alloc_inode    = affs_alloc_inode,
        .destroy_inode  = affs_destroy_inode,
-        .read_inode     = affs_read_inode,
        .write_inode    = affs_write_inode,
        .put_inode      = affs_put_inode,
        .drop_inode     = affs_drop_inode,
@@ -271,6 +270,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
        unsigned long            mount_flags;
        int                      tmp_flags;     /* fix remount prototype... */
        u8                       sig[4];
+        int                      ret = -EINVAL;
        pr_debug("AFFS: read_super(%s)\n",data ? (const char *)data : "no options");
@@ -444,7 +444,12 @@ got_root:
        /* set up enough so that it can read an inode */
-        root_inode = iget(sb, root_block);
+        root_inode = affs_iget(sb, root_block);
+        if (IS_ERR(root_inode)) {
+                ret = PTR_ERR(root_inode);
+                goto out_error_noinode;
+        }
        sb->s_root = d_alloc_root(root_inode);
        if (!sb->s_root) {
                printk(KERN_ERR "AFFS: Get root inode failed\n");
@@ -461,12 +466,13 @@ got_root:
 out_error:
        if (root_inode)
                iput(root_inode);
+out_error_noinode:
        kfree(sbi->s_bitmap);
        affs_brelse(root_bh);
        kfree(sbi->s_prefix);
        kfree(sbi);
        sb->s_fs_info = NULL;
-        return -EINVAL;
+        return ret;
 }
 static int
diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index 0cc3597c1197..b58af8f18bc4 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -512,7 +512,7 @@ static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
        key = afs_request_key(vnode->volume->cell);
        if (IS_ERR(key)) {
                _leave(" = %ld [key]", PTR_ERR(key));
-                return ERR_PTR(PTR_ERR(key));
+                return ERR_CAST(key);
        }
        ret = afs_validate(vnode, key);
@@ -540,7 +540,7 @@ static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
        key_put(key);
        if (IS_ERR(inode)) {
                _leave(" = %ld", PTR_ERR(inode));
-                return ERR_PTR(PTR_ERR(inode));
+                return ERR_CAST(inode);
        }
        dentry->d_op = &afs_fs_dentry_operations;
diff --git a/fs/afs/inode.c b/fs/afs/inode.c
index 84750c8e9f95..08db82e1343a 100644
--- a/fs/afs/inode.c
+++ b/fs/afs/inode.c
@@ -196,10 +196,7 @@ struct inode *afs_iget(struct super_block *sb, struct key *key,
        /* failure */
 bad_inode:
-        make_bad_inode(inode);
+        iget_failed(inode);
-        unlock_new_inode(inode);
-        iput(inode);
        _leave(" = %d [bad]", ret);
        return ERR_PTR(ret);
 }
diff --git a/fs/afs/security.c b/fs/afs/security.c
index 566fe712c682..9446a1fd108a 100644
--- a/fs/afs/security.c
+++ b/fs/afs/security.c
@@ -95,7 +95,7 @@ static struct afs_vnode *afs_get_auth_inode(struct afs_vnode *vnode,
                auth_inode = afs_iget(vnode->vfs_inode.i_sb, key,
                                      &vnode->status.parent, NULL, NULL);
                if (IS_ERR(auth_inode))
-                        return ERR_PTR(PTR_ERR(auth_inode));
+                        return ERR_CAST(auth_inode);
        }
        auth_vnode = AFS_FS_I(auth_inode);
diff --git a/fs/autofs/autofs_i.h b/fs/autofs/autofs_i.h
index 8b4cca3c4705..901a3e67ec45 100644
--- a/fs/autofs/autofs_i.h
+++ b/fs/autofs/autofs_i.h
@@ -150,6 +150,7 @@ extern const struct file_operations autofs_root_operations;
 int autofs_fill_super(struct super_block *, void *, int);
 void autofs_kill_sb(struct super_block *sb);
+struct inode *autofs_iget(struct super_block *, unsigned long);
 /* Queue management functions */
diff --git a/fs/autofs/inode.c b/fs/autofs/inode.c
index 45f5992a0957..708bdb89fea1 100644
--- a/fs/autofs/inode.c
+++ b/fs/autofs/inode.c
@@ -52,10 +52,7 @@ out_kill_sb:
        kill_anon_super(sb);
 }
-static void autofs_read_inode(struct inode *inode);
 static const struct super_operations autofs_sops = {
-        .read_inode     = autofs_read_inode,
        .statfs         = simple_statfs,
 };
@@ -164,7 +161,9 @@ int autofs_fill_super(struct super_block *s, void *data, int silent)
        s->s_time_gran = 1;
        sbi->sb = s;
-        root_inode = iget(s, AUTOFS_ROOT_INO);
+        root_inode = autofs_iget(s, AUTOFS_ROOT_INO);
+        if (IS_ERR(root_inode))
+                goto fail_free;
        root = d_alloc_root(root_inode);
        pipe = NULL;
@@ -230,11 +229,17 @@ fail_unlock:
        return -EINVAL;
 }
-static void autofs_read_inode(struct inode *inode)
+struct inode *autofs_iget(struct super_block *sb, unsigned long ino)
 {
-        ino_t ino = inode->i_ino;
        unsigned int n;
-        struct autofs_sb_info *sbi = autofs_sbi(inode->i_sb);
+        struct autofs_sb_info *sbi = autofs_sbi(sb);
+        struct inode *inode;
+        inode = iget_locked(sb, ino);
+        if (!inode)
+                return ERR_PTR(-ENOMEM);
+        if (!(inode->i_state & I_NEW))
+                return inode;
        /* Initialize to the default case (stub directory) */
@@ -250,7 +255,7 @@ static void autofs_read_inode(struct inode *inode)
                inode->i_op = &autofs_root_inode_operations;
                inode->i_fop = &autofs_root_operations;
                inode->i_uid = inode->i_gid = 0; /* Changed in read_super */
-                return;
+                goto done;
        } 
        
        inode->i_uid = inode->i_sb->s_root->d_inode->i_uid;
@@ -263,7 +268,7 @@ static void autofs_read_inode(struct inode *inode)
                n = ino - AUTOFS_FIRST_SYMLINK;
                if (n >= AUTOFS_MAX_SYMLINKS || !test_bit(n,sbi->symlink_bitmap)) {
                        printk("autofs: Looking for bad symlink inode %u\n", (unsigned int) ino);
-                        return;
+                        goto done;
                }
                
                inode->i_op = &autofs_symlink_inode_operations;
@@ -275,4 +280,8 @@ static void autofs_read_inode(struct inode *inode)
                inode->i_size = sl->len;
                inode->i_nlink = 1;
        }
+done:
+        unlock_new_inode(inode);
+        return inode;
 }
diff --git a/fs/autofs/root.c b/fs/autofs/root.c
index 5efff3c0d886..8aacade56956 100644
--- a/fs/autofs/root.c
+++ b/fs/autofs/root.c
@@ -114,8 +114,8 @@ static int try_to_fill_dentry(struct dentry *dentry, struct super_block *sb, str
        dentry->d_time = (unsigned long) ent;
        
        if (!dentry->d_inode) {
-                inode = iget(sb, ent->ino);
+                inode = autofs_iget(sb, ent->ino);
-                if (!inode) {
+                if (IS_ERR(inode)) {
                        /* Failed, but leave pending for next time */
                        return 1;
                }
@@ -274,6 +274,7 @@ static int autofs_root_symlink(struct inode *dir, struct dentry *dentry, const c
        unsigned int n;
        int slsize;
        struct autofs_symlink *sl;
+        struct inode *inode;
        DPRINTK(("autofs_root_symlink: %s <- ", symname));
        autofs_say(dentry->d_name.name,dentry->d_name.len);
@@ -331,7 +332,12 @@ static int autofs_root_symlink(struct inode *dir, struct dentry *dentry, const c
        ent->dentry = NULL;     /* We don't keep the dentry for symlinks */
        autofs_hash_insert(dh,ent);
-        d_instantiate(dentry, iget(dir->i_sb,ent->ino));
+        inode = autofs_iget(dir->i_sb, ent->ino);
+        if (IS_ERR(inode))
+                return PTR_ERR(inode);
+        d_instantiate(dentry, inode);
        unlock_kernel();
        return 0;
 }
@@ -428,6 +434,7 @@ static int autofs_root_mkdir(struct inode *dir, struct dentry *dentry, int mode)
        struct autofs_sb_info *sbi = autofs_sbi(dir->i_sb);
        struct autofs_dirhash *dh = &sbi->dirhash;
        struct autofs_dir_ent *ent;
+        struct inode *inode;
        ino_t ino;
        lock_kernel();
@@ -469,7 +476,14 @@ static int autofs_root_mkdir(struct inode *dir, struct dentry *dentry, int mode)
        autofs_hash_insert(dh,ent);
        inc_nlink(dir);
-        d_instantiate(dentry, iget(dir->i_sb,ino));
+        inode = autofs_iget(dir->i_sb, ino);
+        if (IS_ERR(inode)) {
+                drop_nlink(dir);
+                return PTR_ERR(inode);
+        }
+        d_instantiate(dentry, inode);
        unlock_kernel();
        return 0;
diff --git a/fs/bad_inode.c b/fs/bad_inode.c
index 521ff7caadbd..f1c2ea8342f5 100644
--- a/fs/bad_inode.c
+++ b/fs/bad_inode.c
@@ -359,3 +359,17 @@ int is_bad_inode(struct inode *inode)
 }
 EXPORT_SYMBOL(is_bad_inode);
+/**
+ * iget_failed - Mark an under-construction inode as dead and release it
+ * @inode: The inode to discard
+ *
+ * Mark an under-construction inode as dead and release it.
+ */
+void iget_failed(struct inode *inode)
+{
+        make_bad_inode(inode);
+        unlock_new_inode(inode);
+        iput(inode);
+}
+EXPORT_SYMBOL(iget_failed);
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index b28a20e61b80..403fe661c144 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -35,7 +35,7 @@ static int befs_get_block(struct inode *, sector_t, struct buffer_head *, int);
 static int befs_readpage(struct file *file, struct page *page);
 static sector_t befs_bmap(struct address_space *mapping, sector_t block);
 static struct dentry *befs_lookup(struct inode *, struct dentry *, struct nameidata *);
-static void befs_read_inode(struct inode *ino);
+static struct inode *befs_iget(struct super_block *, unsigned long);
 static struct inode *befs_alloc_inode(struct super_block *sb);
 static void befs_destroy_inode(struct inode *inode);
 static int befs_init_inodecache(void);
@@ -52,7 +52,6 @@ static int befs_statfs(struct dentry *, struct kstatfs *);
 static int parse_options(char *, befs_mount_options *);
 static const struct super_operations befs_sops = {
-        .read_inode     = befs_read_inode,      /* initialize & read inode */
        .alloc_inode    = befs_alloc_inode,     /* allocate a new inode */
        .destroy_inode  = befs_destroy_inode, /* deallocate an inode */
        .put_super      = befs_put_super,       /* uninit super */
@@ -198,9 +197,9 @@ befs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
                return ERR_PTR(-ENODATA);
        }
-        inode = iget(dir->i_sb, (ino_t) offset);
+        inode = befs_iget(dir->i_sb, (ino_t) offset);
-        if (!inode)
+        if (IS_ERR(inode))
-                return ERR_PTR(-EACCES);
+                return ERR_CAST(inode);
        d_add(dentry, inode);
@@ -296,17 +295,23 @@ static void init_once(struct kmem_cache *cachep, void *foo)
        inode_init_once(&bi->vfs_inode);
 }
-static void
+static struct inode *befs_iget(struct super_block *sb, unsigned long ino)
-befs_read_inode(struct inode *inode)
 {
        struct buffer_head *bh = NULL;
        befs_inode *raw_inode = NULL;
-        struct super_block *sb = inode->i_sb;
        befs_sb_info *befs_sb = BEFS_SB(sb);
        befs_inode_info *befs_ino = NULL;
+        struct inode *inode;
+        long ret = -EIO;
-        befs_debug(sb, "---> befs_read_inode() " "inode = %lu", inode->i_ino);
+        befs_debug(sb, "---> befs_read_inode() " "inode = %lu", ino);
+        inode = iget_locked(sb, ino);
+        if (IS_ERR(inode))
+                return inode;
+        if (!(inode->i_state & I_NEW))
+                return inode;
        befs_ino = BEFS_I(inode);
@@ -402,15 +407,16 @@ befs_read_inode(struct inode *inode)
        brelse(bh);
        befs_debug(sb, "<--- befs_read_inode()");
-        return;
+        unlock_new_inode(inode);
+        return inode;
      unacquire_bh:
        brelse(bh);
      unacquire_none:
-        make_bad_inode(inode);
+        iget_failed(inode);
        befs_debug(sb, "<--- befs_read_inode() - Bad inode");
-        return;
+        return ERR_PTR(ret);
 }
 /* Initialize the inode cache. Called at fs setup.
@@ -752,6 +758,7 @@ befs_fill_super(struct super_block *sb, void *data, int silent)
        befs_sb_info *befs_sb;
        befs_super_block *disk_sb;
        struct inode *root;
+        long ret = -EINVAL;
        const unsigned long sb_block = 0;
        const off_t x86_sb_off = 512;
@@ -833,7 +840,11 @@ befs_fill_super(struct super_block *sb, void *data, int silent)
        /* Set real blocksize of fs */
        sb_set_blocksize(sb, (ulong) befs_sb->block_size);
        sb->s_op = (struct super_operations *) &befs_sops;
-        root = iget(sb, iaddr2blockno(sb, &(befs_sb->root_dir)));
+        root = befs_iget(sb, iaddr2blockno(sb, &(befs_sb->root_dir)));
+        if (IS_ERR(root)) {
+                ret = PTR_ERR(root);
+                goto unacquire_priv_sbp;
+        }
        sb->s_root = d_alloc_root(root);
        if (!sb->s_root) {
                iput(root);
@@ -868,7 +879,7 @@ befs_fill_super(struct super_block *sb, void *data, int silent)
      unacquire_none:
        sb->s_fs_info = NULL;
-        return -EINVAL;
+        return ret;
 }
 static int
diff --git a/fs/bfs/bfs.h b/fs/bfs/bfs.h
index ac7a8b1d6c3a..71faf4d23908 100644
--- a/fs/bfs/bfs.h
+++ b/fs/bfs/bfs.h
@@ -44,6 +44,8 @@ static inline struct bfs_inode_info *BFS_I(struct inode *inode)
 #define printf(format, args...) \
        printk(KERN_ERR "BFS-fs: %s(): " format, __FUNCTION__, ## args)
+/* inode.c */
+extern struct inode *bfs_iget(struct super_block *sb, unsigned long ino);
 /* file.c */
 extern const struct inode_operations bfs_file_inops;
diff --git a/fs/bfs/dir.c b/fs/bfs/dir.c
index 1fd056d0fc3d..034950cb3cbe 100644
--- a/fs/bfs/dir.c
+++ b/fs/bfs/dir.c
@@ -148,10 +148,10 @@ static struct dentry *bfs_lookup(struct inode *dir, struct dentry *dentry,
        if (bh) {
                unsigned long ino = (unsigned long)le16_to_cpu(de->ino);
                brelse(bh);
-                inode = iget(dir->i_sb, ino);
+                inode = bfs_iget(dir->i_sb, ino);
-                if (!inode) {
+                if (IS_ERR(inode)) {
                        unlock_kernel();
-                        return ERR_PTR(-EACCES);
+                        return ERR_CAST(inode);
                }
        }
        unlock_kernel();
diff --git a/fs/bfs/inode.c b/fs/bfs/inode.c
index a64a71d444f5..8db623838b50 100644
--- a/fs/bfs/inode.c
+++ b/fs/bfs/inode.c
@@ -32,17 +32,22 @@ MODULE_LICENSE("GPL");
 void dump_imap(const char *prefix, struct super_block *s);
-static void bfs_read_inode(struct inode *inode)
+struct inode *bfs_iget(struct super_block *sb, unsigned long ino)
 {
-        unsigned long ino = inode->i_ino;
        struct bfs_inode *di;
+        struct inode *inode;
        struct buffer_head *bh;
        int block, off;
+        inode = iget_locked(sb, ino);
+        if (IS_ERR(inode))
+                return ERR_PTR(-ENOMEM);
+        if (!(inode->i_state & I_NEW))
+                return inode;
        if ((ino < BFS_ROOT_INO) || (ino > BFS_SB(inode->i_sb)->si_lasti)) {
                printf("Bad inode number %s:%08lx\n", inode->i_sb->s_id, ino);
-                make_bad_inode(inode);
+                goto error;
-                return;
        }
        block = (ino - BFS_ROOT_INO) / BFS_INODES_PER_BLOCK + 1;
@@ -50,8 +55,7 @@ static void bfs_read_inode(struct inode *inode)
        if (!bh) {
                printf("Unable to read inode %s:%08lx\n", inode->i_sb->s_id,
                                                                        ino);
-                make_bad_inode(inode);
+                goto error;
-                return;
        }
        off = (ino - BFS_ROOT_INO) % BFS_INODES_PER_BLOCK;
@@ -85,6 +89,12 @@ static void bfs_read_inode(struct inode *inode)
        inode->i_ctime.tv_nsec = 0;
        brelse(bh);
+        unlock_new_inode(inode);
+        return inode;
+error:
+        iget_failed(inode);
+        return ERR_PTR(-EIO);
 }
 static int bfs_write_inode(struct inode *inode, int unused)
@@ -276,7 +286,6 @@ static void destroy_inodecache(void)
 static const struct super_operations bfs_sops = {
        .alloc_inode    = bfs_alloc_inode,
        .destroy_inode  = bfs_destroy_inode,
-        .read_inode     = bfs_read_inode,
        .write_inode    = bfs_write_inode,
        .delete_inode   = bfs_delete_inode,
        .put_super      = bfs_put_super,
@@ -312,6 +321,7 @@ static int bfs_fill_super(struct super_block *s, void *data, int silent)
        struct inode *inode;
        unsigned i, imap_len;
        struct bfs_sb_info *info;
+        long ret = -EINVAL;
        info = kzalloc(sizeof(*info), GFP_KERNEL);
        if (!info)
@@ -346,14 +356,16 @@ static int bfs_fill_super(struct super_block *s, void *data, int silent)
                set_bit(i, info->si_imap);
        s->s_op = &bfs_sops;
-        inode = iget(s, BFS_ROOT_INO);
+        inode = bfs_iget(s, BFS_ROOT_INO);
-        if (!inode) {
+        if (IS_ERR(inode)) {
+                ret = PTR_ERR(inode);
                kfree(info->si_imap);
                goto out;
        }
        s->s_root = d_alloc_root(inode);
        if (!s->s_root) {
                iput(inode);
+                ret = -ENOMEM;
                kfree(info->si_imap);
                goto out;
        }
@@ -404,7 +416,7 @@ out:
        brelse(bh);
        kfree(info);
        s->s_fs_info = NULL;
-        return -EINVAL;
+        return ret;
 }
 static int bfs_get_sb(struct file_system_type *fs_type,
diff --git a/fs/binfmt_aout.c b/fs/binfmt_aout.c
index 7596e1e94cde..7f65e71bf859 100644
--- a/fs/binfmt_aout.c
+++ b/fs/binfmt_aout.c
@@ -115,7 +115,7 @@ static int aout_core_dump(long signr, struct pt_regs *regs, struct file *file, u
        current->flags |= PF_DUMPCORE;
        strncpy(dump.u_comm, current->comm, sizeof(dump.u_comm));
 #ifndef __sparc__
-        dump.u_ar0 = (void *)(((unsigned long)(&dump.regs)) - ((unsigned long)(&dump)));
+        dump.u_ar0 = offsetof(struct user, regs);
 #endif
        dump.signal = signr;
        dump_thread(regs, &dump);
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index e9f4ec701092..fcc434227691 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -147,10 +147,11 @@ cifs_read_super(struct super_block *sb, void *data,
 #endif
        sb->s_blocksize = CIFS_MAX_MSGSIZE;
        sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
-        inode = iget(sb, ROOT_I);
+        inode = cifs_iget(sb, ROOT_I);
-        if (!inode) {
+        if (IS_ERR(inode)) {
-                rc = -ENOMEM;
+                rc = PTR_ERR(inode);
+                inode = NULL;
                goto out_no_root;
        }
@@ -520,7 +521,6 @@ static int cifs_remount(struct super_block *sb, int *flags, char *data)
 }
 static const struct super_operations cifs_super_ops = {
-        .read_inode = cifs_read_inode,
        .put_super = cifs_put_super,
        .statfs = cifs_statfs,
        .alloc_inode = cifs_alloc_inode,
diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index 195b14de5567..68978306c3ca 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -44,6 +44,7 @@ extern void cifs_read_inode(struct inode *);
 /* Functions related to inodes */
 extern const struct inode_operations cifs_dir_inode_ops;
+extern struct inode *cifs_iget(struct super_block *, unsigned long);
 extern int cifs_create(struct inode *, struct dentry *, int,
                       struct nameidata *);
 extern struct dentry *cifs_lookup(struct inode *, struct dentry *,
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 47f2621001e4..b1a4a65eaa08 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -586,10 +586,18 @@ static const struct inode_operations cifs_ipc_inode_ops = {
 };
 /* gets root inode */
-void cifs_read_inode(struct inode *inode)
+struct inode *cifs_iget(struct super_block *sb, unsigned long ino)
 {
-        int xid, rc;
+        int xid;
        struct cifs_sb_info *cifs_sb;
+        struct inode *inode;
+        long rc;
+        inode = iget_locked(sb, ino);
+        if (!inode)
+                return ERR_PTR(-ENOMEM);
+        if (!(inode->i_state & I_NEW))
+                return inode;
        cifs_sb = CIFS_SB(inode->i_sb);
        xid = GetXid();
@@ -606,10 +614,18 @@ void cifs_read_inode(struct inode *inode)
                inode->i_fop = &simple_dir_operations;
                inode->i_uid = cifs_sb->mnt_uid;
                inode->i_gid = cifs_sb->mnt_gid;
+                _FreeXid(xid);
+                iget_failed(inode);
+                return ERR_PTR(rc);
        }
-        /* can not call macro FreeXid here since in a void func */
+        unlock_new_inode(inode);
+        /* can not call macro FreeXid here since in a void func
+         * TODO: This is no longer true
+         */
        _FreeXid(xid);
+        return inode;
 }
 int cifs_unlink(struct inode *inode, struct dentry *direntry)
diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index ffdc022cae64..614bd75b5a4a 100644
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -2986,7 +2986,7 @@ asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
        }
 do_ioctl:
-        error = vfs_ioctl(filp, fd, cmd, arg);
+        error = do_vfs_ioctl(filp, fd, cmd, arg);
 out_fput:
        fput_light(filp, fput_needed);
 out:
diff --git a/fs/efs/inode.c b/fs/efs/inode.c
index 174696f9bf14..627c3026946d 100644
--- a/fs/efs/inode.c
+++ b/fs/efs/inode.c
@@ -45,17 +45,26 @@ static inline void extent_copy(efs_extent *src, efs_extent *dst) {
        return;
 }
-void efs_read_inode(struct inode *inode)
+struct inode *efs_iget(struct super_block *super, unsigned long ino)
 {
        int i, inode_index;
        dev_t device;
        u32 rdev;
        struct buffer_head *bh;
-        struct efs_sb_info    *sb = SUPER_INFO(inode->i_sb);
+        struct efs_sb_info    *sb = SUPER_INFO(super);
-        struct efs_inode_info *in = INODE_INFO(inode);
+        struct efs_inode_info *in;
        efs_block_t block, offset;
        struct efs_dinode *efs_inode;
-  
+        struct inode *inode;
+        inode = iget_locked(super, ino);
+        if (IS_ERR(inode))
+                return ERR_PTR(-ENOMEM);
+        if (!(inode->i_state & I_NEW))
+                return inode;
+        in = INODE_INFO(inode);
        /*
        ** EFS layout:
        **
@@ -159,13 +168,13 @@ void efs_read_inode(struct inode *inode)
                        break;
        }
-        return;
+        unlock_new_inode(inode);
+        return inode;
        
 read_inode_error:
        printk(KERN_WARNING "EFS: failed to read inode %lu\n", inode->i_ino);
-        make_bad_inode(inode);
+        iget_failed(inode);
+        return ERR_PTR(-EIO);
-        return;
 }
 static inline efs_block_t
diff --git a/fs/efs/namei.c b/fs/efs/namei.c
index f7f407075be1..e26704742d41 100644
--- a/fs/efs/namei.c
+++ b/fs/efs/namei.c
@@ -66,9 +66,10 @@ struct dentry *efs_lookup(struct inode *dir, struct dentry *dentry, struct namei
        lock_kernel();
        inodenum = efs_find_entry(dir, dentry->d_name.name, dentry->d_name.len);
        if (inodenum) {
-                if (!(inode = iget(dir->i_sb, inodenum))) {
+                inode = efs_iget(dir->i_sb, inodenum);
+                if (IS_ERR(inode)) {
                        unlock_kernel();
-                        return ERR_PTR(-EACCES);
+                        return ERR_CAST(inode);
                }
        }
        unlock_kernel();
@@ -84,12 +85,11 @@ static struct inode *efs_nfs_get_inode(struct super_block *sb, u64 ino,
        if (ino == 0)
                return ERR_PTR(-ESTALE);
-        inode = iget(sb, ino);
+        inode = efs_iget(sb, ino);
-        if (inode == NULL)
+        if (IS_ERR(inode))
-                return ERR_PTR(-ENOMEM);
+                return ERR_CAST(inode);
-        if (is_bad_inode(inode) ||
+        if (generation && inode->i_generation != generation) {
-            (generation && inode->i_generation != generation)) {
                iput(inode);
                return ERR_PTR(-ESTALE);
        }
@@ -116,7 +116,7 @@ struct dentry *efs_get_parent(struct dentry *child)
        struct dentry *parent;
        struct inode *inode;
        efs_ino_t ino;
-        int error;
+        long error;
        lock_kernel();
@@ -125,10 +125,11 @@ struct dentry *efs_get_parent(struct dentry *child)
        if (!ino)
                goto fail;
-        error = -EACCES;
+        inode = efs_iget(child->d_inode->i_sb, ino);
-        inode = iget(child->d_inode->i_sb, ino);
+        if (IS_ERR(inode)) {
-        if (!inode)
+                error = PTR_ERR(inode);
                goto fail;
+        }
        error = -ENOMEM;
        parent = d_alloc_anon(inode);
diff --git a/fs/efs/super.c b/fs/efs/super.c
index c79bc627f107..14082405cdd1 100644
--- a/fs/efs/super.c
+++ b/fs/efs/super.c
@@ -107,7 +107,6 @@ static int efs_remount(struct super_block *sb, int *flags, char *data)
 static const struct super_operations efs_superblock_operations = {
        .alloc_inode    = efs_alloc_inode,
        .destroy_inode  = efs_destroy_inode,
-        .read_inode     = efs_read_inode,
        .put_super      = efs_put_super,
        .statfs         = efs_statfs,
        .remount_fs     = efs_remount,
@@ -247,6 +246,7 @@ static int efs_fill_super(struct super_block *s, void *d, int silent)
        struct efs_sb_info *sb;
        struct buffer_head *bh;
        struct inode *root;
+        int ret = -EINVAL;
        sb = kzalloc(sizeof(struct efs_sb_info), GFP_KERNEL);
        if (!sb)
@@ -303,12 +303,18 @@ static int efs_fill_super(struct super_block *s, void *d, int silent)
        }
        s->s_op   = &efs_superblock_operations;
        s->s_export_op = &efs_export_ops;
-        root = iget(s, EFS_ROOTINODE);
+        root = efs_iget(s, EFS_ROOTINODE);
+        if (IS_ERR(root)) {
+                printk(KERN_ERR "EFS: get root inode failed\n");
+                ret = PTR_ERR(root);
+                goto out_no_fs;
+        }
        s->s_root = d_alloc_root(root);
- 
        if (!(s->s_root)) {
-                printk(KERN_ERR "EFS: get root inode failed\n");
+                printk(KERN_ERR "EFS: get root dentry failed\n");
                iput(root);
+                ret = -ENOMEM;
                goto out_no_fs;
        }
@@ -318,7 +324,7 @@ out_no_fs_ul:
 out_no_fs:
        s->s_fs_info = NULL;
        kfree(sb);
-        return -EINVAL;
+        return ret;
 }
 static int efs_statfs(struct dentry *dentry, struct kstatfs *buf) {
diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index bb9948cdd50f..f1e5705e75f1 100644
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -124,7 +124,7 @@ extern void ext2_check_inodes_bitmap (struct super_block *);
 extern unsigned long ext2_count_free (struct buffer_head *, unsigned);
 /* inode.c */
-extern void ext2_read_inode (struct inode *);
+extern struct inode *ext2_iget (struct super_block *, unsigned long);
 extern int ext2_write_inode (struct inode *, int);
 extern void ext2_put_inode (struct inode *);
 extern void ext2_delete_inode (struct inode *);
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 03978ec2a91c..c62006805427 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -1181,22 +1181,33 @@ void ext2_get_inode_flags(struct ext2_inode_info *ei)
                ei->i_flags |= EXT2_DIRSYNC_FL;
 }
-void ext2_read_inode (struct inode * inode)
+struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
 {
-        struct ext2_inode_info *ei = EXT2_I(inode);
+        struct ext2_inode_info *ei;
-        ino_t ino = inode->i_ino;
        struct buffer_head * bh;
-        struct ext2_inode * raw_inode = ext2_get_inode(inode->i_sb, ino, &bh);
+        struct ext2_inode *raw_inode;
+        struct inode *inode;
+        long ret = -EIO;
        int n;
+        inode = iget_locked(sb, ino);
+        if (!inode)
+                return ERR_PTR(-ENOMEM);
+        if (!(inode->i_state & I_NEW))
+                return inode;
+        ei = EXT2_I(inode);
 #ifdef CONFIG_EXT2_FS_POSIX_ACL
        ei->i_acl = EXT2_ACL_NOT_CACHED;
        ei->i_default_acl = EXT2_ACL_NOT_CACHED;
 #endif
        ei->i_block_alloc_info = NULL;
-        if (IS_ERR(raw_inode))
+        raw_inode = ext2_get_inode(inode->i_sb, ino, &bh);
+        if (IS_ERR(raw_inode)) {
+                ret = PTR_ERR(raw_inode);
                goto bad_inode;
+        }
        inode->i_mode = le16_to_cpu(raw_inode->i_mode);
        inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
@@ -1220,6 +1231,7 @@ void ext2_read_inode (struct inode * inode)
        if (inode->i_nlink == 0 && (inode->i_mode == 0 || ei->i_dtime)) {
                /* this inode is deleted */
                brelse (bh);
+                ret = -ESTALE;
                goto bad_inode;
        }
        inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
@@ -1286,11 +1298,12 @@ void ext2_read_inode (struct inode * inode)
        }
        brelse (bh);
        ext2_set_inode_flags(inode);
-        return;
+        unlock_new_inode(inode);
+        return inode;
        
 bad_inode:
-        make_bad_inode(inode);
+        iget_failed(inode);
-        return;
+        return ERR_PTR(ret);
 }
 static int ext2_update_inode(struct inode * inode, int do_sync)
diff --git a/fs/ext2/namei.c b/fs/ext2/namei.c
index e69beed839ac..80c97fd8c571 100644
--- a/fs/ext2/namei.c
+++ b/fs/ext2/namei.c
@@ -63,9 +63,9 @@ static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry, str
        ino = ext2_inode_by_name(dir, dentry);
        inode = NULL;
        if (ino) {
-                inode = iget(dir->i_sb, ino);
+                inode = ext2_iget(dir->i_sb, ino);
-                if (!inode)
+                if (IS_ERR(inode))
-                        return ERR_PTR(-EACCES);
+                        return ERR_CAST(inode);
        }
        return d_splice_alias(inode, dentry);
 }
@@ -83,10 +83,10 @@ struct dentry *ext2_get_parent(struct dentry *child)
        ino = ext2_inode_by_name(child->d_inode, &dotdot);
        if (!ino)
                return ERR_PTR(-ENOENT);
-        inode = iget(child->d_inode->i_sb, ino);
+        inode = ext2_iget(child->d_inode->i_sb, ino);
-        if (!inode)
+        if (IS_ERR(inode))
-                return ERR_PTR(-EACCES);
+                return ERR_CAST(inode);
        parent = d_alloc_anon(inode);
        if (!parent) {
                iput(inode);
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 1ba18b72d43a..22f1010bf79f 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -296,7 +296,6 @@ static ssize_t ext2_quota_write(struct super_block *sb, int type, const char *da
 static const struct super_operations ext2_sops = {
        .alloc_inode    = ext2_alloc_inode,
        .destroy_inode  = ext2_destroy_inode,
-        .read_inode     = ext2_read_inode,
        .write_inode    = ext2_write_inode,
        .delete_inode   = ext2_delete_inode,
        .put_super      = ext2_put_super,
@@ -326,11 +325,10 @@ static struct inode *ext2_nfs_get_inode(struct super_block *sb,
         * it might be "neater" to call ext2_get_inode first and check
         * if the inode is valid.....
         */
-        inode = iget(sb, ino);
+        inode = ext2_iget(sb, ino);
-        if (inode == NULL)
+        if (IS_ERR(inode))
-                return ERR_PTR(-ENOMEM);
+                return ERR_CAST(inode);
-        if (is_bad_inode(inode) ||
+        if (generation && inode->i_generation != generation) {
-            (generation && inode->i_generation != generation)) {
                /* we didn't find the right inode.. */
                iput(inode);
                return ERR_PTR(-ESTALE);
@@ -746,6 +744,7 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
        unsigned long logic_sb_block;
        unsigned long offset = 0;
        unsigned long def_mount_opts;
+        long ret = -EINVAL;
        int blocksize = BLOCK_SIZE;
        int db_count;
        int i, j;
@@ -1041,19 +1040,24 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_op = &ext2_sops;
        sb->s_export_op = &ext2_export_ops;
        sb->s_xattr = ext2_xattr_handlers;
-        root = iget(sb, EXT2_ROOT_INO);
+        root = ext2_iget(sb, EXT2_ROOT_INO);
-        sb->s_root = d_alloc_root(root);
+        if (IS_ERR(root)) {
-        if (!sb->s_root) {
+                ret = PTR_ERR(root);
-                iput(root);
-                printk(KERN_ERR "EXT2-fs: get root inode failed\n");
                goto failed_mount3;
        }
        if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
-                dput(sb->s_root);
+                iput(root);
-                sb->s_root = NULL;
                printk(KERN_ERR "EXT2-fs: corrupt root inode, run e2fsck\n");
                goto failed_mount3;
        }
+        sb->s_root = d_alloc_root(root);
+        if (!sb->s_root) {
+                iput(root);
+                printk(KERN_ERR "EXT2-fs: get root inode failed\n");
+                ret = -ENOMEM;
+                goto failed_mount3;
+        }
        if (EXT2_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL))
                ext2_warning(sb, __FUNCTION__,
                        "mounting ext3 filesystem as ext2");
@@ -1080,7 +1084,7 @@ failed_mount:
 failed_sbi:
        sb->s_fs_info = NULL;
        kfree(sbi);
-        return -EINVAL;
+        return ret;
 }
 static void ext2_commit_super (struct super_block * sb,
diff --git a/fs/ext3/ialloc.c b/fs/ext3/ialloc.c
index 1bc8cd89c51d..58ae2f943f12 100644
--- a/fs/ext3/ialloc.c
+++ b/fs/ext3/ialloc.c
@@ -642,14 +642,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);
@@ -658,38 +659,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) ||
+        if (!ext3_test_bit(bit, bitmap_bh->b_data))
-                        !(inode = iget(sb, ino)) || is_bad_inode(inode) ||
+                goto bad_orphan;
-                        NEXT_ORPHAN(inode) > max_ino) {
-                ext3_warning(sb, __FUNCTION__,
+        inode = ext3_iget(sb, ino);
-                             "bad orphan inode %lu!  e2fsck was run?", ino);
+        if (IS_ERR(inode))
-                printk(KERN_NOTICE "ext3_test_bit(bit=%d, block=%llu) = %d\n",
+                goto iget_failed;
-                       bit, (unsigned long long)bitmap_bh->b_blocknr,
-                       ext3_test_bit(bit, bitmap_bh->b_data));
+        if (NEXT_ORPHAN(inode) > max_ino)
-                printk(KERN_NOTICE "inode=%p\n", inode);
+                goto bad_orphan;
-                if (inode) {
+        brelse(bitmap_bh);
-                        printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
+        return inode;
-                               is_bad_inode(inode));
-                        printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
+iget_failed:
-                               NEXT_ORPHAN(inode));
+        err = PTR_ERR(inode);
-                        printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
+        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 8a9ce2d09bde..eb95670a27eb 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -2654,21 +2654,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);
@@ -2699,6 +2709,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
@@ -2742,6 +2753,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) {
@@ -2783,11 +2795,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);
+        iget_failed(inode);
-        return;
+        return ERR_PTR(ret);
 }
 /*
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 92b83b004dd8..dec3e0d88ab1 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -1037,17 +1037,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;
+                        return ERR_PTR(-EIO);
-                } else
-                        inode = iget(dir->i_sb, ino);
-                if (!inode)
-                        return ERR_PTR(-EACCES);
-                if (is_bad_inode(inode)) {
-                        iput(inode);
-                        return ERR_PTR(-ENOENT);
                }
+                inode = ext3_iget(dir->i_sb, ino);
+                if (IS_ERR(inode))
+                        return ERR_CAST(inode);
        }
        return d_splice_alias(inode, dentry);
 }
@@ -1076,18 +1070,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;
+                return ERR_PTR(-EIO);
-        } 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);
        }
+        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 44de1453c301..ebc05af7343a 100644
--- a/fs/ext3/resize.c
+++ b/fs/ext3/resize.c
@@ -795,12 +795,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);
+                inode = ext3_iget(sb, EXT3_RESIZE_INO);
-                if (!inode || is_bad_inode(inode)) {
+                if (IS_ERR(inode)) {
                        ext3_warning(sb, __FUNCTION__,
                                     "Error opening resize inode");
-                        iput(inode);
+                        return PTR_ERR(inode);
-                        return -ENOENT;
                }
        }
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 343677e8c350..cf2a2c3660ec 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -649,11 +649,10 @@ static struct inode *ext3_nfs_get_inode(struct super_block *sb,
         * Currently we don't know the generation for parent directory, so
         * a generation of 0 means "accept any"
         */
-        inode = iget(sb, ino);
+        inode = ext3_iget(sb, ino);
-        if (inode == NULL)
+        if (IS_ERR(inode))
-                return ERR_PTR(-ENOMEM);
+                return ERR_CAST(inode);
-        if (is_bad_inode(inode) ||
+        if (generation && inode->i_generation != generation) {
-            (generation && inode->i_generation != generation)) {
                iput(inode);
                return ERR_PTR(-ESTALE);
        }
@@ -722,7 +721,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,
@@ -1378,8 +1376,8 @@ static void ext3_orphan_cleanup (struct super_block * sb,
        while (es->s_last_orphan) {
                struct inode *inode;
-                if (!(inode =
+                inode = ext3_orphan_get(sb, le32_to_cpu(es->s_last_orphan));
-                      ext3_orphan_get(sb, le32_to_cpu(es->s_last_orphan)))) {
+                if (IS_ERR(inode)) {
                        es->s_last_orphan = 0;
                        break;
                }
@@ -1508,6 +1506,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;
        int err;
@@ -1877,19 +1876,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);
+        root = ext3_iget(sb, EXT3_ROOT_INO);
-        sb->s_root = d_alloc_root(root);
+        if (IS_ERR(root)) {
-        if (!sb->s_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);
+                iput(root);
-                sb->s_root = NULL;
                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);
        /*
@@ -1941,7 +1945,7 @@ out_fail:
        sb->s_fs_info = NULL;
        kfree(sbi);
        lock_kernel();
-        return -EINVAL;
+        return ret;
 }
 /*
@@ -1977,8 +1981,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);
+        journal_inode = ext3_iget(sb, journal_inum);
-        if (!journal_inode) {
+        if (IS_ERR(journal_inode)) {
                printk(KERN_ERR "EXT3-fs: no journal found.\n");
                return NULL;
        }
@@ -1991,7 +1995,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/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 575b5215c808..da18a74b966a 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -782,14 +782,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);
        ext4_group_t 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);
@@ -798,38 +799,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) ||
+        if (!ext4_test_bit(bit, bitmap_bh->b_data))
-                        !(inode = iget(sb, ino)) || is_bad_inode(inode) ||
+                goto bad_orphan;
-                        NEXT_ORPHAN(inode) > max_ino) {
-                ext4_warning(sb, __FUNCTION__,
+        inode = ext4_iget(sb, ino);
-                             "bad orphan inode %lu!  e2fsck was run?", ino);
+        if (IS_ERR(inode))
-                printk(KERN_NOTICE "ext4_test_bit(bit=%d, block=%llu) = %d\n",
+                goto iget_failed;
-                       bit, (unsigned long long)bitmap_bh->b_blocknr,
-                       ext4_test_bit(bit, bitmap_bh->b_data));
+        if (NEXT_ORPHAN(inode) > max_ino)
-                printk(KERN_NOTICE "inode=%p\n", inode);
+                goto bad_orphan;
-                if (inode) {
+        brelse(bitmap_bh);
-                        printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
+        return inode;
-                               is_bad_inode(inode));
-                        printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
+iget_failed:
-                               NEXT_ORPHAN(inode));
+        err = PTR_ERR(inode);
-                        printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
+        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 0e9055cf700e..f4e387452246 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -2680,21 +2680,31 @@ static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
        }
 }
-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);
@@ -2720,6 +2730,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
@@ -2758,6 +2769,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) {
@@ -2811,11 +2823,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);
+        iget_failed(inode);
-        return;
+        return ERR_PTR(ret);
 }
 static int ext4_inode_blocks_set(handle_t *handle,
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 67b6d8a1ceff..d153bb5922fc 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -1039,17 +1039,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;
+                        return ERR_PTR(-EIO);
-                } else
-                        inode = iget(dir->i_sb, ino);
-                if (!inode)
-                        return ERR_PTR(-EACCES);
-                if (is_bad_inode(inode)) {
-                        iput(inode);
-                        return ERR_PTR(-ENOENT);
                }
+                inode = ext4_iget(dir->i_sb, ino);
+                if (IS_ERR(inode))
+                        return ERR_CAST(inode);
        }
        return d_splice_alias(inode, dentry);
 }
@@ -1078,18 +1072,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;
+                return ERR_PTR(-EIO);
-        } 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);
        }
+        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 4fbba60816f4..9477a2bd6ff2 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -779,12 +779,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);
+                inode = ext4_iget(sb, EXT4_RESIZE_INO);
-                if (!inode || is_bad_inode(inode)) {
+                if (IS_ERR(inode)) {
                        ext4_warning(sb, __FUNCTION__,
                                     "Error opening resize inode");
-                        iput(inode);
+                        return PTR_ERR(inode);
-                        return -ENOENT;
                }
        }
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index c89bb8797765..93beb865c20d 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -777,11 +777,10 @@ static struct inode *ext4_nfs_get_inode(struct super_block *sb,
         * Currently we don't know the generation for parent directory, so
         * a generation of 0 means "accept any"
         */
-        inode = iget(sb, ino);
+        inode = ext4_iget(sb, ino);
-        if (inode == NULL)
+        if (IS_ERR(inode))
-                return ERR_PTR(-ENOMEM);
+                return ERR_CAST(inode);
-        if (is_bad_inode(inode) ||
+        if (generation && inode->i_generation != generation) {
-            (generation && inode->i_generation != generation)) {
                iput(inode);
                return ERR_PTR(-ESTALE);
        }
@@ -850,7 +849,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,
@@ -1805,6 +1803,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 db_count;
        int i;
@@ -2237,19 +2236,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);
+        root = ext4_iget(sb, EXT4_ROOT_INO);
-        sb->s_root = d_alloc_root(root);
+        if (IS_ERR(root)) {
-        if (!sb->s_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);
+                iput(root);
-                sb->s_root = NULL;
                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);
@@ -2330,7 +2334,7 @@ out_fail:
        sb->s_fs_info = NULL;
        kfree(sbi);
        lock_kernel();
-        return -EINVAL;
+        return ret;
 }
 /*
@@ -2366,8 +2370,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);
+        journal_inode = ext4_iget(sb, journal_inum);
-        if (!journal_inode) {
+        if (IS_ERR(journal_inode)) {
                printk(KERN_ERR "EXT4-fs: no journal found.\n");
                return NULL;
        }
@@ -2380,7 +2384,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/fs/fat/inode.c b/fs/fat/inode.c
index 24c0aaa5ae80..085269e07fb3 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -634,8 +634,6 @@ static const struct super_operations fat_sops = {
        .clear_inode    = fat_clear_inode,
        .remount_fs     = fat_remount,
-        .read_inode     = make_bad_inode,
        .show_options   = fat_show_options,
 };
@@ -663,8 +661,8 @@ static struct dentry *fat_fh_to_dentry(struct super_block *sb,
        if (fh_len < 5 || fh_type != 3)
                return NULL;
-        inode = iget(sb, fh[0]);
+        inode = ilookup(sb, fh[0]);
-        if (!inode || is_bad_inode(inode) || inode->i_generation != fh[1]) {
+        if (!inode || inode->i_generation != fh[1]) {
                if (inode)
                        iput(inode);
                inode = NULL;
@@ -760,7 +758,7 @@ static struct dentry *fat_get_parent(struct dentry *child)
        inode = fat_build_inode(child->d_sb, de, i_pos);
        brelse(bh);
        if (IS_ERR(inode)) {
-                parent = ERR_PTR(PTR_ERR(inode));
+                parent = ERR_CAST(inode);
                goto out;
        }
        parent = d_alloc_anon(inode);
diff --git a/fs/freevxfs/vxfs_extern.h b/fs/freevxfs/vxfs_extern.h
index 91ccee8723f7..2b46064f66b2 100644
--- a/fs/freevxfs/vxfs_extern.h
+++ b/fs/freevxfs/vxfs_extern.h
@@ -58,7 +58,7 @@ extern struct inode *		vxfs_get_fake_inode(struct super_block *,
 extern void                     vxfs_put_fake_inode(struct inode *);
 extern struct vxfs_inode_info * vxfs_blkiget(struct super_block *, u_long, ino_t);
 extern struct vxfs_inode_info * vxfs_stiget(struct super_block *, ino_t);
-extern void                     vxfs_read_inode(struct inode *);
+extern struct inode *           vxfs_iget(struct super_block *, ino_t);
 extern void                     vxfs_clear_inode(struct inode *);
 /* vxfs_lookup.c */
diff --git a/fs/freevxfs/vxfs_inode.c b/fs/freevxfs/vxfs_inode.c
index d1f7c5b5b3c3..ad88d2364bc2 100644
--- a/fs/freevxfs/vxfs_inode.c
+++ b/fs/freevxfs/vxfs_inode.c
@@ -129,7 +129,7 @@ fail:
 * Description:
 *  Search the for inode number @ino in the filesystem
 *  described by @sbp.  Use the specified inode table (@ilistp).
- *  Returns the matching VxFS inode on success, else a NULL pointer.
+ *  Returns the matching VxFS inode on success, else an error code.
 */
 static struct vxfs_inode_info *
 __vxfs_iget(ino_t ino, struct inode *ilistp)
@@ -157,12 +157,12 @@ __vxfs_iget(ino_t ino, struct inode *ilistp)
        }
        printk(KERN_WARNING "vxfs: error on page %p\n", pp);
-        return NULL;
+        return ERR_CAST(pp);
 fail:
        printk(KERN_WARNING "vxfs: unable to read inode %ld\n", (unsigned long)ino);
        vxfs_put_page(pp);
-        return NULL;
+        return ERR_PTR(-ENOMEM);
 }
 /**
@@ -178,7 +178,10 @@ fail:
 struct vxfs_inode_info *
 vxfs_stiget(struct super_block *sbp, ino_t ino)
 {
-        return __vxfs_iget(ino, VXFS_SBI(sbp)->vsi_stilist);
+        struct vxfs_inode_info *vip;
+        vip = __vxfs_iget(ino, VXFS_SBI(sbp)->vsi_stilist);
+        return IS_ERR(vip) ? NULL : vip;
 }
 /**
@@ -282,23 +285,32 @@ vxfs_put_fake_inode(struct inode *ip)
 }
 /**
- * vxfs_read_inode - fill in inode information
+ * vxfs_iget - get an inode
- * @ip:         inode pointer to fill
+ * @sbp:        the superblock to get the inode for
+ * @ino:        the number of the inode to get
 *
 * Description:
- *  vxfs_read_inode reads the disk inode for @ip and fills
+ *  vxfs_read_inode creates an inode, reads the disk inode for @ino and fills
- *  in all relevant fields in @ip.
+ *  in all relevant fields in the new inode.
 */
-void
+struct inode *
-vxfs_read_inode(struct inode *ip)
+vxfs_iget(struct super_block *sbp, ino_t ino)
 {
-        struct super_block              *sbp = ip->i_sb;
        struct vxfs_inode_info          *vip;
        const struct address_space_operations   *aops;
-        ino_t                           ino = ip->i_ino;
+        struct inode *ip;
-        if (!(vip = __vxfs_iget(ino, VXFS_SBI(sbp)->vsi_ilist)))
+        ip = iget_locked(sbp, ino);
-                return;
+        if (!ip)
+                return ERR_PTR(-ENOMEM);
+        if (!(ip->i_state & I_NEW))
+                return ip;
+        vip = __vxfs_iget(ino, VXFS_SBI(sbp)->vsi_ilist);
+        if (IS_ERR(vip)) {
+                iget_failed(ip);
+                return ERR_CAST(vip);
+        }
        vxfs_iinit(ip, vip);
@@ -323,7 +335,8 @@ vxfs_read_inode(struct inode *ip)
        } else
                init_special_inode(ip, ip->i_mode, old_decode_dev(vip->vii_rdev));
-        return;
+        unlock_new_inode(ip);
+        return ip;
 }
 /**
diff --git a/fs/freevxfs/vxfs_lookup.c b/fs/freevxfs/vxfs_lookup.c
index bf86e5444ea6..aee049cb9f84 100644
--- a/fs/freevxfs/vxfs_lookup.c
+++ b/fs/freevxfs/vxfs_lookup.c
@@ -213,10 +213,10 @@ vxfs_lookup(struct inode *dip, struct dentry *dp, struct nameidata *nd)
        lock_kernel();
        ino = vxfs_inode_by_name(dip, dp);
        if (ino) {
-                ip = iget(dip->i_sb, ino);
+                ip = vxfs_iget(dip->i_sb, ino);
-                if (!ip) {
+                if (IS_ERR(ip)) {
                        unlock_kernel();
-                        return ERR_PTR(-EACCES);
+                        return ERR_CAST(ip);
                }
        }
        unlock_kernel();
diff --git a/fs/freevxfs/vxfs_super.c b/fs/freevxfs/vxfs_super.c
index 4f95572d2722..1dacda831577 100644
--- a/fs/freevxfs/vxfs_super.c
+++ b/fs/freevxfs/vxfs_super.c
@@ -60,7 +60,6 @@ static int		vxfs_statfs(struct dentry *, struct kstatfs *);
 static int              vxfs_remount(struct super_block *, int *, char *);
 static const struct super_operations vxfs_super_ops = {
-        .read_inode =           vxfs_read_inode,
        .clear_inode =          vxfs_clear_inode,
        .put_super =            vxfs_put_super,
        .statfs =               vxfs_statfs,
@@ -153,6 +152,7 @@ static int vxfs_fill_super(struct super_block *sbp, void *dp, int silent)
        struct buffer_head      *bp = NULL;
        u_long                  bsize;
        struct inode *root;
+        int ret = -EINVAL;
        sbp->s_flags |= MS_RDONLY;
@@ -219,7 +219,11 @@ static int vxfs_fill_super(struct super_block *sbp, void *dp, int silent)
        }
        sbp->s_op = &vxfs_super_ops;
-        root = iget(sbp, VXFS_ROOT_INO);
+        root = vxfs_iget(sbp, VXFS_ROOT_INO);
+        if (IS_ERR(root)) {
+                ret = PTR_ERR(root);
+                goto out;
+        }
        sbp->s_root = d_alloc_root(root);
        if (!sbp->s_root) {
                iput(root);
@@ -236,7 +240,7 @@ out_free_ilist:
 out:
        brelse(bp);
        kfree(infp);
-        return -EINVAL;
+        return ret;
 }
 /*
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index f56f91bd38be..7fb514b6d852 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -269,12 +269,12 @@ static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
        req = fuse_get_req(fc);
        if (IS_ERR(req))
-                return ERR_PTR(PTR_ERR(req));
+                return ERR_CAST(req);
        forget_req = fuse_get_req(fc);
        if (IS_ERR(forget_req)) {
                fuse_put_request(fc, req);
-                return ERR_PTR(PTR_ERR(forget_req));
+                return ERR_CAST(forget_req);
        }
        attr_version = fuse_get_attr_version(fc);
@@ -1006,7 +1006,7 @@ static char *read_link(struct dentry *dentry)
        char *link;
        if (IS_ERR(req))
-                return ERR_PTR(PTR_ERR(req));
+                return ERR_CAST(req);
        link = (char *) __get_free_page(GFP_KERNEL);
        if (!link) {
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index c90f633d0b57..574707409bbf 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -76,11 +76,6 @@ static void fuse_destroy_inode(struct inode *inode)
        kmem_cache_free(fuse_inode_cachep, inode);
 }
-static void fuse_read_inode(struct inode *inode)
-{
-        /* No op */
-}
 void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req,
                      unsigned long nodeid, u64 nlookup)
 {
@@ -515,7 +510,6 @@ static struct inode *get_root_inode(struct super_block *sb, unsigned mode)
 static const struct super_operations fuse_super_operations = {
        .alloc_inode    = fuse_alloc_inode,
        .destroy_inode  = fuse_destroy_inode,
-        .read_inode     = fuse_read_inode,
        .clear_inode    = fuse_clear_inode,
        .drop_inode     = generic_delete_inode,
        .remount_fs     = fuse_remount_fs,
diff --git a/fs/gfs2/dir.c b/fs/gfs2/dir.c
index 57e2ed932adc..c34709512b19 100644
--- a/fs/gfs2/dir.c
+++ b/fs/gfs2/dir.c
@@ -1498,7 +1498,7 @@ struct inode *gfs2_dir_search(struct inode *dir, const struct qstr *name)
        dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
        if (dent) {
                if (IS_ERR(dent))
-                        return ERR_PTR(PTR_ERR(dent));
+                        return ERR_CAST(dent);
                inode = gfs2_inode_lookup(dir->i_sb, 
                                be16_to_cpu(dent->de_type),
                                be64_to_cpu(dent->de_inum.no_addr),
diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
index 80e09c50590a..7175a4d06435 100644
--- a/fs/gfs2/glock.c
+++ b/fs/gfs2/glock.c
@@ -334,7 +334,7 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number,
        gl->gl_state = LM_ST_UNLOCKED;
        gl->gl_demote_state = LM_ST_EXCLUSIVE;
        gl->gl_hash = hash;
-        gl->gl_owner_pid = 0;
+        gl->gl_owner_pid = NULL;
        gl->gl_ip = 0;
        gl->gl_ops = glops;
        gl->gl_req_gh = NULL;
@@ -399,7 +399,7 @@ void gfs2_holder_init(struct gfs2_glock *gl, unsigned int state, unsigned flags,
        INIT_LIST_HEAD(&gh->gh_list);
        gh->gh_gl = gl;
        gh->gh_ip = (unsigned long)__builtin_return_address(0);
-        gh->gh_owner_pid = current->pid;
+        gh->gh_owner_pid = get_pid(task_pid(current));
        gh->gh_state = state;
        gh->gh_flags = flags;
        gh->gh_error = 0;
@@ -433,6 +433,7 @@ void gfs2_holder_reinit(unsigned int state, unsigned flags, struct gfs2_holder *
 void gfs2_holder_uninit(struct gfs2_holder *gh)
 {
+        put_pid(gh->gh_owner_pid);
        gfs2_glock_put(gh->gh_gl);
        gh->gh_gl = NULL;
        gh->gh_ip = 0;
@@ -631,7 +632,7 @@ static void gfs2_glmutex_lock(struct gfs2_glock *gl)
                wait_on_holder(&gh);
                gfs2_holder_uninit(&gh);
        } else {
-                gl->gl_owner_pid = current->pid;
+                gl->gl_owner_pid = get_pid(task_pid(current));
                gl->gl_ip = (unsigned long)__builtin_return_address(0);
                spin_unlock(&gl->gl_spin);
        }
@@ -652,7 +653,7 @@ static int gfs2_glmutex_trylock(struct gfs2_glock *gl)
        if (test_and_set_bit(GLF_LOCK, &gl->gl_flags)) {
                acquired = 0;
        } else {
-                gl->gl_owner_pid = current->pid;
+                gl->gl_owner_pid = get_pid(task_pid(current));
                gl->gl_ip = (unsigned long)__builtin_return_address(0);
        }
        spin_unlock(&gl->gl_spin);
@@ -668,12 +669,17 @@ static int gfs2_glmutex_trylock(struct gfs2_glock *gl)
 static void gfs2_glmutex_unlock(struct gfs2_glock *gl)
 {
+        struct pid *pid;
        spin_lock(&gl->gl_spin);
        clear_bit(GLF_LOCK, &gl->gl_flags);
-        gl->gl_owner_pid = 0;
+        pid = gl->gl_owner_pid;
+        gl->gl_owner_pid = NULL;
        gl->gl_ip = 0;
        run_queue(gl);
        spin_unlock(&gl->gl_spin);
+        put_pid(pid);
 }
 /**
@@ -1045,7 +1051,7 @@ static int glock_wait_internal(struct gfs2_holder *gh)
 }
 static inline struct gfs2_holder *
-find_holder_by_owner(struct list_head *head, pid_t pid)
+find_holder_by_owner(struct list_head *head, struct pid *pid)
 {
        struct gfs2_holder *gh;
@@ -1082,7 +1088,7 @@ static void add_to_queue(struct gfs2_holder *gh)
        struct gfs2_glock *gl = gh->gh_gl;
        struct gfs2_holder *existing;
-        BUG_ON(!gh->gh_owner_pid);
+        BUG_ON(gh->gh_owner_pid == NULL);
        if (test_and_set_bit(HIF_WAIT, &gh->gh_iflags))
                BUG();
@@ -1092,12 +1098,14 @@ static void add_to_queue(struct gfs2_holder *gh)
                if (existing) {
                        print_symbol(KERN_WARNING "original: %s\n", 
                                     existing->gh_ip);
-                        printk(KERN_INFO "pid : %d\n", existing->gh_owner_pid);
+                        printk(KERN_INFO "pid : %d\n",
+                                        pid_nr(existing->gh_owner_pid));
                        printk(KERN_INFO "lock type : %d lock state : %d\n",
                               existing->gh_gl->gl_name.ln_type, 
                               existing->gh_gl->gl_state);
                        print_symbol(KERN_WARNING "new: %s\n", gh->gh_ip);
-                        printk(KERN_INFO "pid : %d\n", gh->gh_owner_pid);
+                        printk(KERN_INFO "pid : %d\n",
+                                        pid_nr(gh->gh_owner_pid));
                        printk(KERN_INFO "lock type : %d lock state : %d\n",
                               gl->gl_name.ln_type, gl->gl_state);
                        BUG();
@@ -1798,8 +1806,9 @@ static int dump_holder(struct glock_iter *gi, char *str,
        print_dbg(gi, "  %s\n", str);
        if (gh->gh_owner_pid) {
-                print_dbg(gi, "    owner = %ld ", (long)gh->gh_owner_pid);
+                print_dbg(gi, "    owner = %ld ",
-                gh_owner = find_task_by_pid(gh->gh_owner_pid);
+                                (long)pid_nr(gh->gh_owner_pid));
+                gh_owner = pid_task(gh->gh_owner_pid, PIDTYPE_PID);
                if (gh_owner)
                        print_dbg(gi, "(%s)\n", gh_owner->comm);
                else
@@ -1877,13 +1886,13 @@ static int dump_glock(struct glock_iter *gi, struct gfs2_glock *gl)
        print_dbg(gi, "  gl_ref = %d\n", atomic_read(&gl->gl_ref));
        print_dbg(gi, "  gl_state = %u\n", gl->gl_state);
        if (gl->gl_owner_pid) {
-                gl_owner = find_task_by_pid(gl->gl_owner_pid);
+                gl_owner = pid_task(gl->gl_owner_pid, PIDTYPE_PID);
                if (gl_owner)
                        print_dbg(gi, "  gl_owner = pid %d (%s)\n",
-                                  gl->gl_owner_pid, gl_owner->comm);
+                                  pid_nr(gl->gl_owner_pid), gl_owner->comm);
                else
                        print_dbg(gi, "  gl_owner = %d (ended)\n",
-                                  gl->gl_owner_pid);
+                                  pid_nr(gl->gl_owner_pid));
        } else
                print_dbg(gi, "  gl_owner = -1\n");
        print_dbg(gi, "  gl_ip = %lu\n", gl->gl_ip);
diff --git a/fs/gfs2/glock.h b/fs/gfs2/glock.h
index b16f604eea9f..2f9c6d136b37 100644
--- a/fs/gfs2/glock.h
+++ b/fs/gfs2/glock.h
@@ -36,11 +36,13 @@ static inline int gfs2_glock_is_locked_by_me(struct gfs2_glock *gl)
 {
        struct gfs2_holder *gh;
        int locked = 0;
+        struct pid *pid;
        /* Look in glock's list of holders for one with current task as owner */
        spin_lock(&gl->gl_spin);
+        pid = task_pid(current);
        list_for_each_entry(gh, &gl->gl_holders, gh_list) {
-                if (gh->gh_owner_pid == current->pid) {
+                if (gh->gh_owner_pid == pid) {
                        locked = 1;
                        break;
                }
diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
index 513aaf0dc0ab..525dcae352d6 100644
--- a/fs/gfs2/incore.h
+++ b/fs/gfs2/incore.h
@@ -151,7 +151,7 @@ struct gfs2_holder {
        struct list_head gh_list;
        struct gfs2_glock *gh_gl;
-        pid_t gh_owner_pid;
+        struct pid *gh_owner_pid;
        unsigned int gh_state;
        unsigned gh_flags;
@@ -182,7 +182,7 @@ struct gfs2_glock {
        unsigned int gl_hash;
        unsigned int gl_demote_state; /* state requested by remote node */
        unsigned long gl_demote_time; /* time of first demote request */
-        pid_t gl_owner_pid;
+        struct pid *gl_owner_pid;
        unsigned long gl_ip;
        struct list_head gl_holders;
        struct list_head gl_waiters1;   /* HIF_MUTEX */
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 728d3169e7bd..37725ade3c51 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -240,7 +240,7 @@ fail_put:
        ip->i_gl->gl_object = NULL;
        gfs2_glock_put(ip->i_gl);
 fail:
-        iput(inode);
+        iget_failed(inode);
        return ERR_PTR(error);
 }
diff --git a/fs/gfs2/ops_export.c b/fs/gfs2/ops_export.c
index b9da62348a87..334c7f85351b 100644
--- a/fs/gfs2/ops_export.c
+++ b/fs/gfs2/ops_export.c
@@ -143,7 +143,7 @@ static struct dentry *gfs2_get_parent(struct dentry *child)
         * have to return that as a(n invalid) pointer to dentry.
         */
        if (IS_ERR(inode))
-                return ERR_PTR(PTR_ERR(inode));
+                return ERR_CAST(inode);
        dentry = d_alloc_anon(inode);
        if (!dentry) {
diff --git a/fs/gfs2/ops_inode.c b/fs/gfs2/ops_inode.c
index 9f71372c1757..e87412902bed 100644
--- a/fs/gfs2/ops_inode.c
+++ b/fs/gfs2/ops_inode.c
@@ -111,7 +111,7 @@ static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
        inode = gfs2_lookupi(dir, &dentry->d_name, 0, nd);
        if (inode && IS_ERR(inode))
-                return ERR_PTR(PTR_ERR(inode));
+                return ERR_CAST(inode);
        if (inode) {
                struct gfs2_glock *gl = GFS2_I(inode)->i_gl;
diff --git a/fs/hfsplus/btree.c b/fs/hfsplus/btree.c
index 050d29c0a5b5..bb5433608a42 100644
--- a/fs/hfsplus/btree.c
+++ b/fs/hfsplus/btree.c
@@ -22,6 +22,7 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id)
        struct hfs_btree *tree;
        struct hfs_btree_header_rec *head;
        struct address_space *mapping;
+        struct inode *inode;
        struct page *page;
        unsigned int size;
@@ -33,9 +34,10 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id)
        spin_lock_init(&tree->hash_lock);
        tree->sb = sb;
        tree->cnid = id;
-        tree->inode = iget(sb, id);
+        inode = hfsplus_iget(sb, id);
-        if (!tree->inode)
+        if (IS_ERR(inode))
                goto free_tree;
+        tree->inode = inode;
        mapping = tree->inode->i_mapping;
        page = read_mapping_page(mapping, 0, NULL);
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index 1955ee61251c..29683645fa0a 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -97,9 +97,9 @@ again:
                goto fail;
        }
        hfs_find_exit(&fd);
-        inode = iget(dir->i_sb, cnid);
+        inode = hfsplus_iget(dir->i_sb, cnid);
-        if (!inode)
+        if (IS_ERR(inode))
-                return ERR_PTR(-EACCES);
+                return ERR_CAST(inode);
        if (S_ISREG(inode->i_mode))
                HFSPLUS_I(inode).dev = linkid;
 out:
diff --git a/fs/hfsplus/hfsplus_fs.h b/fs/hfsplus/hfsplus_fs.h
index d9f5eda6d039..d72d0a8b25aa 100644
--- a/fs/hfsplus/hfsplus_fs.h
+++ b/fs/hfsplus/hfsplus_fs.h
@@ -345,6 +345,9 @@ int hfsplus_parse_options(char *, struct hfsplus_sb_info *);
 void hfsplus_fill_defaults(struct hfsplus_sb_info *);
 int hfsplus_show_options(struct seq_file *, struct vfsmount *);
+/* super.c */
+struct inode *hfsplus_iget(struct super_block *, unsigned long);
 /* tables.c */
 extern u16 hfsplus_case_fold_table[];
 extern u16 hfsplus_decompose_table[];
diff --git a/fs/hfsplus/super.c b/fs/hfsplus/super.c
index ecf70dafb643..b0f9ad362d1d 100644
--- a/fs/hfsplus/super.c
+++ b/fs/hfsplus/super.c
@@ -20,11 +20,18 @@ static void hfsplus_destroy_inode(struct inode *inode);
 #include "hfsplus_fs.h"
-static void hfsplus_read_inode(struct inode *inode)
+struct inode *hfsplus_iget(struct super_block *sb, unsigned long ino)
 {
        struct hfs_find_data fd;
        struct hfsplus_vh *vhdr;
-        int err;
+        struct inode *inode;
+        long err = -EIO;
+        inode = iget_locked(sb, ino);
+        if (!inode)
+                return ERR_PTR(-ENOMEM);
+        if (!(inode->i_state & I_NEW))
+                return inode;
        INIT_LIST_HEAD(&HFSPLUS_I(inode).open_dir_list);
        init_MUTEX(&HFSPLUS_I(inode).extents_lock);
@@ -41,7 +48,7 @@ static void hfsplus_read_inode(struct inode *inode)
                hfs_find_exit(&fd);
                if (err)
                        goto bad_inode;
-                return;
+                goto done;
        }
        vhdr = HFSPLUS_SB(inode->i_sb).s_vhdr;
        switch(inode->i_ino) {
@@ -70,10 +77,13 @@ static void hfsplus_read_inode(struct inode *inode)
                goto bad_inode;
        }
-        return;
+done:
+        unlock_new_inode(inode);
+        return inode;
- bad_inode:
+bad_inode:
-        make_bad_inode(inode);
+        iget_failed(inode);
+        return ERR_PTR(err);
 }
 static int hfsplus_write_inode(struct inode *inode, int unused)
@@ -262,7 +272,6 @@ static int hfsplus_remount(struct super_block *sb, int *flags, char *data)
 static const struct super_operations hfsplus_sops = {
        .alloc_inode    = hfsplus_alloc_inode,
        .destroy_inode  = hfsplus_destroy_inode,
-        .read_inode     = hfsplus_read_inode,
        .write_inode    = hfsplus_write_inode,
        .clear_inode    = hfsplus_clear_inode,
        .put_super      = hfsplus_put_super,
@@ -278,7 +287,7 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
        struct hfsplus_sb_info *sbi;
        hfsplus_cat_entry entry;
        struct hfs_find_data fd;
-        struct inode *root;
+        struct inode *root, *inode;
        struct qstr str;
        struct nls_table *nls = NULL;
        int err = -EINVAL;
@@ -366,18 +375,25 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
                goto cleanup;
        }
-        HFSPLUS_SB(sb).alloc_file = iget(sb, HFSPLUS_ALLOC_CNID);
+        inode = hfsplus_iget(sb, HFSPLUS_ALLOC_CNID);
-        if (!HFSPLUS_SB(sb).alloc_file) {
+        if (IS_ERR(inode)) {
                printk(KERN_ERR "hfs: failed to load allocation file\n");
+                err = PTR_ERR(inode);
                goto cleanup;
        }
+        HFSPLUS_SB(sb).alloc_file = inode;
        /* Load the root directory */
-        root = iget(sb, HFSPLUS_ROOT_CNID);
+        root = hfsplus_iget(sb, HFSPLUS_ROOT_CNID);
+        if (IS_ERR(root)) {
+                printk(KERN_ERR "hfs: failed to load root directory\n");
+                err = PTR_ERR(root);
+                goto cleanup;
+        }
        sb->s_root = d_alloc_root(root);
        if (!sb->s_root) {
-                printk(KERN_ERR "hfs: failed to load root directory\n");
                iput(root);
+                err = -ENOMEM;
                goto cleanup;
        }
        sb->s_root->d_op = &hfsplus_dentry_operations;
@@ -390,9 +406,12 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
                hfs_find_exit(&fd);
                if (entry.type != cpu_to_be16(HFSPLUS_FOLDER))
                        goto cleanup;
-                HFSPLUS_SB(sb).hidden_dir = iget(sb, be32_to_cpu(entry.folder.id));
+                inode = hfsplus_iget(sb, be32_to_cpu(entry.folder.id));
-                if (!HFSPLUS_SB(sb).hidden_dir)
+                if (IS_ERR(inode)) {
+                        err = PTR_ERR(inode);
                        goto cleanup;
+                }
+                HFSPLUS_SB(sb).hidden_dir = inode;
        } else
                hfs_find_exit(&fd);
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index 8966b050196e..2b9b35733aac 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -202,7 +202,7 @@ static char *follow_link(char *link)
        return ERR_PTR(n);
 }
-static int read_inode(struct inode *ino)
+static int hostfs_read_inode(struct inode *ino)
 {
        char *name;
        int err = 0;
@@ -233,6 +233,25 @@ static int read_inode(struct inode *ino)
        return err;
 }
+static struct inode *hostfs_iget(struct super_block *sb)
+{
+        struct inode *inode;
+        long ret;
+        inode = iget_locked(sb, 0);
+        if (!inode)
+                return ERR_PTR(-ENOMEM);
+        if (inode->i_state & I_NEW) {
+                ret = hostfs_read_inode(inode);
+                if (ret < 0) {
+                        iget_failed(inode);
+                        return ERR_PTR(ret);
+                }
+                unlock_new_inode(inode);
+        }
+        return inode;
+}
 int hostfs_statfs(struct dentry *dentry, struct kstatfs *sf)
 {
        /*
@@ -303,17 +322,11 @@ static void hostfs_destroy_inode(struct inode *inode)
        kfree(HOSTFS_I(inode));
 }
-static void hostfs_read_inode(struct inode *inode)
-{
-        read_inode(inode);
-}
 static const struct super_operations hostfs_sbops = {
        .alloc_inode    = hostfs_alloc_inode,
        .drop_inode     = generic_delete_inode,
        .delete_inode   = hostfs_delete_inode,
        .destroy_inode  = hostfs_destroy_inode,
-        .read_inode     = hostfs_read_inode,
        .statfs         = hostfs_statfs,
 };
@@ -571,10 +584,11 @@ int hostfs_create(struct inode *dir, struct dentry *dentry, int mode,
        char *name;
        int error, fd;
-        error = -ENOMEM;
+        inode = hostfs_iget(dir->i_sb);
-        inode = iget(dir->i_sb, 0);
+        if (IS_ERR(inode)) {
-        if (inode == NULL)
+                error = PTR_ERR(inode);
                goto out;
+        }
        error = init_inode(inode, dentry);
        if (error)
@@ -615,10 +629,11 @@ struct dentry *hostfs_lookup(struct inode *ino, struct dentry *dentry,
        char *name;
        int err;
-        err = -ENOMEM;
+        inode = hostfs_iget(ino->i_sb);
-        inode = iget(ino->i_sb, 0);
+        if (IS_ERR(inode)) {
-        if (inode == NULL)
+                err = PTR_ERR(inode);
                goto out;
+        }
        err = init_inode(inode, dentry);
        if (err)
@@ -736,11 +751,13 @@ int hostfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
 {
        struct inode *inode;
        char *name;
-        int err = -ENOMEM;
+        int err;
-        inode = iget(dir->i_sb, 0);
+        inode = hostfs_iget(dir->i_sb);
-        if (inode == NULL)
+        if (IS_ERR(inode)) {
+                err = PTR_ERR(inode);
                goto out;
+        }
        err = init_inode(inode, dentry);
        if (err)
@@ -952,9 +969,11 @@ static int hostfs_fill_sb_common(struct super_block *sb, void *d, int silent)
        sprintf(host_root_path, "%s/%s", root_ino, req_root);
-        root_inode = iget(sb, 0);
+        root_inode = hostfs_iget(sb);
-        if (root_inode == NULL)
+        if (IS_ERR(root_inode)) {
+                err = PTR_ERR(root_inode);
                goto out_free;
+        }
        err = init_inode(root_inode, NULL);
        if (err)
@@ -972,7 +991,7 @@ static int hostfs_fill_sb_common(struct super_block *sb, void *d, int silent)
        if (sb->s_root == NULL)
                goto out_put;
-        err = read_inode(root_inode);
+        err = hostfs_read_inode(root_inode);
        if (err) {
                /* No iput in this case because the dput does that for us */
                dput(sb->s_root);
diff --git a/fs/hppfs/hppfs_kern.c b/fs/hppfs/hppfs_kern.c
index affb7412125e..a1e1f0f61aa5 100644
--- a/fs/hppfs/hppfs_kern.c
+++ b/fs/hppfs/hppfs_kern.c
@@ -155,6 +155,20 @@ static void hppfs_read_inode(struct inode *ino)
        ino->i_blocks = proc_ino->i_blocks;
 }
+static struct inode *hppfs_iget(struct super_block *sb)
+{
+        struct inode *inode;
+        inode = iget_locked(sb, 0);
+        if (!inode)
+                return ERR_PTR(-ENOMEM);
+        if (inode->i_state & I_NEW) {
+                hppfs_read_inode(inode);
+                unlock_new_inode(inode);
+        }
+        return inode;
+}
 static struct dentry *hppfs_lookup(struct inode *ino, struct dentry *dentry,
                                  struct nameidata *nd)
 {
@@ -190,9 +204,11 @@ static struct dentry *hppfs_lookup(struct inode *ino, struct dentry *dentry,
        if(IS_ERR(proc_dentry))
                return(proc_dentry);
-        inode = iget(ino->i_sb, 0);
+        inode = hppfs_iget(ino->i_sb);
-        if(inode == NULL)
+        if (IS_ERR(inode)) {
+                err = PTR_ERR(inode);
                goto out_dput;
+        }
        err = init_inode(inode, proc_dentry);
        if(err)
@@ -652,7 +668,6 @@ static void hppfs_destroy_inode(struct inode *inode)
 static const struct super_operations hppfs_sbops = {
        .alloc_inode    = hppfs_alloc_inode,
        .destroy_inode  = hppfs_destroy_inode,
-        .read_inode     = hppfs_read_inode,
        .delete_inode   = hppfs_delete_inode,
        .statfs         = hppfs_statfs,
 };
@@ -745,9 +760,11 @@ static int hppfs_fill_super(struct super_block *sb, void *d, int silent)
        sb->s_magic = HPPFS_SUPER_MAGIC;
        sb->s_op = &hppfs_sbops;
-        root_inode = iget(sb, 0);
+        root_inode = hppfs_iget(sb);
-        if(root_inode == NULL)
+        if (IS_ERR(root_inode)) {
+                err = PTR_ERR(root_inode);
                goto out;
+        }
        err = init_inode(root_inode, proc_sb->s_root);
        if(err)
diff --git a/fs/inode.c b/fs/inode.c
index 276ffd6b6fdd..53245ffcf93d 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -928,8 +928,6 @@ EXPORT_SYMBOL(ilookup);
 * @set:        callback used to initialize a new struct inode
 * @data:       opaque data pointer to pass to @test and @set
 *
- * This is iget() without the read_inode() portion of get_new_inode().
- *
 * iget5_locked() uses ifind() to search for the inode specified by @hashval
 * and @data in the inode cache and if present it is returned with an increased
 * reference count. This is a generalized version of iget_locked() for file
@@ -966,8 +964,6 @@ EXPORT_SYMBOL(iget5_locked);
 * @sb:         super block of file system
 * @ino:        inode number to get
 *
- * This is iget() without the read_inode() portion of get_new_inode_fast().
- *
 * iget_locked() uses ifind_fast() to search for the inode specified by @ino in
 * the inode cache and if present it is returned with an increased reference
 * count. This is for file systems where the inode number is sufficient for
diff --git a/fs/ioctl.c b/fs/ioctl.c
index c2a773e8620b..683002fefa55 100644
--- a/fs/ioctl.c
+++ b/fs/ioctl.c
@@ -12,12 +12,24 @@
 #include <linux/fs.h>
 #include <linux/security.h>
 #include <linux/module.h>
+#include <linux/uaccess.h>
-#include <asm/uaccess.h>
 #include <asm/ioctls.h>
-static long do_ioctl(struct file *filp, unsigned int cmd,
+/**
-                unsigned long arg)
+ * vfs_ioctl - call filesystem specific ioctl methods
+ * @filp: [in]     open file to invoke ioctl method on
+ * @cmd:  [in]     ioctl command to execute
+ * @arg:  [in/out] command-specific argument for ioctl
+ *
+ * Invokes filesystem specific ->unlocked_ioctl, if one exists; otherwise
+ * invokes * filesystem specific ->ioctl method.  If neither method exists,
+ * returns -ENOTTY.
+ *
+ * Returns 0 on success, -errno on error.
+ */
+long vfs_ioctl(struct file *filp, unsigned int cmd,
+               unsigned long arg)
 {
        int error = -ENOTTY;
@@ -40,123 +52,148 @@ static long do_ioctl(struct file *filp, unsigned int cmd,
        return error;
 }
+static int ioctl_fibmap(struct file *filp, int __user *p)
+{
+        struct address_space *mapping = filp->f_mapping;
+        int res, block;
+        /* do we support this mess? */
+        if (!mapping->a_ops->bmap)
+                return -EINVAL;
+        if (!capable(CAP_SYS_RAWIO))
+                return -EPERM;
+        res = get_user(block, p);
+        if (res)
+                return res;
+        lock_kernel();
+        res = mapping->a_ops->bmap(mapping, block);
+        unlock_kernel();
+        return put_user(res, p);
+}
 static int file_ioctl(struct file *filp, unsigned int cmd,
                unsigned long arg)
 {
-        int error;
+        struct inode *inode = filp->f_path.dentry->d_inode;
-        int block;
-        struct inode * inode = filp->f_path.dentry->d_inode;
        int __user *p = (int __user *)arg;
        switch (cmd) {
-                case FIBMAP:
+        case FIBMAP:
-                {
+                return ioctl_fibmap(filp, p);
-                        struct address_space *mapping = filp->f_mapping;
+        case FIGETBSZ:
-                        int res;
+                return put_user(inode->i_sb->s_blocksize, p);
-                        /* do we support this mess? */
+        case FIONREAD:
-                        if (!mapping->a_ops->bmap)
+                return put_user(i_size_read(inode) - filp->f_pos, p);
-                                return -EINVAL;
+        }
-                        if (!capable(CAP_SYS_RAWIO))
-                                return -EPERM;
-                        if ((error = get_user(block, p)) != 0)
-                                return error;
+        return vfs_ioctl(filp, cmd, arg);
+}
+static int ioctl_fionbio(struct file *filp, int __user *argp)
+{
+        unsigned int flag;
+        int on, error;
+        error = get_user(on, argp);
+        if (error)
+                return error;
+        flag = O_NONBLOCK;
+#ifdef __sparc__
+        /* SunOS compatibility item. */
+        if (O_NONBLOCK != O_NDELAY)
+                flag |= O_NDELAY;
+#endif
+        if (on)
+                filp->f_flags |= flag;
+        else
+                filp->f_flags &= ~flag;
+        return error;
+}
+static int ioctl_fioasync(unsigned int fd, struct file *filp,
+                          int __user *argp)
+{
+        unsigned int flag;
+        int on, error;
+        error = get_user(on, argp);
+        if (error)
+                return error;
+        flag = on ? FASYNC : 0;
+        /* Did FASYNC state change ? */
+        if ((flag ^ filp->f_flags) & FASYNC) {
+                if (filp->f_op && filp->f_op->fasync) {
                        lock_kernel();
-                        res = mapping->a_ops->bmap(mapping, block);
+                        error = filp->f_op->fasync(fd, filp, on);
                        unlock_kernel();
-                        return put_user(res, p);
+                } else
-                }
+                        error = -ENOTTY;
-                case FIGETBSZ:
-                        return put_user(inode->i_sb->s_blocksize, p);
-                case FIONREAD:
-                        return put_user(i_size_read(inode) - filp->f_pos, p);
        }
+        if (error)
+                return error;
-        return do_ioctl(filp, cmd, arg);
+        if (on)
+                filp->f_flags |= FASYNC;
+        else
+                filp->f_flags &= ~FASYNC;
+        return error;
 }
 /*
 * When you add any new common ioctls to the switches above and below
 * please update compat_sys_ioctl() too.
 *
- * vfs_ioctl() is not for drivers and not intended to be EXPORT_SYMBOL()'d.
+ * do_vfs_ioctl() is not for drivers and not intended to be EXPORT_SYMBOL()'d.
 * It's just a simple helper for sys_ioctl and compat_sys_ioctl.
 */
-int vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd, unsigned long arg)
+int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
+             unsigned long arg)
 {
-        unsigned int flag;
+        int error = 0;
-        int on, error = 0;
+        int __user *argp = (int __user *)arg;
        switch (cmd) {
-                case FIOCLEX:
+        case FIOCLEX:
-                        set_close_on_exec(fd, 1);
+                set_close_on_exec(fd, 1);
-                        break;
+                break;
-                case FIONCLEX:
+        case FIONCLEX:
-                        set_close_on_exec(fd, 0);
+                set_close_on_exec(fd, 0);
-                        break;
+                break;
-                case FIONBIO:
+        case FIONBIO:
-                        if ((error = get_user(on, (int __user *)arg)) != 0)
+                error = ioctl_fionbio(filp, argp);
-                                break;
+                break;
-                        flag = O_NONBLOCK;
-#ifdef __sparc__
+        case FIOASYNC:
-                        /* SunOS compatibility item. */
+                error = ioctl_fioasync(fd, filp, argp);
-                        if(O_NONBLOCK != O_NDELAY)
+                break;
-                                flag |= O_NDELAY;
-#endif
+        case FIOQSIZE:
-                        if (on)
+                if (S_ISDIR(filp->f_path.dentry->d_inode->i_mode) ||
-                                filp->f_flags |= flag;
+                    S_ISREG(filp->f_path.dentry->d_inode->i_mode) ||
-                        else
+                    S_ISLNK(filp->f_path.dentry->d_inode->i_mode)) {
-                                filp->f_flags &= ~flag;
+                        loff_t res =
-                        break;
+                                inode_get_bytes(filp->f_path.dentry->d_inode);
+                        error = copy_to_user((loff_t __user *)arg, &res,
-                case FIOASYNC:
+                                             sizeof(res)) ? -EFAULT : 0;
-                        if ((error = get_user(on, (int __user *)arg)) != 0)
+                } else
-                                break;
+                        error = -ENOTTY;
-                        flag = on ? FASYNC : 0;
+                break;
+        default:
-                        /* Did FASYNC state change ? */
+                if (S_ISREG(filp->f_path.dentry->d_inode->i_mode))
-                        if ((flag ^ filp->f_flags) & FASYNC) {
+                        error = file_ioctl(filp, cmd, arg);
-                                if (filp->f_op && filp->f_op->fasync) {
+                else
-                                        lock_kernel();
+                        error = vfs_ioctl(filp, cmd, arg);
-                                        error = filp->f_op->fasync(fd, filp, on);
+                break;
-                                        unlock_kernel();
-                                }
-                                else error = -ENOTTY;
-                        }
-                        if (error != 0)
-                                break;
-                        if (on)
-                                filp->f_flags |= FASYNC;
-                        else
-                                filp->f_flags &= ~FASYNC;
-                        break;
-                case FIOQSIZE:
-                        if (S_ISDIR(filp->f_path.dentry->d_inode->i_mode) ||
-                            S_ISREG(filp->f_path.dentry->d_inode->i_mode) ||
-                            S_ISLNK(filp->f_path.dentry->d_inode->i_mode)) {
-                                loff_t res = inode_get_bytes(filp->f_path.dentry->d_inode);
-                                error = copy_to_user((loff_t __user *)arg, &res, sizeof(res)) ? -EFAULT : 0;
-                        }
-                        else
-                                error = -ENOTTY;
-                        break;
-                default:
-                        if (S_ISREG(filp->f_path.dentry->d_inode->i_mode))
-                                error = file_ioctl(filp, cmd, arg);
-                        else
-                                error = do_ioctl(filp, cmd, arg);
-                        break;
        }
        return error;
 }
 asmlinkage long sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
 {
-        struct file * filp;
+        struct file *filp;
        int error = -EBADF;
        int fput_needed;
@@ -168,7 +205,7 @@ asmlinkage long sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
        if (error)
                goto out_fput;
-        error = vfs_ioctl(filp, fd, cmd, arg);
+        error = do_vfs_ioctl(filp, fd, cmd, arg);
 out_fput:
        fput_light(filp, fput_needed);
 out:
diff --git a/fs/isofs/export.c b/fs/isofs/export.c
index 29f9753ae5e5..bb219138331a 100644
--- a/fs/isofs/export.c
+++ b/fs/isofs/export.c
@@ -26,11 +26,9 @@ isofs_export_iget(struct super_block *sb,
        if (block == 0)
                return ERR_PTR(-ESTALE);
        inode = isofs_iget(sb, block, offset);
-        if (inode == NULL)
+        if (IS_ERR(inode))
-                return ERR_PTR(-ENOMEM);
+                return ERR_CAST(inode);
-        if (is_bad_inode(inode)
+        if (generation && inode->i_generation != generation) {
-            || (generation && inode->i_generation != generation))
-        {
                iput(inode);
                return ERR_PTR(-ESTALE);
        }
@@ -110,8 +108,10 @@ static struct dentry *isofs_export_get_parent(struct dentry *child)
        parent_inode = isofs_iget(child_inode->i_sb,
                                  parent_block,
                                  parent_offset);
-        if (parent_inode == NULL) {
+        if (IS_ERR(parent_inode)) {
-                rv = ERR_PTR(-EACCES);
+                rv = ERR_CAST(parent_inode);
+                if (rv != ERR_PTR(-ENOMEM))
+                        rv = ERR_PTR(-EACCES);
                goto out;
        }
diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index 09e3d306e96f..875d37fb6c70 100644
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -54,7 +54,7 @@ static void isofs_put_super(struct super_block *sb)
        return;
 }
-static void isofs_read_inode(struct inode *);
+static int isofs_read_inode(struct inode *);
 static int isofs_statfs (struct dentry *, struct kstatfs *);
 static struct kmem_cache *isofs_inode_cachep;
@@ -107,7 +107,6 @@ static int isofs_remount(struct super_block *sb, int *flags, char *data)
 static const struct super_operations isofs_sops = {
        .alloc_inode    = isofs_alloc_inode,
        .destroy_inode  = isofs_destroy_inode,
-        .read_inode     = isofs_read_inode,
        .put_super      = isofs_put_super,
        .statfs         = isofs_statfs,
        .remount_fs     = isofs_remount,
@@ -552,7 +551,7 @@ static int isofs_fill_super(struct super_block *s, void *data, int silent)
        int joliet_level = 0;
        int iso_blknum, block;
        int orig_zonesize;
-        int table;
+        int table, error = -EINVAL;
        unsigned int vol_desc_start;
        sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
@@ -810,6 +809,8 @@ root_found:
         * we then decide whether to use the Joliet descriptor.
         */
        inode = isofs_iget(s, sbi->s_firstdatazone, 0);
+        if (IS_ERR(inode))
+                goto out_no_root;
        /*
         * If this disk has both Rock Ridge and Joliet on it, then we
@@ -829,6 +830,8 @@ root_found:
                                "ISOFS: changing to secondary root\n");
                        iput(inode);
                        inode = isofs_iget(s, sbi->s_firstdatazone, 0);
+                        if (IS_ERR(inode))
+                                goto out_no_root;
                }
        }
@@ -842,8 +845,6 @@ root_found:
        sbi->s_joliet_level = joliet_level;
        /* check the root inode */
-        if (!inode)
-                goto out_no_root;
        if (!inode->i_op)
                goto out_bad_root;
@@ -876,11 +877,14 @@ root_found:
         */
 out_bad_root:
        printk(KERN_WARNING "%s: root inode not initialized\n", __func__);
-        goto out_iput;
-out_no_root:
-        printk(KERN_WARNING "%s: get root inode failed\n", __func__);
 out_iput:
        iput(inode);
+        goto out_no_inode;
+out_no_root:
+        error = PTR_ERR(inode);
+        if (error != -ENOMEM)
+                printk(KERN_WARNING "%s: get root inode failed\n", __func__);
+out_no_inode:
 #ifdef CONFIG_JOLIET
        if (sbi->s_nls_iocharset)
                unload_nls(sbi->s_nls_iocharset);
@@ -908,7 +912,7 @@ out_freesbi:
        kfree(opt.iocharset);
        kfree(sbi);
        s->s_fs_info = NULL;
-        return -EINVAL;
+        return error;
 }
 static int isofs_statfs (struct dentry *dentry, struct kstatfs *buf)
@@ -930,7 +934,7 @@ static int isofs_statfs (struct dentry *dentry, struct kstatfs *buf)
 /*
 * Get a set of blocks; filling in buffer_heads if already allocated
 * or getblk() if they are not.  Returns the number of blocks inserted
- * (0 == error.)
+ * (-ve == error.)
 */
 int isofs_get_blocks(struct inode *inode, sector_t iblock_s,
                     struct buffer_head **bh, unsigned long nblocks)
@@ -940,11 +944,12 @@ int isofs_get_blocks(struct inode *inode, sector_t iblock_s,
        unsigned int firstext;
        unsigned long nextblk, nextoff;
        long iblock = (long)iblock_s;
-        int section, rv;
+        int section, rv, error;
        struct iso_inode_info *ei = ISOFS_I(inode);
        lock_kernel();
+        error = -EIO;
        rv = 0;
        if (iblock < 0 || iblock != iblock_s) {
                printk(KERN_DEBUG "%s: block number too large\n", __func__);
@@ -983,8 +988,10 @@ int isofs_get_blocks(struct inode *inode, sector_t iblock_s,
                        offset += sect_size;
                        ninode = isofs_iget(inode->i_sb, nextblk, nextoff);
-                        if (!ninode)
+                        if (IS_ERR(ninode)) {
+                                error = PTR_ERR(ninode);
                                goto abort;
+                        }
                        firstext  = ISOFS_I(ninode)->i_first_extent;
                        sect_size = ISOFS_I(ninode)->i_section_size >> ISOFS_BUFFER_BITS(ninode);
                        nextblk   = ISOFS_I(ninode)->i_next_section_block;
@@ -1015,9 +1022,10 @@ int isofs_get_blocks(struct inode *inode, sector_t iblock_s,
                rv++;
        }
+        error = 0;
 abort:
        unlock_kernel();
-        return rv;
+        return rv != 0 ? rv : error;
 }
 /*
@@ -1026,12 +1034,15 @@ abort:
 static int isofs_get_block(struct inode *inode, sector_t iblock,
                    struct buffer_head *bh_result, int create)
 {
+        int ret;
        if (create) {
                printk(KERN_DEBUG "%s: Kernel tries to allocate a block\n", __func__);
                return -EROFS;
        }
-        return isofs_get_blocks(inode, iblock, &bh_result, 1) ? 0 : -EIO;
+        ret = isofs_get_blocks(inode, iblock, &bh_result, 1);
+        return ret < 0 ? ret : 0;
 }
 static int isofs_bmap(struct inode *inode, sector_t block)
@@ -1186,7 +1197,7 @@ out_toomany:
        goto out;
 }
-static void isofs_read_inode(struct inode *inode)
+static int isofs_read_inode(struct inode *inode)
 {
        struct super_block *sb = inode->i_sb;
        struct isofs_sb_info *sbi = ISOFS_SB(sb);
@@ -1199,6 +1210,7 @@ static void isofs_read_inode(struct inode *inode)
        unsigned int de_len;
        unsigned long offset;
        struct iso_inode_info *ei = ISOFS_I(inode);
+        int ret = -EIO;
        block = ei->i_iget5_block;
        bh = sb_bread(inode->i_sb, block);
@@ -1216,6 +1228,7 @@ static void isofs_read_inode(struct inode *inode)
                tmpde = kmalloc(de_len, GFP_KERNEL);
                if (tmpde == NULL) {
                        printk(KERN_INFO "%s: out of memory\n", __func__);
+                        ret = -ENOMEM;
                        goto fail;
                }
                memcpy(tmpde, bh->b_data + offset, frag1);
@@ -1259,8 +1272,10 @@ static void isofs_read_inode(struct inode *inode)
        ei->i_section_size = isonum_733(de->size);
        if (de->flags[-high_sierra] & 0x80) {
-                if(isofs_read_level3_size(inode))
+                ret = isofs_read_level3_size(inode);
+                if (ret < 0)
                        goto fail;
+                ret = -EIO;
        } else {
                ei->i_next_section_block = 0;
                ei->i_next_section_offset = 0;
@@ -1346,16 +1361,16 @@ static void isofs_read_inode(struct inode *inode)
                /* XXX - parse_rock_ridge_inode() had already set i_rdev. */
                init_special_inode(inode, inode->i_mode, inode->i_rdev);
+        ret = 0;
 out:
        kfree(tmpde);
        if (bh)
                brelse(bh);
-        return;
+        return ret;
 out_badread:
        printk(KERN_WARNING "ISOFS: unable to read i-node block\n");
 fail:
-        make_bad_inode(inode);
        goto out;
 }
@@ -1394,9 +1409,10 @@ struct inode *isofs_iget(struct super_block *sb,
        unsigned long hashval;
        struct inode *inode;
        struct isofs_iget5_callback_data data;
+        long ret;
        if (offset >= 1ul << sb->s_blocksize_bits)
-                return NULL;
+                return ERR_PTR(-EINVAL);
        data.block = block;
        data.offset = offset;
@@ -1406,9 +1422,17 @@ struct inode *isofs_iget(struct super_block *sb,
        inode = iget5_locked(sb, hashval, &isofs_iget5_test,
                                &isofs_iget5_set, &data);
-        if (inode && (inode->i_state & I_NEW)) {
+        if (!inode)
-                sb->s_op->read_inode(inode);
+                return ERR_PTR(-ENOMEM);
-                unlock_new_inode(inode);
+        if (inode->i_state & I_NEW) {
+                ret = isofs_read_inode(inode);
+                if (ret < 0) {
+                        iget_failed(inode);
+                        inode = ERR_PTR(ret);
+                } else {
+                        unlock_new_inode(inode);
+                }
        }
        return inode;
diff --git a/fs/isofs/namei.c b/fs/isofs/namei.c
index e2b4dad39ca9..344b247bc29a 100644
--- a/fs/isofs/namei.c
+++ b/fs/isofs/namei.c
@@ -179,9 +179,9 @@ struct dentry *isofs_lookup(struct inode *dir, struct dentry *dentry, struct nam
        inode = NULL;
        if (found) {
                inode = isofs_iget(dir->i_sb, block, offset);
-                if (!inode) {
+                if (IS_ERR(inode)) {
                        unlock_kernel();
-                        return ERR_PTR(-EACCES);
+                        return ERR_CAST(inode);
                }
        }
        unlock_kernel();
diff --git a/fs/isofs/rock.c b/fs/isofs/rock.c
index f3a1db3098de..6bd48f0a7047 100644
--- a/fs/isofs/rock.c
+++ b/fs/isofs/rock.c
@@ -474,8 +474,10 @@ repeat:
                            isofs_iget(inode->i_sb,
                                       ISOFS_I(inode)->i_first_extent,
                                       0);
-                        if (!reloc)
+                        if (IS_ERR(reloc)) {
+                                ret = PTR_ERR(reloc);
                                goto out;
+                        }
                        inode->i_mode = reloc->i_mode;
                        inode->i_nlink = reloc->i_nlink;
                        inode->i_uid = reloc->i_uid;
diff --git a/fs/jffs2/acl.c b/fs/jffs2/acl.c
index 77fc5838609c..4c80404a9aba 100644
--- a/fs/jffs2/acl.c
+++ b/fs/jffs2/acl.c
@@ -176,7 +176,7 @@ static void jffs2_iset_acl(struct inode *inode, struct posix_acl **i_acl, struct
        spin_unlock(&inode->i_lock);
 }
-struct posix_acl *jffs2_get_acl(struct inode *inode, int type)
+static struct posix_acl *jffs2_get_acl(struct inode *inode, int type)
 {
        struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
        struct posix_acl *acl;
@@ -345,8 +345,10 @@ int jffs2_init_acl_pre(struct inode *dir_i, struct inode *inode, int *i_mode)
                if (!clone)
                        return -ENOMEM;
                rc = posix_acl_create_masq(clone, (mode_t *)i_mode);
-                if (rc < 0)
+                if (rc < 0) {
+                        posix_acl_release(clone);
                        return rc;
+                }
                if (rc > 0)
                        jffs2_iset_acl(inode, &f->i_acl_access, clone);
diff --git a/fs/jffs2/acl.h b/fs/jffs2/acl.h
index 76c6ebd1acd9..0bb7f003fd80 100644
--- a/fs/jffs2/acl.h
+++ b/fs/jffs2/acl.h
@@ -28,7 +28,6 @@ struct jffs2_acl_header {
 #define JFFS2_ACL_NOT_CACHED ((void *)-1)
-extern struct posix_acl *jffs2_get_acl(struct inode *inode, int type);
 extern int jffs2_permission(struct inode *, int, struct nameidata *);
 extern int jffs2_acl_chmod(struct inode *);
 extern int jffs2_init_acl_pre(struct inode *, struct inode *, int *);
@@ -40,7 +39,6 @@ extern struct xattr_handler jffs2_acl_default_xattr_handler;
 #else
-#define jffs2_get_acl(inode, type)              (NULL)
 #define jffs2_permission                        (NULL)
 #define jffs2_acl_chmod(inode)                  (0)
 #define jffs2_init_acl_pre(dir_i,inode,mode)    (0)
diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index 787e392ffd41..f948f7e6ec82 100644
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -101,10 +101,10 @@ static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target,
                ino = fd->ino;
        up(&dir_f->sem);
        if (ino) {
-                inode = iget(dir_i->i_sb, ino);
+                inode = jffs2_iget(dir_i->i_sb, ino);
-                if (!inode) {
+                if (IS_ERR(inode)) {
                        printk(KERN_WARNING "iget() failed for ino #%u\n", ino);
-                        return (ERR_PTR(-EIO));
+                        return ERR_CAST(inode);
                }
        }
diff --git a/fs/jffs2/fs.c b/fs/jffs2/fs.c
index d2e06f7ea96f..e26ea78c7892 100644
--- a/fs/jffs2/fs.c
+++ b/fs/jffs2/fs.c
@@ -97,11 +97,7 @@ int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
        ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);
        if (ivalid & ATTR_MODE)
-                if (iattr->ia_mode & S_ISGID &&
+                ri->mode = cpu_to_jemode(iattr->ia_mode);
-                    !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
-                        ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
-                else
-                        ri->mode = cpu_to_jemode(iattr->ia_mode);
        else
                ri->mode = cpu_to_jemode(inode->i_mode);
@@ -230,16 +226,23 @@ void jffs2_clear_inode (struct inode *inode)
        jffs2_do_clear_inode(c, f);
 }
-void jffs2_read_inode (struct inode *inode)
+struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
 {
        struct jffs2_inode_info *f;
        struct jffs2_sb_info *c;
        struct jffs2_raw_inode latest_node;
        union jffs2_device_node jdev;
+        struct inode *inode;
        dev_t rdev = 0;
        int ret;
-        D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
+        D1(printk(KERN_DEBUG "jffs2_iget(): ino == %lu\n", ino));
+        inode = iget_locked(sb, ino);
+        if (!inode)
+                return ERR_PTR(-ENOMEM);
+        if (!(inode->i_state & I_NEW))
+                return inode;
        f = JFFS2_INODE_INFO(inode);
        c = JFFS2_SB_INFO(inode->i_sb);
@@ -250,9 +253,9 @@ void jffs2_read_inode (struct inode *inode)
        ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
        if (ret) {
-                make_bad_inode(inode);
                up(&f->sem);
-                return;
+                iget_failed(inode);
+                return ERR_PTR(ret);
        }
        inode->i_mode = jemode_to_cpu(latest_node.mode);
        inode->i_uid = je16_to_cpu(latest_node.uid);
@@ -303,19 +306,14 @@ void jffs2_read_inode (struct inode *inode)
                if (f->metadata->size != sizeof(jdev.old) &&
                    f->metadata->size != sizeof(jdev.new)) {
                        printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
-                        up(&f->sem);
+                        goto error_io;
-                        jffs2_do_clear_inode(c, f);
-                        make_bad_inode(inode);
-                        return;
                }
                D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
-                if (jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size) < 0) {
+                ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
+                if (ret < 0) {
                        /* Eep */
                        printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
-                        up(&f->sem);
+                        goto error;
-                        jffs2_do_clear_inode(c, f);
-                        make_bad_inode(inode);
-                        return;
                }
                if (f->metadata->size == sizeof(jdev.old))
                        rdev = old_decode_dev(je16_to_cpu(jdev.old));
@@ -335,6 +333,16 @@ void jffs2_read_inode (struct inode *inode)
        up(&f->sem);
        D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
+        unlock_new_inode(inode);
+        return inode;
+error_io:
+        ret = -EIO;
+error:
+        up(&f->sem);
+        jffs2_do_clear_inode(c, f);
+        iget_failed(inode);
+        return ERR_PTR(ret);
 }
 void jffs2_dirty_inode(struct inode *inode)
@@ -522,15 +530,16 @@ int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
        if ((ret = jffs2_do_mount_fs(c)))
                goto out_inohash;
-        ret = -EINVAL;
        D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
-        root_i = iget(sb, 1);
+        root_i = jffs2_iget(sb, 1);
-        if (is_bad_inode(root_i)) {
+        if (IS_ERR(root_i)) {
                D1(printk(KERN_WARNING "get root inode failed\n"));
-                goto out_root_i;
+                ret = PTR_ERR(root_i);
+                goto out_root;
        }
+        ret = -ENOMEM;
        D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
        sb->s_root = d_alloc_root(root_i);
        if (!sb->s_root)
@@ -546,6 +555,7 @@ int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
 out_root_i:
        iput(root_i);
+out_root:
        jffs2_free_ino_caches(c);
        jffs2_free_raw_node_refs(c);
        if (jffs2_blocks_use_vmalloc(c))
@@ -615,9 +625,9 @@ struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
                   jffs2_do_unlink() would need the alloc_sem and we have it.
                   Just iget() it, and if read_inode() is necessary that's OK.
                */
-                inode = iget(OFNI_BS_2SFFJ(c), inum);
+                inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
-                if (!inode)
+                if (IS_ERR(inode))
-                        return ERR_PTR(-ENOMEM);
+                        return ERR_CAST(inode);
        }
        if (is_bad_inode(inode)) {
                printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
diff --git a/fs/jffs2/nodelist.c b/fs/jffs2/nodelist.c
index 4bf86088b3ae..87c6f555e1a0 100644
--- a/fs/jffs2/nodelist.c
+++ b/fs/jffs2/nodelist.c
@@ -32,15 +32,18 @@ void jffs2_add_fd_to_list(struct jffs2_sb_info *c, struct jffs2_full_dirent *new
                if ((*prev)->nhash == new->nhash && !strcmp((*prev)->name, new->name)) {
                        /* Duplicate. Free one */
                        if (new->version < (*prev)->version) {
-                                dbg_dentlist("Eep! Marking new dirent node is obsolete, old is \"%s\", ino #%u\n",
+                                dbg_dentlist("Eep! Marking new dirent node obsolete, old is \"%s\", ino #%u\n",
                                        (*prev)->name, (*prev)->ino);
                                jffs2_mark_node_obsolete(c, new->raw);
                                jffs2_free_full_dirent(new);
                        } else {
-                                dbg_dentlist("marking old dirent \"%s\", ino #%u bsolete\n",
+                                dbg_dentlist("marking old dirent \"%s\", ino #%u obsolete\n",
                                        (*prev)->name, (*prev)->ino);
                                new->next = (*prev)->next;
-                                jffs2_mark_node_obsolete(c, ((*prev)->raw));
+                                /* It may have been a 'placeholder' deletion dirent, 
+                                   if jffs2_can_mark_obsolete() (see jffs2_do_unlink()) */
+                                if ((*prev)->raw)
+                                        jffs2_mark_node_obsolete(c, ((*prev)->raw));
                                jffs2_free_full_dirent(*prev);
                                *prev = new;
                        }
diff --git a/fs/jffs2/os-linux.h b/fs/jffs2/os-linux.h
index bf64686cf098..1b10d2594092 100644
--- a/fs/jffs2/os-linux.h
+++ b/fs/jffs2/os-linux.h
@@ -175,7 +175,7 @@ extern const struct inode_operations jffs2_symlink_inode_operations;
 /* fs.c */
 int jffs2_setattr (struct dentry *, struct iattr *);
 int jffs2_do_setattr (struct inode *, struct iattr *);
-void jffs2_read_inode (struct inode *);
+struct inode *jffs2_iget(struct super_block *, unsigned long);
 void jffs2_clear_inode (struct inode *);
 void jffs2_dirty_inode(struct inode *inode);
 struct inode *jffs2_new_inode (struct inode *dir_i, int mode,
diff --git a/fs/jffs2/readinode.c b/fs/jffs2/readinode.c
index 6c1ba3566f58..e512a93d6249 100644
--- a/fs/jffs2/readinode.c
+++ b/fs/jffs2/readinode.c
@@ -37,23 +37,24 @@ static int check_node_data(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info
        BUG_ON(tn->csize == 0);
-        if (!jffs2_is_writebuffered(c))
-                goto adj_acc;
        /* Calculate how many bytes were already checked */
        ofs = ref_offset(ref) + sizeof(struct jffs2_raw_inode);
-        len = ofs % c->wbuf_pagesize;
+        len = tn->csize;
-        if (likely(len))
-                len = c->wbuf_pagesize - len;
+        if (jffs2_is_writebuffered(c)) {
+                int adj = ofs % c->wbuf_pagesize;
-        if (len >= tn->csize) {
+                if (likely(adj))
-                dbg_readinode("no need to check node at %#08x, data length %u, data starts at %#08x - it has already been checked.\n",
+                        adj = c->wbuf_pagesize - adj;
-                        ref_offset(ref), tn->csize, ofs);
-                goto adj_acc;
+                if (adj >= tn->csize) {
-        }
+                        dbg_readinode("no need to check node at %#08x, data length %u, data starts at %#08x - it has already been checked.\n",
+                                      ref_offset(ref), tn->csize, ofs);
+                        goto adj_acc;
+                }
-        ofs += len;
+                ofs += adj;
-        len = tn->csize - len;
+                len -= adj;
+        }
        dbg_readinode("check node at %#08x, data length %u, partial CRC %#08x, correct CRC %#08x, data starts at %#08x, start checking from %#08x - %u bytes.\n",
                ref_offset(ref), tn->csize, tn->partial_crc, tn->data_crc, ofs - len, ofs, len);
@@ -63,7 +64,7 @@ static int check_node_data(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info
         * adding and jffs2_flash_read_end() interface. */
        if (c->mtd->point) {
                err = c->mtd->point(c->mtd, ofs, len, &retlen, &buffer);
-                if (!err && retlen < tn->csize) {
+                if (!err && retlen < len) {
                        JFFS2_WARNING("MTD point returned len too short: %zu instead of %u.\n", retlen, tn->csize);
                        c->mtd->unpoint(c->mtd, buffer, ofs, retlen);
                } else if (err)
diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c
index ffa447511e6a..4677355996cc 100644
--- a/fs/jffs2/super.c
+++ b/fs/jffs2/super.c
@@ -65,7 +65,6 @@ static const struct super_operations jffs2_super_operations =
 {
        .alloc_inode =  jffs2_alloc_inode,
        .destroy_inode =jffs2_destroy_inode,
-        .read_inode =   jffs2_read_inode,
        .put_super =    jffs2_put_super,
        .write_super =  jffs2_write_super,
        .statfs =       jffs2_statfs,
diff --git a/fs/jffs2/write.c b/fs/jffs2/write.c
index 147e2cbee9e4..776f13cbf2b5 100644
--- a/fs/jffs2/write.c
+++ b/fs/jffs2/write.c
@@ -177,7 +177,7 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
                void *hold_err = fn->raw;
                /* Release the full_dnode which is now useless, and return */
                jffs2_free_full_dnode(fn);
-                return ERR_PTR(PTR_ERR(hold_err));
+                return ERR_CAST(hold_err);
        }
        fn->ofs = je32_to_cpu(ri->offset);
        fn->size = je32_to_cpu(ri->dsize);
@@ -313,7 +313,7 @@ struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jff
                void *hold_err = fd->raw;
                /* Release the full_dirent which is now useless, and return */
                jffs2_free_full_dirent(fd);
-                return ERR_PTR(PTR_ERR(hold_err));
+                return ERR_CAST(hold_err);
        }
        if (retried) {
@@ -582,7 +582,7 @@ int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
                jffs2_add_fd_to_list(c, fd, &dir_f->dents);
                up(&dir_f->sem);
        } else {
-                struct jffs2_full_dirent **prev = &dir_f->dents;
+                struct jffs2_full_dirent *fd = dir_f->dents;
                uint32_t nhash = full_name_hash(name, namelen);
                /* We don't actually want to reserve any space, but we do
@@ -590,21 +590,22 @@ int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
                down(&c->alloc_sem);
                down(&dir_f->sem);
-                while ((*prev) && (*prev)->nhash <= nhash) {
+                for (fd = dir_f->dents; fd; fd = fd->next) {
-                        if ((*prev)->nhash == nhash &&
+                        if (fd->nhash == nhash &&
-                            !memcmp((*prev)->name, name, namelen) &&
+                            !memcmp(fd->name, name, namelen) &&
-                            !(*prev)->name[namelen]) {
+                            !fd->name[namelen]) {
-                                struct jffs2_full_dirent *this = *prev;
                                D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n",
-                                          this->ino, ref_offset(this->raw)));
+                                          fd->ino, ref_offset(fd->raw)));
+                                jffs2_mark_node_obsolete(c, fd->raw);
-                                *prev = this->next;
+                                /* We don't want to remove it from the list immediately,
-                                jffs2_mark_node_obsolete(c, (this->raw));
+                                   because that screws up getdents()/seek() semantics even
-                                jffs2_free_full_dirent(this);
+                                   more than they're screwed already. Turn it into a
+                                   node-less deletion dirent instead -- a placeholder */
+                                fd->raw = NULL;
+                                fd->ino = 0;
                                break;
                        }
-                        prev = &((*prev)->next);
                }
                up(&dir_f->sem);
        }
@@ -630,7 +631,8 @@ int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
                                        D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n",
                                                fd->name, dead_f->inocache->ino));
                                }
-                                jffs2_mark_node_obsolete(c, fd->raw);
+                                if (fd->raw)
+                                        jffs2_mark_node_obsolete(c, fd->raw);
                                jffs2_free_full_dirent(fd);
                        }
                }
diff --git a/fs/jfs/inode.c b/fs/jfs/inode.c
index 4672013802e1..210339784b56 100644
--- a/fs/jfs/inode.c
+++ b/fs/jfs/inode.c
@@ -31,11 +31,21 @@
 #include "jfs_debug.h"
-void jfs_read_inode(struct inode *inode)
+struct inode *jfs_iget(struct super_block *sb, unsigned long ino)
 {
-        if (diRead(inode)) {
+        struct inode *inode;
-                make_bad_inode(inode);
+        int ret;
-                return;
+        inode = iget_locked(sb, ino);
+        if (!inode)
+                return ERR_PTR(-ENOMEM);
+        if (!(inode->i_state & I_NEW))
+                return inode;
+        ret = diRead(inode);
+        if (ret < 0) {
+                iget_failed(inode);
+                return ERR_PTR(ret);
        }
        if (S_ISREG(inode->i_mode)) {
@@ -55,6 +65,8 @@ void jfs_read_inode(struct inode *inode)
                inode->i_op = &jfs_file_inode_operations;
                init_special_inode(inode, inode->i_mode, inode->i_rdev);
        }
+        unlock_new_inode(inode);
+        return inode;
 }
 /*
diff --git a/fs/jfs/jfs_inode.h b/fs/jfs/jfs_inode.h
index 8e2cf2cde185..95a6a11425e5 100644
--- a/fs/jfs/jfs_inode.h
+++ b/fs/jfs/jfs_inode.h
@@ -24,7 +24,7 @@ extern struct inode *ialloc(struct inode *, umode_t);
 extern int jfs_fsync(struct file *, struct dentry *, int);
 extern int jfs_ioctl(struct inode *, struct file *,
                        unsigned int, unsigned long);
-extern void jfs_read_inode(struct inode *);
+extern struct inode *jfs_iget(struct super_block *, unsigned long);
 extern int jfs_commit_inode(struct inode *, int);
 extern int jfs_write_inode(struct inode*, int);
 extern void jfs_delete_inode(struct inode *);
diff --git a/fs/jfs/namei.c b/fs/jfs/namei.c
index f8718de3505e..403cfc24c6fe 100644
--- a/fs/jfs/namei.c
+++ b/fs/jfs/namei.c
@@ -1462,12 +1462,10 @@ static struct dentry *jfs_lookup(struct inode *dip, struct dentry *dentry, struc
                }
        }
-        ip = iget(dip->i_sb, inum);
+        ip = jfs_iget(dip->i_sb, inum);
-        if (ip == NULL || is_bad_inode(ip)) {
+        if (IS_ERR(ip)) {
                jfs_err("jfs_lookup: iget failed on inum %d", (uint) inum);
-                if (ip)
+                return ERR_CAST(ip);
-                        iput(ip);
-                return ERR_PTR(-EACCES);
        }
        dentry = d_splice_alias(ip, dentry);
@@ -1485,12 +1483,11 @@ static struct inode *jfs_nfs_get_inode(struct super_block *sb,
        if (ino == 0)
                return ERR_PTR(-ESTALE);
-        inode = iget(sb, ino);
+        inode = jfs_iget(sb, ino);
-        if (inode == NULL)
+        if (IS_ERR(inode))
-                return ERR_PTR(-ENOMEM);
+                return ERR_CAST(inode);
-        if (is_bad_inode(inode) ||
+        if (generation && inode->i_generation != generation) {
-            (generation && inode->i_generation != generation)) {
                iput(inode);
                return ERR_PTR(-ESTALE);
        }
@@ -1521,17 +1518,14 @@ struct dentry *jfs_get_parent(struct dentry *dentry)
        parent_ino =
                le32_to_cpu(JFS_IP(dentry->d_inode)->i_dtroot.header.idotdot);
-        inode = iget(sb, parent_ino);
+        inode = jfs_iget(sb, parent_ino);
-        if (inode) {
+        if (IS_ERR(inode)) {
-                if (is_bad_inode(inode)) {
+                parent = ERR_CAST(inode);
+        } else {
+                parent = d_alloc_anon(inode);
+                if (!parent) {
+                        parent = ERR_PTR(-ENOMEM);
                        iput(inode);
-                        parent = ERR_PTR(-EACCES);
-                } else {
-                        parent = d_alloc_anon(inode);
-                        if (!parent) {
-                                parent = ERR_PTR(-ENOMEM);
-                                iput(inode);
-                        }
                }
        }
diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index 70a14001c98f..50ea65451732 100644
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -414,7 +414,7 @@ static int jfs_fill_super(struct super_block *sb, void *data, int silent)
        struct inode *inode;
        int rc;
        s64 newLVSize = 0;
-        int flag;
+        int flag, ret = -EINVAL;
        jfs_info("In jfs_read_super: s_flags=0x%lx", sb->s_flags);
@@ -461,8 +461,10 @@ static int jfs_fill_super(struct super_block *sb, void *data, int silent)
         * Initialize direct-mapping inode/address-space
         */
        inode = new_inode(sb);
-        if (inode == NULL)
+        if (inode == NULL) {
+                ret = -ENOMEM;
                goto out_kfree;
+        }
        inode->i_ino = 0;
        inode->i_nlink = 1;
        inode->i_size = sb->s_bdev->bd_inode->i_size;
@@ -494,9 +496,11 @@ static int jfs_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_magic = JFS_SUPER_MAGIC;
-        inode = iget(sb, ROOT_I);
+        inode = jfs_iget(sb, ROOT_I);
-        if (!inode || is_bad_inode(inode))
+        if (IS_ERR(inode)) {
+                ret = PTR_ERR(inode);
                goto out_no_root;
+        }
        sb->s_root = d_alloc_root(inode);
        if (!sb->s_root)
                goto out_no_root;
@@ -536,7 +540,7 @@ out_kfree:
        if (sbi->nls_tab)
                unload_nls(sbi->nls_tab);
        kfree(sbi);
-        return -EINVAL;
+        return ret;
 }
 static void jfs_write_super_lockfs(struct super_block *sb)
@@ -726,7 +730,6 @@ out:
 static const struct super_operations jfs_super_operations = {
        .alloc_inode    = jfs_alloc_inode,
        .destroy_inode  = jfs_destroy_inode,
-        .read_inode     = jfs_read_inode,
        .dirty_inode    = jfs_dirty_inode,
        .write_inode    = jfs_write_inode,
        .delete_inode   = jfs_delete_inode,
diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index bf4cd316af81..84f6242ba6fc 100644
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -18,7 +18,6 @@
 #include <linux/highuid.h>
 #include <linux/vfs.h>
-static void minix_read_inode(struct inode * inode);
 static int minix_write_inode(struct inode * inode, int wait);
 static int minix_statfs(struct dentry *dentry, struct kstatfs *buf);
 static int minix_remount (struct super_block * sb, int * flags, char * data);
@@ -96,7 +95,6 @@ static void destroy_inodecache(void)
 static const struct super_operations minix_sops = {
        .alloc_inode    = minix_alloc_inode,
        .destroy_inode  = minix_destroy_inode,
-        .read_inode     = minix_read_inode,
        .write_inode    = minix_write_inode,
        .delete_inode   = minix_delete_inode,
        .put_super      = minix_put_super,
@@ -149,6 +147,7 @@ static int minix_fill_super(struct super_block *s, void *data, int silent)
        unsigned long i, block;
        struct inode *root_inode;
        struct minix_sb_info *sbi;
+        int ret = -EINVAL;
        sbi = kzalloc(sizeof(struct minix_sb_info), GFP_KERNEL);
        if (!sbi)
@@ -246,10 +245,13 @@ static int minix_fill_super(struct super_block *s, void *data, int silent)
        /* set up enough so that it can read an inode */
        s->s_op = &minix_sops;
-        root_inode = iget(s, MINIX_ROOT_INO);
+        root_inode = minix_iget(s, MINIX_ROOT_INO);
-        if (!root_inode || is_bad_inode(root_inode))
+        if (IS_ERR(root_inode)) {
+                ret = PTR_ERR(root_inode);
                goto out_no_root;
+        }
+        ret = -ENOMEM;
        s->s_root = d_alloc_root(root_inode);
        if (!s->s_root)
                goto out_iput;
@@ -290,6 +292,7 @@ out_freemap:
        goto out_release;
 out_no_map:
+        ret = -ENOMEM;
        if (!silent)
                printk("MINIX-fs: can't allocate map\n");
        goto out_release;
@@ -316,7 +319,7 @@ out_bad_sb:
 out:
        s->s_fs_info = NULL;
        kfree(sbi);
-        return -EINVAL;
+        return ret;
 }
 static int minix_statfs(struct dentry *dentry, struct kstatfs *buf)
@@ -409,7 +412,7 @@ void minix_set_inode(struct inode *inode, dev_t rdev)
 /*
 * The minix V1 function to read an inode.
 */
-static void V1_minix_read_inode(struct inode * inode)
+static struct inode *V1_minix_iget(struct inode *inode)
 {
        struct buffer_head * bh;
        struct minix_inode * raw_inode;
@@ -418,8 +421,8 @@ static void V1_minix_read_inode(struct inode * inode)
        raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
        if (!raw_inode) {
-                make_bad_inode(inode);
+                iget_failed(inode);
-                return;
+                return ERR_PTR(-EIO);
        }
        inode->i_mode = raw_inode->i_mode;
        inode->i_uid = (uid_t)raw_inode->i_uid;
@@ -435,12 +438,14 @@ static void V1_minix_read_inode(struct inode * inode)
                minix_inode->u.i1_data[i] = raw_inode->i_zone[i];
        minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
        brelse(bh);
+        unlock_new_inode(inode);
+        return inode;
 }
 /*
 * The minix V2 function to read an inode.
 */
-static void V2_minix_read_inode(struct inode * inode)
+static struct inode *V2_minix_iget(struct inode *inode)
 {
        struct buffer_head * bh;
        struct minix2_inode * raw_inode;
@@ -449,8 +454,8 @@ static void V2_minix_read_inode(struct inode * inode)
        raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
        if (!raw_inode) {
-                make_bad_inode(inode);
+                iget_failed(inode);
-                return;
+                return ERR_PTR(-EIO);
        }
        inode->i_mode = raw_inode->i_mode;
        inode->i_uid = (uid_t)raw_inode->i_uid;
@@ -468,17 +473,27 @@ static void V2_minix_read_inode(struct inode * inode)
                minix_inode->u.i2_data[i] = raw_inode->i_zone[i];
        minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
        brelse(bh);
+        unlock_new_inode(inode);
+        return inode;
 }
 /*
 * The global function to read an inode.
 */
-static void minix_read_inode(struct inode * inode)
+struct inode *minix_iget(struct super_block *sb, unsigned long ino)
 {
+        struct inode *inode;
+        inode = iget_locked(sb, ino);
+        if (!inode)
+                return ERR_PTR(-ENOMEM);
+        if (!(inode->i_state & I_NEW))
+                return inode;
        if (INODE_VERSION(inode) == MINIX_V1)
-                V1_minix_read_inode(inode);
+                return V1_minix_iget(inode);
        else
-                V2_minix_read_inode(inode);
+                return V2_minix_iget(inode);
 }
 /*
diff --git a/fs/minix/minix.h b/fs/minix/minix.h
index ac5d3a75cb0d..326edfe96108 100644
--- a/fs/minix/minix.h
+++ b/fs/minix/minix.h
@@ -45,6 +45,7 @@ struct minix_sb_info {
        unsigned short s_version;
 };
+extern struct inode *minix_iget(struct super_block *, unsigned long);
 extern struct minix_inode * minix_V1_raw_inode(struct super_block *, ino_t, struct buffer_head **);
 extern struct minix2_inode * minix_V2_raw_inode(struct super_block *, ino_t, struct buffer_head **);
 extern struct inode * minix_new_inode(const struct inode * dir, int * error);
diff --git a/fs/minix/namei.c b/fs/minix/namei.c
index f4aa7a939040..102241bc9c79 100644
--- a/fs/minix/namei.c
+++ b/fs/minix/namei.c
@@ -54,10 +54,9 @@ static struct dentry *minix_lookup(struct inode * dir, struct dentry *dentry, st
        ino = minix_inode_by_name(dentry);
        if (ino) {
-                inode = iget(dir->i_sb, ino);
+                inode = minix_iget(dir->i_sb, ino);
- 
+                if (IS_ERR(inode))
-                if (!inode)
+                        return ERR_CAST(inode);
-                        return ERR_PTR(-EACCES);
        }
        d_add(dentry, inode);
        return NULL;
diff --git a/fs/nfs/getroot.c b/fs/nfs/getroot.c
index e6242cdbaf91..fae97196daad 100644
--- a/fs/nfs/getroot.c
+++ b/fs/nfs/getroot.c
@@ -96,7 +96,7 @@ struct dentry *nfs_get_root(struct super_block *sb, struct nfs_fh *mntfh)
        inode = nfs_fhget(sb, mntfh, fsinfo.fattr);
        if (IS_ERR(inode)) {
                dprintk("nfs_get_root: get root inode failed\n");
-                return ERR_PTR(PTR_ERR(inode));
+                return ERR_CAST(inode);
        }
        error = nfs_superblock_set_dummy_root(sb, inode);
@@ -266,7 +266,7 @@ struct dentry *nfs4_get_root(struct super_block *sb, struct nfs_fh *mntfh)
        inode = nfs_fhget(sb, mntfh, &fattr);
        if (IS_ERR(inode)) {
                dprintk("nfs_get_root: get root inode failed\n");
-                return ERR_PTR(PTR_ERR(inode));
+                return ERR_CAST(inode);
        }
        error = nfs_superblock_set_dummy_root(sb, inode);
diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c
index 79b4bf812960..346570f6d848 100644
--- a/fs/nfsd/export.c
+++ b/fs/nfsd/export.c
@@ -1218,13 +1218,13 @@ static struct svc_export *exp_find(struct auth_domain *clp, int fsid_type,
        struct svc_export *exp;
        struct svc_expkey *ek = exp_find_key(clp, fsid_type, fsidv, reqp);
        if (IS_ERR(ek))
-                return ERR_PTR(PTR_ERR(ek));
+                return ERR_CAST(ek);
        exp = exp_get_by_name(clp, ek->ek_mnt, ek->ek_dentry, reqp);
        cache_put(&ek->h, &svc_expkey_cache);
        if (IS_ERR(exp))
-                return ERR_PTR(PTR_ERR(exp));
+                return ERR_CAST(exp);
        return exp;
 }
diff --git a/fs/openpromfs/inode.c b/fs/openpromfs/inode.c
index 6b7ff1618945..d17b4fd204e1 100644
--- a/fs/openpromfs/inode.c
+++ b/fs/openpromfs/inode.c
@@ -38,6 +38,8 @@ struct op_inode_info {
        union op_inode_data     u;
 };
+static struct inode *openprom_iget(struct super_block *sb, ino_t ino);
 static inline struct op_inode_info *OP_I(struct inode *inode)
 {
        return container_of(inode, struct op_inode_info, vfs_inode);
@@ -226,10 +228,10 @@ static struct dentry *openpromfs_lookup(struct inode *dir, struct dentry *dentry
        return ERR_PTR(-ENOENT);
 found:
-        inode = iget(dir->i_sb, ino);
+        inode = openprom_iget(dir->i_sb, ino);
        mutex_unlock(&op_mutex);
-        if (!inode)
+        if (IS_ERR(inode))
-                return ERR_PTR(-EINVAL);
+                return ERR_CAST(inode);
        ent_oi = OP_I(inode);
        ent_oi->type = ent_type;
        ent_oi->u = ent_data;
@@ -348,14 +350,23 @@ static void openprom_destroy_inode(struct inode *inode)
        kmem_cache_free(op_inode_cachep, OP_I(inode));
 }
-static void openprom_read_inode(struct inode * inode)
+static struct inode *openprom_iget(struct super_block *sb, ino_t ino)
 {
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+        struct inode *inode;
-        if (inode->i_ino == OPENPROM_ROOT_INO) {
-                inode->i_op = &openprom_inode_operations;
+        inode = iget_locked(sb, ino);
-                inode->i_fop = &openprom_operations;
+        if (!inode)
-                inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
+                return ERR_PTR(-ENOMEM);
+        if (inode->i_state & I_NEW) {
+                inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+                if (inode->i_ino == OPENPROM_ROOT_INO) {
+                        inode->i_op = &openprom_inode_operations;
+                        inode->i_fop = &openprom_operations;
+                        inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
+                }
+                unlock_new_inode(inode);
        }
+        return inode;
 }
 static int openprom_remount(struct super_block *sb, int *flags, char *data)
@@ -367,7 +378,6 @@ static int openprom_remount(struct super_block *sb, int *flags, char *data)
 static const struct super_operations openprom_sops = {
        .alloc_inode    = openprom_alloc_inode,
        .destroy_inode  = openprom_destroy_inode,
-        .read_inode     = openprom_read_inode,
        .statfs         = simple_statfs,
        .remount_fs     = openprom_remount,
 };
@@ -376,6 +386,7 @@ static int openprom_fill_super(struct super_block *s, void *data, int silent)
 {
        struct inode *root_inode;
        struct op_inode_info *oi;
+        int ret;
        s->s_flags |= MS_NOATIME;
        s->s_blocksize = 1024;
@@ -383,9 +394,11 @@ static int openprom_fill_super(struct super_block *s, void *data, int silent)
        s->s_magic = OPENPROM_SUPER_MAGIC;
        s->s_op = &openprom_sops;
        s->s_time_gran = 1;
-        root_inode = iget(s, OPENPROM_ROOT_INO);
+        root_inode = openprom_iget(s, OPENPROM_ROOT_INO);
-        if (!root_inode)
+        if (IS_ERR(root_inode)) {
+                ret = PTR_ERR(root_inode);
                goto out_no_root;
+        }
        oi = OP_I(root_inode);
        oi->type = op_inode_node;
@@ -393,13 +406,15 @@ static int openprom_fill_super(struct super_block *s, void *data, int silent)
        s->s_root = d_alloc_root(root_inode);
        if (!s->s_root)
-                goto out_no_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");
-        iput(root_inode);
+        return ret;
-        return -ENOMEM;
 }
 static int openprom_get_sb(struct file_system_type *fs_type,
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 1a551d92e1d8..6ecf6396f072 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -73,11 +73,6 @@ static void proc_delete_inode(struct inode *inode)
 struct vfsmount *proc_mnt;
-static void proc_read_inode(struct inode * inode)
-{
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
-}
 static struct kmem_cache * proc_inode_cachep;
 static struct inode *proc_alloc_inode(struct super_block *sb)
@@ -128,7 +123,6 @@ static int proc_remount(struct super_block *sb, int *flags, char *data)
 static const struct super_operations proc_sops = {
        .alloc_inode    = proc_alloc_inode,
        .destroy_inode  = proc_destroy_inode,
-        .read_inode     = proc_read_inode,
        .drop_inode     = generic_delete_inode,
        .delete_inode   = proc_delete_inode,
        .statfs         = simple_statfs,
@@ -401,39 +395,41 @@ struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
        if (de != NULL && !try_module_get(de->owner))
                goto out_mod;
-        inode = iget(sb, ino);
+        inode = iget_locked(sb, ino);
        if (!inode)
                goto out_ino;
+        if (inode->i_state & I_NEW) {
-        PROC_I(inode)->fd = 0;
+                inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
-        PROC_I(inode)->pde = de;
+                PROC_I(inode)->fd = 0;
-        if (de) {
+                PROC_I(inode)->pde = de;
-                if (de->mode) {
+                if (de) {
-                        inode->i_mode = de->mode;
+                        if (de->mode) {
-                        inode->i_uid = de->uid;
+                                inode->i_mode = de->mode;
-                        inode->i_gid = de->gid;
+                                inode->i_uid = de->uid;
-                }
+                                inode->i_gid = de->gid;
-                if (de->size)
+                        }
-                        inode->i_size = de->size;
+                        if (de->size)
-                if (de->nlink)
+                                inode->i_size = de->size;
-                        inode->i_nlink = de->nlink;
+                        if (de->nlink)
-                if (de->proc_iops)
+                                inode->i_nlink = de->nlink;
-                        inode->i_op = de->proc_iops;
+                        if (de->proc_iops)
-                if (de->proc_fops) {
+                                inode->i_op = de->proc_iops;
-                        if (S_ISREG(inode->i_mode)) {
+                        if (de->proc_fops) {
+                                if (S_ISREG(inode->i_mode)) {
 #ifdef CONFIG_COMPAT
-                                if (!de->proc_fops->compat_ioctl)
+                                        if (!de->proc_fops->compat_ioctl)
-                                        inode->i_fop =
+                                                inode->i_fop =
-                                                &proc_reg_file_ops_no_compat;
+                                                        &proc_reg_file_ops_no_compat;
-                                else
+                                        else
 #endif
-                                        inode->i_fop = &proc_reg_file_ops;
+                                                inode->i_fop = &proc_reg_file_ops;
+                                } else {
+                                        inode->i_fop = de->proc_fops;
+                                }
                        }
-                        else
-                                inode->i_fop = de->proc_fops;
                }
+                unlock_new_inode(inode);
        }
        return inode;
 out_ino:
diff --git a/fs/qnx4/inode.c b/fs/qnx4/inode.c
index 638bdb963213..b31ab78052b3 100644
--- a/fs/qnx4/inode.c
+++ b/fs/qnx4/inode.c
@@ -125,7 +125,6 @@ static int qnx4_write_inode(struct inode *inode, int unused)
 static void qnx4_put_super(struct super_block *sb);
 static struct inode *qnx4_alloc_inode(struct super_block *sb);
 static void qnx4_destroy_inode(struct inode *inode);
-static void qnx4_read_inode(struct inode *);
 static int qnx4_remount(struct super_block *sb, int *flags, char *data);
 static int qnx4_statfs(struct dentry *, struct kstatfs *);
@@ -133,7 +132,6 @@ static const struct super_operations qnx4_sops =
 {
        .alloc_inode    = qnx4_alloc_inode,
        .destroy_inode  = qnx4_destroy_inode,
-        .read_inode     = qnx4_read_inode,
        .put_super      = qnx4_put_super,
        .statfs         = qnx4_statfs,
        .remount_fs     = qnx4_remount,
@@ -357,6 +355,7 @@ static int qnx4_fill_super(struct super_block *s, void *data, int silent)
        struct inode *root;
        const char *errmsg;
        struct qnx4_sb_info *qs;
+        int ret = -EINVAL;
        qs = kzalloc(sizeof(struct qnx4_sb_info), GFP_KERNEL);
        if (!qs)
@@ -396,12 +395,14 @@ static int qnx4_fill_super(struct super_block *s, void *data, int silent)
        }
        /* does root not have inode number QNX4_ROOT_INO ?? */
-        root = iget(s, QNX4_ROOT_INO * QNX4_INODES_PER_BLOCK);
+        root = qnx4_iget(s, QNX4_ROOT_INO * QNX4_INODES_PER_BLOCK);
-        if (!root) {
+        if (IS_ERR(root)) {
                printk("qnx4: get inode failed\n");
+                ret = PTR_ERR(root);
                goto out;
        }
+        ret = -ENOMEM;
        s->s_root = d_alloc_root(root);
        if (s->s_root == NULL)
                goto outi;
@@ -417,7 +418,7 @@ static int qnx4_fill_super(struct super_block *s, void *data, int silent)
      outnobh:
        kfree(qs);
        s->s_fs_info = NULL;
-        return -EINVAL;
+        return ret;
 }
 static void qnx4_put_super(struct super_block *sb)
@@ -462,29 +463,38 @@ static const struct address_space_operations qnx4_aops = {
        .bmap           = qnx4_bmap
 };
-static void qnx4_read_inode(struct inode *inode)
+struct inode *qnx4_iget(struct super_block *sb, unsigned long ino)
 {
        struct buffer_head *bh;
        struct qnx4_inode_entry *raw_inode;
-        int block, ino;
+        int block;
-        struct super_block *sb = inode->i_sb;
+        struct qnx4_inode_entry *qnx4_inode;
-        struct qnx4_inode_entry *qnx4_inode = qnx4_raw_inode(inode);
+        struct inode *inode;
-        ino = inode->i_ino;
+        inode = iget_locked(sb, ino);
+        if (!inode)
+                return ERR_PTR(-ENOMEM);
+        if (!(inode->i_state & I_NEW))
+                return inode;
+        qnx4_inode = qnx4_raw_inode(inode);
        inode->i_mode = 0;
        QNX4DEBUG(("Reading inode : [%d]\n", ino));
        if (!ino) {
-                printk("qnx4: bad inode number on dev %s: %d is out of range\n",
+                printk(KERN_ERR "qnx4: bad inode number on dev %s: %lu is "
+                                "out of range\n",
                       sb->s_id, ino);
-                return;
+                iget_failed(inode);
+                return ERR_PTR(-EIO);
        }
        block = ino / QNX4_INODES_PER_BLOCK;
        if (!(bh = sb_bread(sb, block))) {
                printk("qnx4: major problem: unable to read inode from dev "
                       "%s\n", sb->s_id);
-                return;
+                iget_failed(inode);
+                return ERR_PTR(-EIO);
        }
        raw_inode = ((struct qnx4_inode_entry *) bh->b_data) +
            (ino % QNX4_INODES_PER_BLOCK);
@@ -515,9 +525,16 @@ static void qnx4_read_inode(struct inode *inode)
                inode->i_op = &page_symlink_inode_operations;
                inode->i_mapping->a_ops = &qnx4_aops;
                qnx4_i(inode)->mmu_private = inode->i_size;
-        } else
+        } else {
-                printk("qnx4: bad inode %d on dev %s\n",ino,sb->s_id);
+                printk(KERN_ERR "qnx4: bad inode %lu on dev %s\n",
+                        ino, sb->s_id);
+                iget_failed(inode);
+                brelse(bh);
+                return ERR_PTR(-EIO);
+        }
        brelse(bh);
+        unlock_new_inode(inode);
+        return inode;
 }
 static struct kmem_cache *qnx4_inode_cachep;
diff --git a/fs/qnx4/namei.c b/fs/qnx4/namei.c
index 733cdf01d645..775eed3a4085 100644
--- a/fs/qnx4/namei.c
+++ b/fs/qnx4/namei.c
@@ -128,10 +128,12 @@ struct dentry * qnx4_lookup(struct inode *dir, struct dentry *dentry, struct nam
        }
        brelse(bh);
-        if ((foundinode = iget(dir->i_sb, ino)) == NULL) {
+        foundinode = qnx4_iget(dir->i_sb, ino);
+        if (IS_ERR(foundinode)) {
                unlock_kernel();
-                QNX4DEBUG(("qnx4: lookup->iget -> NULL\n"));
+                QNX4DEBUG(("qnx4: lookup->iget -> error %ld\n",
-                return ERR_PTR(-EACCES);
+                           PTR_ERR(foundinode)));
+                return ERR_CAST(foundinode);
        }
 out:
        unlock_kernel();
diff --git a/fs/quota.c b/fs/quota.c
index 99b24b52bfc8..84f28dd72116 100644
--- a/fs/quota.c
+++ b/fs/quota.c
@@ -341,11 +341,11 @@ static inline struct super_block *quotactl_block(const char __user *special)
        char *tmp = getname(special);
        if (IS_ERR(tmp))
-                return ERR_PTR(PTR_ERR(tmp));
+                return ERR_CAST(tmp);
        bdev = lookup_bdev(tmp);
        putname(tmp);
        if (IS_ERR(bdev))
-                return ERR_PTR(PTR_ERR(bdev));
+                return ERR_CAST(bdev);
        sb = get_super(bdev);
        bdput(bdev);
        if (!sb)
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 195309857e63..57917932212e 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -1536,7 +1536,7 @@ static struct dentry *reiserfs_get_dentry(struct super_block *sb,
        if (!inode)
                inode = ERR_PTR(-ESTALE);
        if (IS_ERR(inode))
-                return ERR_PTR(PTR_ERR(inode));
+                return ERR_CAST(inode);
        result = d_alloc_anon(inode);
        if (!result) {
                iput(inode);
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index a5bd23ce0e46..eba037b3338f 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -155,7 +155,7 @@ static struct dentry *get_xa_file_dentry(const struct inode *inode,
        xadir = open_xa_dir(inode, flags);
        if (IS_ERR(xadir)) {
-                return ERR_PTR(PTR_ERR(xadir));
+                return ERR_CAST(xadir);
        } else if (xadir && !xadir->d_inode) {
                dput(xadir);
                return ERR_PTR(-ENODATA);
@@ -164,7 +164,7 @@ static struct dentry *get_xa_file_dentry(const struct inode *inode,
        xafile = lookup_one_len(name, xadir, strlen(name));
        if (IS_ERR(xafile)) {
                dput(xadir);
-                return ERR_PTR(PTR_ERR(xafile));
+                return ERR_CAST(xafile);
        }
        if (xafile->d_inode) {  /* file exists */
diff --git a/fs/romfs/inode.c b/fs/romfs/inode.c
index a49cf5b9a195..00b6f0a518c8 100644
--- a/fs/romfs/inode.c
+++ b/fs/romfs/inode.c
@@ -84,6 +84,8 @@ struct romfs_inode_info {
        struct inode vfs_inode;
 };
+static struct inode *romfs_iget(struct super_block *, unsigned long);
 /* instead of private superblock data */
 static inline unsigned long romfs_maxsize(struct super_block *sb)
 {
@@ -117,7 +119,7 @@ static int romfs_fill_super(struct super_block *s, void *data, int silent)
        struct buffer_head *bh;
        struct romfs_super_block *rsb;
        struct inode *root;
-        int sz;
+        int sz, ret = -EINVAL;
        /* I would parse the options here, but there are none.. :) */
@@ -157,10 +159,13 @@ static int romfs_fill_super(struct super_block *s, void *data, int silent)
             & ROMFH_MASK;
        s->s_op = &romfs_ops;
-        root = iget(s, sz);
+        root = romfs_iget(s, sz);
-        if (!root)
+        if (IS_ERR(root)) {
+                ret = PTR_ERR(root);
                goto out;
+        }
+        ret = -ENOMEM;
        s->s_root = d_alloc_root(root);
        if (!s->s_root)
                goto outiput;
@@ -173,7 +178,7 @@ outiput:
 out:
        brelse(bh);
 outnobh:
-        return -EINVAL;
+        return ret;
 }
 /* That's simple too. */
@@ -389,8 +394,11 @@ romfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
        if ((be32_to_cpu(ri.next) & ROMFH_TYPE) == ROMFH_HRD)
                offset = be32_to_cpu(ri.spec) & ROMFH_MASK;
-        if ((inode = iget(dir->i_sb, offset)))
+        inode = romfs_iget(dir->i_sb, offset);
-                goto outi;
+        if (IS_ERR(inode)) {
+                res = PTR_ERR(inode);
+                goto out;
+        }
        /*
         * it's a bit funky, _lookup needs to return an error code
@@ -402,7 +410,7 @@ romfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
         */
 out0:   inode = NULL;
-outi:   res = 0;
+        res = 0;
        d_add (dentry, inode);
 out:    unlock_kernel();
@@ -478,20 +486,29 @@ static mode_t romfs_modemap[] =
        S_IFBLK+0600, S_IFCHR+0600, S_IFSOCK+0644, S_IFIFO+0644
 };
-static void
+static struct inode *
-romfs_read_inode(struct inode *i)
+romfs_iget(struct super_block *sb, unsigned long ino)
 {
-        int nextfh, ino;
+        int nextfh;
        struct romfs_inode ri;
+        struct inode *i;
+        ino &= ROMFH_MASK;
+        i = iget_locked(sb, ino);
+        if (!i)
+                return ERR_PTR(-ENOMEM);
+        if (!(i->i_state & I_NEW))
+                return i;
-        ino = i->i_ino & ROMFH_MASK;
        i->i_mode = 0;
        /* Loop for finding the real hard link */
        for(;;) {
                if (romfs_copyfrom(i, &ri, ino, ROMFH_SIZE) <= 0) {
-                        printk("romfs: read error for inode 0x%x\n", ino);
+                        printk(KERN_ERR "romfs: read error for inode 0x%lx\n",
-                        return;
+                                ino);
+                        iget_failed(i);
+                        return ERR_PTR(-EIO);
                }
                /* XXX: do romfs_checksum here too (with name) */
@@ -548,6 +565,8 @@ romfs_read_inode(struct inode *i)
                        init_special_inode(i, ino,
                                        MKDEV(nextfh>>16,nextfh&0xffff));
        }
+        unlock_new_inode(i);
+        return i;
 }
 static struct kmem_cache * romfs_inode_cachep;
@@ -599,7 +618,6 @@ static int romfs_remount(struct super_block *sb, int *flags, char *data)
 static const struct super_operations romfs_ops = {
        .alloc_inode    = romfs_alloc_inode,
        .destroy_inode  = romfs_destroy_inode,
-        .read_inode     = romfs_read_inode,
        .statfs         = romfs_statfs,
        .remount_fs     = romfs_remount,
 };
diff --git a/fs/sysv/inode.c b/fs/sysv/inode.c
index 81ec6c548c07..c5d60de0658f 100644
--- a/fs/sysv/inode.c
+++ b/fs/sysv/inode.c
@@ -169,20 +169,27 @@ void sysv_set_inode(struct inode *inode, dev_t rdev)
                init_special_inode(inode, inode->i_mode, rdev);
 }
-static void sysv_read_inode(struct inode *inode)
+struct inode *sysv_iget(struct super_block *sb, unsigned int ino)
 {
-        struct super_block * sb = inode->i_sb;
        struct sysv_sb_info * sbi = SYSV_SB(sb);
        struct buffer_head * bh;
        struct sysv_inode * raw_inode;
        struct sysv_inode_info * si;
-        unsigned int block, ino = inode->i_ino;
+        struct inode *inode;
+        unsigned int block;
        if (!ino || ino > sbi->s_ninodes) {
                printk("Bad inode number on dev %s: %d is out of range\n",
-                       inode->i_sb->s_id, ino);
+                       sb->s_id, ino);
-                goto bad_inode;
+                return ERR_PTR(-EIO);
        }
+        inode = iget_locked(sb, ino);
+        if (!inode)
+                return ERR_PTR(-ENOMEM);
+        if (!(inode->i_state & I_NEW))
+                return inode;
        raw_inode = sysv_raw_inode(sb, ino, &bh);
        if (!raw_inode) {
                printk("Major problem: unable to read inode from dev %s\n",
@@ -214,11 +221,12 @@ static void sysv_read_inode(struct inode *inode)
                               old_decode_dev(fs32_to_cpu(sbi, si->i_data[0])));
        else
                sysv_set_inode(inode, 0);
-        return;
+        unlock_new_inode(inode);
+        return inode;
 bad_inode:
-        make_bad_inode(inode);
+        iget_failed(inode);
-        return;
+        return ERR_PTR(-EIO);
 }
 static struct buffer_head * sysv_update_inode(struct inode * inode)
@@ -328,7 +336,6 @@ static void init_once(struct kmem_cache *cachep, void *p)
 const struct super_operations sysv_sops = {
        .alloc_inode    = sysv_alloc_inode,
        .destroy_inode  = sysv_destroy_inode,
-        .read_inode     = sysv_read_inode,
        .write_inode    = sysv_write_inode,
        .delete_inode   = sysv_delete_inode,
        .put_super      = sysv_put_super,
diff --git a/fs/sysv/namei.c b/fs/sysv/namei.c
index 6bd850b7641a..a1f1ef33e81c 100644
--- a/fs/sysv/namei.c
+++ b/fs/sysv/namei.c
@@ -53,9 +53,9 @@ static struct dentry *sysv_lookup(struct inode * dir, struct dentry * dentry, st
        ino = sysv_inode_by_name(dentry);
        if (ino) {
-                inode = iget(dir->i_sb, ino);
+                inode = sysv_iget(dir->i_sb, ino);
-                if (!inode)
+                if (IS_ERR(inode))
-                        return ERR_PTR(-EACCES);
+                        return ERR_CAST(inode);
        }
        d_add(dentry, inode);
        return NULL;
diff --git a/fs/sysv/super.c b/fs/sysv/super.c
index 6f9707a1b954..5a903da54551 100644
--- a/fs/sysv/super.c
+++ b/fs/sysv/super.c
@@ -332,8 +332,8 @@ static int complete_read_super(struct super_block *sb, int silent, int size)
        sb->s_magic = SYSV_MAGIC_BASE + sbi->s_type;
        /* set up enough so that it can read an inode */
        sb->s_op = &sysv_sops;
-        root_inode = iget(sb,SYSV_ROOT_INO);
+        root_inode = sysv_iget(sb, SYSV_ROOT_INO);
-        if (!root_inode || is_bad_inode(root_inode)) {
+        if (IS_ERR(root_inode)) {
                printk("SysV FS: get root inode failed\n");
                return 0;
        }
diff --git a/fs/sysv/sysv.h b/fs/sysv/sysv.h
index 64c03bdf06a5..42d51d1c05cd 100644
--- a/fs/sysv/sysv.h
+++ b/fs/sysv/sysv.h
@@ -141,6 +141,7 @@ extern int __sysv_write_begin(struct file *file, struct address_space *mapping,
                        struct page **pagep, void **fsdata);
 /* inode.c */
+extern struct inode *sysv_iget(struct super_block *, unsigned int);
 extern int sysv_write_inode(struct inode *, int);
 extern int sysv_sync_inode(struct inode *);
 extern int sysv_sync_file(struct file *, struct dentry *, int);
diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index 4320782761ae..489f26bc26d9 100644
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -714,26 +714,30 @@ static int ufs2_read_inode(struct inode *inode, struct ufs2_inode *ufs2_inode)
        return 0;
 }
-void ufs_read_inode(struct inode * inode)
+struct inode *ufs_iget(struct super_block *sb, unsigned long ino)
 {
-        struct ufs_inode_info *ufsi = UFS_I(inode);
+        struct ufs_inode_info *ufsi;
-        struct super_block * sb;
+        struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
-        struct ufs_sb_private_info * uspi;
        struct buffer_head * bh;
+        struct inode *inode;
        int err;
-        UFSD("ENTER, ino %lu\n", inode->i_ino);
+        UFSD("ENTER, ino %lu\n", ino);
-        sb = inode->i_sb;
-        uspi = UFS_SB(sb)->s_uspi;
-        if (inode->i_ino < UFS_ROOTINO ||
+        if (ino < UFS_ROOTINO || ino > (uspi->s_ncg * uspi->s_ipg)) {
-            inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
                ufs_warning(sb, "ufs_read_inode", "bad inode number (%lu)\n",
-                            inode->i_ino);
+                            ino);
-                goto bad_inode;
+                return ERR_PTR(-EIO);
        }
+        inode = iget_locked(sb, ino);
+        if (!inode)
+                return ERR_PTR(-ENOMEM);
+        if (!(inode->i_state & I_NEW))
+                return inode;
+        ufsi = UFS_I(inode);
        bh = sb_bread(sb, uspi->s_sbbase + ufs_inotofsba(inode->i_ino));
        if (!bh) {
                ufs_warning(sb, "ufs_read_inode", "unable to read inode %lu\n",
@@ -765,10 +769,12 @@ void ufs_read_inode(struct inode * inode)
        brelse(bh);
        UFSD("EXIT\n");
-        return;
+        unlock_new_inode(inode);
+        return inode;
 bad_inode:
-        make_bad_inode(inode);
+        iget_failed(inode);
+        return ERR_PTR(-EIO);
 }
 static void ufs1_update_inode(struct inode *inode, struct ufs_inode *ufs_inode)
diff --git a/fs/ufs/namei.c b/fs/ufs/namei.c
index d8bfbee2fe2b..747a4de6c695 100644
--- a/fs/ufs/namei.c
+++ b/fs/ufs/namei.c
@@ -57,10 +57,10 @@ static struct dentry *ufs_lookup(struct inode * dir, struct dentry *dentry, stru
        lock_kernel();
        ino = ufs_inode_by_name(dir, dentry);
        if (ino) {
-                inode = iget(dir->i_sb, ino);
+                inode = ufs_iget(dir->i_sb, ino);
-                if (!inode) {
+                if (IS_ERR(inode)) {
                        unlock_kernel();
-                        return ERR_PTR(-EACCES);
+                        return ERR_CAST(inode);
                }
        }
        unlock_kernel();
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index 0072cb33ebec..73deff475e63 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -633,6 +633,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
        unsigned block_size, super_block_size;
        unsigned flags;
        unsigned super_block_offset;
+        int ret = -EINVAL;
        uspi = NULL;
        ubh = NULL;
@@ -1065,12 +1066,16 @@ magic_found:
                uspi->s_maxsymlinklen =
                    fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen);
-        inode = iget(sb, UFS_ROOTINO);
+        inode = ufs_iget(sb, UFS_ROOTINO);
-        if (!inode || is_bad_inode(inode))
+        if (IS_ERR(inode)) {
+                ret = PTR_ERR(inode);
                goto failed;
+        }
        sb->s_root = d_alloc_root(inode);
-        if (!sb->s_root)
+        if (!sb->s_root) {
+                ret = -ENOMEM;
                goto dalloc_failed;
+        }
        ufs_setup_cstotal(sb);
        /*
@@ -1092,7 +1097,7 @@ failed:
        kfree(sbi);
        sb->s_fs_info = NULL;
        UFSD("EXIT (FAILED)\n");
-        return -EINVAL;
+        return ret;
 failed_nomem:
        UFSD("EXIT (NOMEM)\n");
@@ -1326,7 +1331,6 @@ static ssize_t ufs_quota_write(struct super_block *, int, const char *, size_t,
 static const struct super_operations ufs_super_ops = {
        .alloc_inode    = ufs_alloc_inode,
        .destroy_inode  = ufs_destroy_inode,
-        .read_inode     = ufs_read_inode,
        .write_inode    = ufs_write_inode,
        .delete_inode   = ufs_delete_inode,
        .put_super      = ufs_put_super,
diff --git a/fs/ufs/ufs.h b/fs/ufs/ufs.h
index 7faa4cd71a27..fcb9231bb9ed 100644
--- a/fs/ufs/ufs.h
+++ b/fs/ufs/ufs.h
@@ -106,7 +106,7 @@ extern void ufs_free_inode (struct inode *inode);
 extern struct inode * ufs_new_inode (struct inode *, int);
 /* inode.c */
-extern void ufs_read_inode (struct inode *);
+extern struct inode *ufs_iget(struct super_block *, unsigned long);
 extern void ufs_put_inode (struct inode *);
 extern int ufs_write_inode (struct inode *, int);
 extern int ufs_sync_inode (struct inode *);
diff --git a/fs/vfat/namei.c b/fs/vfat/namei.c
index c28add2fbe95..cd450bea9f1a 100644
--- a/fs/vfat/namei.c
+++ b/fs/vfat/namei.c
@@ -705,7 +705,7 @@ static struct dentry *vfat_lookup(struct inode *dir, struct dentry *dentry,
        brelse(sinfo.bh);
        if (IS_ERR(inode)) {
                unlock_kernel();
-                return ERR_PTR(PTR_ERR(inode));
+                return ERR_CAST(inode);
        }
        alias = d_find_alias(inode);
        if (alias) {