25 files changed, 133 insertions, 120 deletions

diff --git a/Documentation/filesystems/nfs/Exporting b/Documentation/filesystems/nfs/Exporting
index 87019d2b5981..09994c247289 100644
--- a/Documentation/filesystems/nfs/Exporting
+++ b/Documentation/filesystems/nfs/Exporting
@@ -92,7 +92,14 @@ For a filesystem to be exportable it must:
    1/ provide the filehandle fragment routines described below.
    2/ make sure that d_splice_alias is used rather than d_add
       when ->lookup finds an inode for a given parent and name.
-      Typically the ->lookup routine will end with a:
+
+      If inode is NULL, d_splice_alias(inode, dentry) is eqivalent to
+
+                d_add(dentry, inode), NULL
+
+      Similarly, d_splice_alias(ERR_PTR(err), dentry) = ERR_PTR(err)
+
+      Typically the ->lookup routine will simply end with a:
 
                 return d_splice_alias(inode, dentry);
         }
diff --git a/drivers/pci/pci-label.c b/drivers/pci/pci-label.c
index 77cb2a14c896..81525ae5d869 100644
--- a/drivers/pci/pci-label.c
+++ b/drivers/pci/pci-label.c
@@ -55,7 +55,7 @@ enum smbios_attr_enum {
         SMBIOS_ATTR_INSTANCE_SHOW,
 };
 
-static mode_t
+static size_t
 find_smbios_instance_string(struct pci_dev *pdev, char *buf,
                             enum smbios_attr_enum attribute)
 {
diff --git a/fs/anon_inodes.c b/fs/anon_inodes.c
index 4d433d34736f..f11e43ed907d 100644
--- a/fs/anon_inodes.c
+++ b/fs/anon_inodes.c
@@ -187,7 +187,7 @@ EXPORT_SYMBOL_GPL(anon_inode_getfd);
  */
 static struct inode *anon_inode_mkinode(void)
 {
-        struct inode *inode = new_inode(anon_inode_mnt->mnt_sb);
+        struct inode *inode = new_inode_pseudo(anon_inode_mnt->mnt_sb);
 
         if (!inode)
                 return ERR_PTR(-ENOMEM);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index e91b097e7252..caa26ab5ed68 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4467,7 +4467,7 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
         inode->i_generation = BTRFS_I(inode)->generation;
         btrfs_set_inode_space_info(root, inode);
 
-        if (mode & S_IFDIR)
+        if (S_ISDIR(mode))
                 owner = 0;
         else
                 owner = 1;
@@ -4512,7 +4512,7 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
 
         btrfs_inherit_iflags(inode, dir);
 
-        if ((mode & S_IFREG)) {
+        if (S_ISREG(mode)) {
                 if (btrfs_test_opt(root, NODATASUM))
                         BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
                 if (btrfs_test_opt(root, NODATACOW) ||
diff --git a/fs/dcache.c b/fs/dcache.c
index be18598c7fd7..b05aac3a8cfc 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -2138,8 +2138,9 @@ static void dentry_unlock_parents_for_move(struct dentry *dentry,
  * @target: new dentry
  *
  * Update the dcache to reflect the move of a file name. Negative
- * dcache entries should not be moved in this way.  Caller hold
- * rename_lock.
+ * dcache entries should not be moved in this way. Caller must hold
+ * rename_lock, the i_mutex of the source and target directories,
+ * and the sb->s_vfs_rename_mutex if they differ. See lock_rename().
  */
 static void __d_move(struct dentry * dentry, struct dentry * target)
 {
@@ -2202,7 +2203,8 @@ static void __d_move(struct dentry * dentry, struct dentry * target)
  * @target: new dentry
  *
  * Update the dcache to reflect the move of a file name. Negative
- * dcache entries should not be moved in this way.
+ * dcache entries should not be moved in this way. See the locking
+ * requirements for __d_move.
  */
 void d_move(struct dentry *dentry, struct dentry *target)
 {
@@ -2320,7 +2322,8 @@ static void __d_materialise_dentry(struct dentry *dentry, struct dentry *anon)
  * @inode: inode to bind to the dentry, to which aliases may be attached
  *
  * Introduces an dentry into the tree, substituting an extant disconnected
- * root directory alias in its place if there is one
+ * root directory alias in its place if there is one. Caller must hold the
+ * i_mutex of the parent directory.
  */
 struct dentry *d_materialise_unique(struct dentry *dentry, struct inode *inode)
 {
diff --git a/fs/inode.c b/fs/inode.c
index a48fa5355fb4..d0c72ff6b30e 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -361,9 +361,11 @@ EXPORT_SYMBOL_GPL(inode_sb_list_add);
 
 static inline void inode_sb_list_del(struct inode *inode)
 {
-        spin_lock(&inode_sb_list_lock);
-        list_del_init(&inode->i_sb_list);
-        spin_unlock(&inode_sb_list_lock);
+        if (!list_empty(&inode->i_sb_list)) {
+                spin_lock(&inode_sb_list_lock);
+                list_del_init(&inode->i_sb_list);
+                spin_unlock(&inode_sb_list_lock);
+        }
 }
 
 static unsigned long hash(struct super_block *sb, unsigned long hashval)
@@ -796,6 +798,29 @@ unsigned int get_next_ino(void)
 EXPORT_SYMBOL(get_next_ino);
 
 /**
+ *      new_inode_pseudo        - obtain an inode
+ *      @sb: superblock
+ *
+ *      Allocates a new inode for given superblock.
+ *      Inode wont be chained in superblock s_inodes list
+ *      This means :
+ *      - fs can't be unmount
+ *      - quotas, fsnotify, writeback can't work
+ */
+struct inode *new_inode_pseudo(struct super_block *sb)
+{
+        struct inode *inode = alloc_inode(sb);
+
+        if (inode) {
+                spin_lock(&inode->i_lock);
+                inode->i_state = 0;
+                spin_unlock(&inode->i_lock);
+                INIT_LIST_HEAD(&inode->i_sb_list);
+        }
+        return inode;
+}
+
+/**
  *      new_inode       - obtain an inode
  *      @sb: superblock
  *
@@ -813,13 +838,9 @@ struct inode *new_inode(struct super_block *sb)
 
         spin_lock_prefetch(&inode_sb_list_lock);
 
-        inode = alloc_inode(sb);
-        if (inode) {
-                spin_lock(&inode->i_lock);
-                inode->i_state = 0;
-                spin_unlock(&inode->i_lock);
+        inode = new_inode_pseudo(sb);
+        if (inode)
                 inode_sb_list_add(inode);
-        }
         return inode;
 }
 EXPORT_SYMBOL(new_inode);
diff --git a/fs/jffs2/fs.c b/fs/jffs2/fs.c
index eeead33d8ef0..b81b35ddf4e4 100644
--- a/fs/jffs2/fs.c
+++ b/fs/jffs2/fs.c
@@ -80,7 +80,7 @@ int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
                                   ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
         if (ret) {
                 jffs2_free_raw_inode(ri);
-                if (S_ISLNK(inode->i_mode & S_IFMT))
+                if (S_ISLNK(inode->i_mode))
                          kfree(mdata);
                 return ret;
         }
diff --git a/fs/omfs/dir.c b/fs/omfs/dir.c
index 3b8d3979e03b..98e544274390 100644
--- a/fs/omfs/dir.c
+++ b/fs/omfs/dir.c
@@ -93,7 +93,7 @@ int omfs_make_empty(struct inode *inode, struct super_block *sb)
 
         memset(bh->b_data, 0, sizeof(struct omfs_inode));
 
-        if (inode->i_mode & S_IFDIR) {
+        if (S_ISDIR(inode->i_mode)) {
                 memset(&bh->b_data[OMFS_DIR_START], 0xff,
                         sbi->s_sys_blocksize - OMFS_DIR_START);
         } else
diff --git a/fs/open.c b/fs/open.c
index 739b751aa73e..f71192109457 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -446,74 +446,52 @@ out:
         return error;
 }
 
-SYSCALL_DEFINE2(fchmod, unsigned int, fd, mode_t, mode)
+static int chmod_common(struct path *path, umode_t mode)
 {
-        struct inode * inode;
-        struct dentry * dentry;
-        struct file * file;
-        int err = -EBADF;
+        struct inode *inode = path->dentry->d_inode;
         struct iattr newattrs;
+        int error;
 
-        file = fget(fd);
-        if (!file)
-                goto out;
-
-        dentry = file->f_path.dentry;
-        inode = dentry->d_inode;
-
-        audit_inode(NULL, dentry);
-
-        err = mnt_want_write_file(file);
-        if (err)
-                goto out_putf;
+        error = mnt_want_write(path->mnt);
+        if (error)
+                return error;
         mutex_lock(&inode->i_mutex);
-        err = security_path_chmod(dentry, file->f_vfsmnt, mode);
-        if (err)
+        error = security_path_chmod(path->dentry, path->mnt, mode);
+        if (error)
                 goto out_unlock;
-        if (mode == (mode_t) -1)
-                mode = inode->i_mode;
         newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
         newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
-        err = notify_change(dentry, &newattrs);
+        error = notify_change(path->dentry, &newattrs);
 out_unlock:
         mutex_unlock(&inode->i_mutex);
-        mnt_drop_write(file->f_path.mnt);
-out_putf:
-        fput(file);
-out:
+        mnt_drop_write(path->mnt);
+        return error;
+}
+
+SYSCALL_DEFINE2(fchmod, unsigned int, fd, mode_t, mode)
+{
+        struct file * file;
+        int err = -EBADF;
+
+        file = fget(fd);
+        if (file) {
+                audit_inode(NULL, file->f_path.dentry);
+                err = chmod_common(&file->f_path, mode);
+                fput(file);
+        }
         return err;
 }
 
 SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename, mode_t, mode)
 {
         struct path path;
-        struct inode *inode;
         int error;
-        struct iattr newattrs;
 
         error = user_path_at(dfd, filename, LOOKUP_FOLLOW, &path);
-        if (error)
-                goto out;
-        inode = path.dentry->d_inode;
-
-        error = mnt_want_write(path.mnt);
-        if (error)
-                goto dput_and_out;
-        mutex_lock(&inode->i_mutex);
-        error = security_path_chmod(path.dentry, path.mnt, mode);
-        if (error)
-                goto out_unlock;
-        if (mode == (mode_t) -1)
-                mode = inode->i_mode;
-        newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
-        newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
-        error = notify_change(path.dentry, &newattrs);
-out_unlock:
-        mutex_unlock(&inode->i_mutex);
-        mnt_drop_write(path.mnt);
-dput_and_out:
-        path_put(&path);
-out:
+        if (!error) {
+                error = chmod_common(&path, mode);
+                path_put(&path);
+        }
         return error;
 }
 
diff --git a/fs/pipe.c b/fs/pipe.c
index 1b7f9af67ccf..0e0be1dc0f8e 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -948,7 +948,7 @@ static const struct dentry_operations pipefs_dentry_operations = {
 
 static struct inode * get_pipe_inode(void)
 {
-        struct inode *inode = new_inode(pipe_mnt->mnt_sb);
+        struct inode *inode = new_inode_pseudo(pipe_mnt->mnt_sb);
         struct pipe_inode_info *pipe;
 
         if (!inode)
diff --git a/fs/read_write.c b/fs/read_write.c
index 5907b49e4d7e..179f1c33ea57 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -166,8 +166,10 @@ loff_t default_llseek(struct file *file, loff_t offset, int origin)
                          * long as offset isn't at the end of the file then the
                          * offset is data.
                          */
-                        if (offset >= inode->i_size)
-                                return -ENXIO;
+                        if (offset >= inode->i_size) {
+                                retval = -ENXIO;
+                                goto out;
+                        }
                         break;
                 case SEEK_HOLE:
                         /*
@@ -175,8 +177,10 @@ loff_t default_llseek(struct file *file, loff_t offset, int origin)
                          * as long as offset isn't i_size or larger, return
                          * i_size.
                          */
-                        if (offset >= inode->i_size)
-                                return -ENXIO;
+                        if (offset >= inode->i_size) {
+                                retval = -ENXIO;
+                                goto out;
+                        }
                         offset = inode->i_size;
                         break;
         }
diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index acca2c5ca3fa..f7ce7debe14c 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -265,7 +265,7 @@ xfs_open_by_handle(
                 return PTR_ERR(filp);
         }
 
-        if (inode->i_mode & S_IFREG) {
+        if (S_ISREG(inode->i_mode)) {
                 filp->f_flags |= O_NOATIME;
                 filp->f_mode |= FMODE_NOCMTIME;
         }
@@ -850,14 +850,14 @@ xfs_set_diflags(
                 di_flags |= XFS_DIFLAG_NODEFRAG;
         if (xflags & XFS_XFLAG_FILESTREAM)
                 di_flags |= XFS_DIFLAG_FILESTREAM;
-        if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
+        if (S_ISDIR(ip->i_d.di_mode)) {
                 if (xflags & XFS_XFLAG_RTINHERIT)
                         di_flags |= XFS_DIFLAG_RTINHERIT;
                 if (xflags & XFS_XFLAG_NOSYMLINKS)
                         di_flags |= XFS_DIFLAG_NOSYMLINKS;
                 if (xflags & XFS_XFLAG_EXTSZINHERIT)
                         di_flags |= XFS_DIFLAG_EXTSZINHERIT;
-        } else if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) {
+        } else if (S_ISREG(ip->i_d.di_mode)) {
                 if (xflags & XFS_XFLAG_REALTIME)
                         di_flags |= XFS_DIFLAG_REALTIME;
                 if (xflags & XFS_XFLAG_EXTSIZE)
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index c51a3f903633..ab3e5c6c4642 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -414,7 +414,7 @@ xfs_bmap_add_attrfork_local(
 
         if (ip->i_df.if_bytes <= XFS_IFORK_DSIZE(ip))
                 return 0;
-        if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
+        if (S_ISDIR(ip->i_d.di_mode)) {
                 mp = ip->i_mount;
                 memset(&dargs, 0, sizeof(dargs));
                 dargs.dp = ip;
@@ -3344,8 +3344,7 @@ xfs_bmap_local_to_extents(
          * We don't want to deal with the case of keeping inode data inline yet.
          * So sending the data fork of a regular inode is invalid.
          */
-        ASSERT(!((ip->i_d.di_mode & S_IFMT) == S_IFREG &&
-                 whichfork == XFS_DATA_FORK));
+        ASSERT(!(S_ISREG(ip->i_d.di_mode) && whichfork == XFS_DATA_FORK));
         ifp = XFS_IFORK_PTR(ip, whichfork);
         ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);
         flags = 0;
@@ -4052,7 +4051,7 @@ xfs_bmap_one_block(
 
 #ifndef DEBUG
         if (whichfork == XFS_DATA_FORK) {
-                return ((ip->i_d.di_mode & S_IFMT) == S_IFREG) ?
+                return S_ISREG(ip->i_d.di_mode) ?
                         (ip->i_size == ip->i_mount->m_sb.sb_blocksize) :
                         (ip->i_d.di_size == ip->i_mount->m_sb.sb_blocksize);
         }
diff --git a/fs/xfs/xfs_dir2.c b/fs/xfs/xfs_dir2.c
index 4580ce00aeb4..a2e27010c7fb 100644
--- a/fs/xfs/xfs_dir2.c
+++ b/fs/xfs/xfs_dir2.c
@@ -121,7 +121,7 @@ xfs_dir_isempty(
 {
         xfs_dir2_sf_hdr_t       *sfp;
 
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
         if (dp->i_d.di_size == 0)       /* might happen during shutdown. */
                 return 1;
         if (dp->i_d.di_size > XFS_IFORK_DSIZE(dp))
@@ -179,7 +179,7 @@ xfs_dir_init(
         memset((char *)&args, 0, sizeof(args));
         args.dp = dp;
         args.trans = tp;
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
         if ((error = xfs_dir_ino_validate(tp->t_mountp, pdp->i_ino)))
                 return error;
         return xfs_dir2_sf_create(&args, pdp->i_ino);
@@ -202,7 +202,7 @@ xfs_dir_createname(
         int                     rval;
         int                     v;              /* type-checking value */
 
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
         if ((rval = xfs_dir_ino_validate(tp->t_mountp, inum)))
                 return rval;
         XFS_STATS_INC(xs_dir_create);
@@ -278,7 +278,7 @@ xfs_dir_lookup(
         int             rval;
         int             v;              /* type-checking value */
 
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
         XFS_STATS_INC(xs_dir_lookup);
 
         memset(&args, 0, sizeof(xfs_da_args_t));
@@ -333,7 +333,7 @@ xfs_dir_removename(
         int             rval;
         int             v;              /* type-checking value */
 
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
         XFS_STATS_INC(xs_dir_remove);
 
         memset(&args, 0, sizeof(xfs_da_args_t));
@@ -382,7 +382,7 @@ xfs_readdir(
         if (XFS_FORCED_SHUTDOWN(dp->i_mount))
                 return XFS_ERROR(EIO);
 
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
         XFS_STATS_INC(xs_dir_getdents);
 
         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
@@ -414,7 +414,7 @@ xfs_dir_replace(
         int             rval;
         int             v;              /* type-checking value */
 
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
 
         if ((rval = xfs_dir_ino_validate(tp->t_mountp, inum)))
                 return rval;
@@ -464,7 +464,7 @@ xfs_dir_canenter(
         if (resblks)
                 return 0;
 
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
 
         memset(&args, 0, sizeof(xfs_da_args_t));
         args.name = name->name;
diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c
index 9124425b7f2f..3ff3d9e23ded 100644
--- a/fs/xfs/xfs_filestream.c
+++ b/fs/xfs/xfs_filestream.c
@@ -344,9 +344,9 @@ _xfs_filestream_update_ag(
          * Either ip is a regular file and pip is a directory, or ip is a
          * directory and pip is NULL.
          */
-        ASSERT(ip && (((ip->i_d.di_mode & S_IFREG) && pip &&
-                       (pip->i_d.di_mode & S_IFDIR)) ||
-                      ((ip->i_d.di_mode & S_IFDIR) && !pip)));
+        ASSERT(ip && ((S_ISREG(ip->i_d.di_mode) && pip &&
+                       S_ISDIR(pip->i_d.di_mode)) ||
+                      (S_ISDIR(ip->i_d.di_mode) && !pip)));
 
         mp = ip->i_mount;
         cache = mp->m_filestream;
@@ -537,7 +537,7 @@ xfs_filestream_lookup_ag(
         xfs_agnumber_t  ag;
         int             ref;
 
-        if (!(ip->i_d.di_mode & (S_IFREG | S_IFDIR))) {
+        if (!S_ISREG(ip->i_d.di_mode) && !S_ISDIR(ip->i_d.di_mode)) {
                 ASSERT(0);
                 return NULLAGNUMBER;
         }
@@ -579,9 +579,9 @@ xfs_filestream_associate(
         xfs_agnumber_t  ag, rotorstep, startag;
         int             err = 0;
 
-        ASSERT(pip->i_d.di_mode & S_IFDIR);
-        ASSERT(ip->i_d.di_mode & S_IFREG);
-        if (!(pip->i_d.di_mode & S_IFDIR) || !(ip->i_d.di_mode & S_IFREG))
+        ASSERT(S_ISDIR(pip->i_d.di_mode));
+        ASSERT(S_ISREG(ip->i_d.di_mode));
+        if (!S_ISDIR(pip->i_d.di_mode) || !S_ISREG(ip->i_d.di_mode))
                 return -EINVAL;
 
         mp = pip->i_mount;
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 3cc21ddf9f7e..2fcca4b03ed3 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -368,7 +368,7 @@ xfs_iformat(
                         /*
                          * no local regular files yet
                          */
-                        if (unlikely((be16_to_cpu(dip->di_mode) & S_IFMT) == S_IFREG)) {
+                        if (unlikely(S_ISREG(be16_to_cpu(dip->di_mode)))) {
                                 xfs_warn(ip->i_mount,
                         "corrupt inode %Lu (local format for regular file).",
                                         (unsigned long long) ip->i_ino);
@@ -1040,7 +1040,7 @@ xfs_ialloc(
 
         if (pip && XFS_INHERIT_GID(pip)) {
                 ip->i_d.di_gid = pip->i_d.di_gid;
-                if ((pip->i_d.di_mode & S_ISGID) && (mode & S_IFMT) == S_IFDIR) {
+                if ((pip->i_d.di_mode & S_ISGID) && S_ISDIR(mode)) {
                         ip->i_d.di_mode |= S_ISGID;
                 }
         }
@@ -1097,14 +1097,14 @@ xfs_ialloc(
                 if (pip && (pip->i_d.di_flags & XFS_DIFLAG_ANY)) {
                         uint    di_flags = 0;
 
-                        if ((mode & S_IFMT) == S_IFDIR) {
+                        if (S_ISDIR(mode)) {
                                 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
                                         di_flags |= XFS_DIFLAG_RTINHERIT;
                                 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
                                         di_flags |= XFS_DIFLAG_EXTSZINHERIT;
                                         ip->i_d.di_extsize = pip->i_d.di_extsize;
                                 }
-                        } else if ((mode & S_IFMT) == S_IFREG) {
+                        } else if (S_ISREG(mode)) {
                                 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
                                         di_flags |= XFS_DIFLAG_REALTIME;
                                 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
@@ -1188,7 +1188,7 @@ xfs_isize_check(
         int                     nimaps;
         xfs_bmbt_irec_t         imaps[2];
 
-        if ((ip->i_d.di_mode & S_IFMT) != S_IFREG)
+        if (!S_ISREG(ip->i_d.di_mode))
                 return;
 
         if (XFS_IS_REALTIME_INODE(ip))
@@ -1828,7 +1828,7 @@ xfs_ifree(
         ASSERT(ip->i_d.di_nextents == 0);
         ASSERT(ip->i_d.di_anextents == 0);
         ASSERT((ip->i_d.di_size == 0 && ip->i_size == 0) ||
-               ((ip->i_d.di_mode & S_IFMT) != S_IFREG));
+               (!S_ISREG(ip->i_d.di_mode)));
         ASSERT(ip->i_d.di_nblocks == 0);
 
         /*
@@ -2671,7 +2671,7 @@ xfs_iflush_int(
                         __func__, ip->i_ino, ip, ip->i_d.di_magic);
                 goto corrupt_out;
         }
-        if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) {
+        if (S_ISREG(ip->i_d.di_mode)) {
                 if (XFS_TEST_ERROR(
                     (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
                     (ip->i_d.di_format != XFS_DINODE_FMT_BTREE),
@@ -2681,7 +2681,7 @@ xfs_iflush_int(
                                 __func__, ip->i_ino, ip);
                         goto corrupt_out;
                 }
-        } else if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
+        } else if (S_ISDIR(ip->i_d.di_mode)) {
                 if (XFS_TEST_ERROR(
                     (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
                     (ip->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index a97644ab945a..2380a4bcbece 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -263,7 +263,7 @@ typedef struct xfs_inode {
         struct inode            i_vnode;        /* embedded VFS inode */
 } xfs_inode_t;
 
-#define XFS_ISIZE(ip)   (((ip)->i_d.di_mode & S_IFMT) == S_IFREG) ? \
+#define XFS_ISIZE(ip)   S_ISREG((ip)->i_d.di_mode) ? \
                                 (ip)->i_size : (ip)->i_d.di_size;
 
 /* Convert from vfs inode to xfs inode */
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 8fe4206de057..052a2c0ec5fb 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -2283,7 +2283,7 @@ xlog_recover_inode_pass2(
         /* Take the opportunity to reset the flush iteration count */
         dicp->di_flushiter = 0;
 
-        if (unlikely((dicp->di_mode & S_IFMT) == S_IFREG)) {
+        if (unlikely(S_ISREG(dicp->di_mode))) {
                 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
                     (dicp->di_format != XFS_DINODE_FMT_BTREE)) {
                         XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(3)",
@@ -2296,7 +2296,7 @@ xlog_recover_inode_pass2(
                         error = EFSCORRUPTED;
                         goto error;
                 }
-        } else if (unlikely((dicp->di_mode & S_IFMT) == S_IFDIR)) {
+        } else if (unlikely(S_ISDIR(dicp->di_mode))) {
                 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
                     (dicp->di_format != XFS_DINODE_FMT_BTREE) &&
                     (dicp->di_format != XFS_DINODE_FMT_LOCAL)) {
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 7f25245da289..092e16ae4d9d 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -1331,7 +1331,7 @@ xfs_mountfs(
 
         ASSERT(rip != NULL);
 
-        if (unlikely((rip->i_d.di_mode & S_IFMT) != S_IFDIR)) {
+        if (unlikely(!S_ISDIR(rip->i_d.di_mode))) {
                 xfs_warn(mp, "corrupted root inode %llu: not a directory",
                         (unsigned long long)rip->i_ino);
                 xfs_iunlock(rip, XFS_ILOCK_EXCL);
diff --git a/fs/xfs/xfs_rename.c b/fs/xfs/xfs_rename.c
index 77a59891734e..df78c297d1a1 100644
--- a/fs/xfs/xfs_rename.c
+++ b/fs/xfs/xfs_rename.c
@@ -116,7 +116,7 @@ xfs_rename(
         trace_xfs_rename(src_dp, target_dp, src_name, target_name);
 
         new_parent = (src_dp != target_dp);
-        src_is_directory = ((src_ip->i_d.di_mode & S_IFMT) == S_IFDIR);
+        src_is_directory = S_ISDIR(src_ip->i_d.di_mode);
 
         if (src_is_directory) {
                 /*
@@ -226,7 +226,7 @@ xfs_rename(
                  * target and source are directories and that target can be
                  * destroyed, or that neither is a directory.
                  */
-                if ((target_ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
+                if (S_ISDIR(target_ip->i_d.di_mode)) {
                         /*
                          * Make sure target dir is empty.
                          */
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 88d121486c52..9322e13f0c63 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -121,7 +121,7 @@ xfs_readlink(
 
         xfs_ilock(ip, XFS_ILOCK_SHARED);
 
-        ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFLNK);
+        ASSERT(S_ISLNK(ip->i_d.di_mode));
         ASSERT(ip->i_d.di_size <= MAXPATHLEN);
 
         pathlen = ip->i_d.di_size;
@@ -529,7 +529,7 @@ xfs_release(
         if (ip->i_d.di_nlink == 0)
                 return 0;
 
-        if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
+        if ((S_ISREG(ip->i_d.di_mode) &&
              ((ip->i_size > 0) || (VN_CACHED(VFS_I(ip)) > 0 ||
                ip->i_delayed_blks > 0)) &&
              (ip->i_df.if_flags & XFS_IFEXTENTS))  &&
@@ -610,7 +610,7 @@ xfs_inactive(
         truncate = ((ip->i_d.di_nlink == 0) &&
             ((ip->i_d.di_size != 0) || (ip->i_size != 0) ||
              (ip->i_d.di_nextents > 0) || (ip->i_delayed_blks > 0)) &&
-            ((ip->i_d.di_mode & S_IFMT) == S_IFREG));
+            S_ISREG(ip->i_d.di_mode));
 
         mp = ip->i_mount;
 
@@ -621,7 +621,7 @@ xfs_inactive(
                 goto out;
 
         if (ip->i_d.di_nlink != 0) {
-                if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
+                if ((S_ISREG(ip->i_d.di_mode) &&
                      ((ip->i_size > 0) || (VN_CACHED(VFS_I(ip)) > 0 ||
                        ip->i_delayed_blks > 0)) &&
                       (ip->i_df.if_flags & XFS_IFEXTENTS) &&
@@ -669,7 +669,7 @@ xfs_inactive(
                         xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
                         return VN_INACTIVE_CACHE;
                 }
-        } else if ((ip->i_d.di_mode & S_IFMT) == S_IFLNK) {
+        } else if (S_ISLNK(ip->i_d.di_mode)) {
 
                 /*
                  * If we get an error while cleaning up a
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 5f523eb9bb8d..f23bcb77260c 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2310,7 +2310,8 @@ extern void __iget(struct inode * inode);
 extern void iget_failed(struct inode *);
 extern void end_writeback(struct inode *);
 extern void __destroy_inode(struct inode *);
-extern struct inode *new_inode(struct super_block *);
+extern struct inode *new_inode_pseudo(struct super_block *sb);
+extern struct inode *new_inode(struct super_block *sb);
 extern void free_inode_nonrcu(struct inode *inode);
 extern int should_remove_suid(struct dentry *);
 extern int file_remove_suid(struct file *);
diff --git a/net/socket.c b/net/socket.c
index 02dc82db3d23..26ed35c7751e 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -467,7 +467,7 @@ static struct socket *sock_alloc(void)
         struct inode *inode;
         struct socket *sock;
 
-        inode = new_inode(sock_mnt->mnt_sb);
+        inode = new_inode_pseudo(sock_mnt->mnt_sb);
         if (!inode)
                 return NULL;
 
diff --git a/security/integrity/ima/ima_main.c b/security/integrity/ima/ima_main.c
index 39d66dc2b8e9..26b46ff74663 100644
--- a/security/integrity/ima/ima_main.c
+++ b/security/integrity/ima/ima_main.c
@@ -86,7 +86,7 @@ static void ima_check_last_writer(struct ima_iint_cache *iint,
                                   struct inode *inode,
                                   struct file *file)
 {
-        mode_t mode = file->f_mode;
+        fmode_t mode = file->f_mode;
 
         mutex_lock(&iint->mutex);
         if (mode & FMODE_WRITE &&
diff --git a/sound/isa/msnd/msnd.h b/sound/isa/msnd/msnd.h
index 3773e242b58e..a168ba3313ac 100644
--- a/sound/isa/msnd/msnd.h
+++ b/sound/isa/msnd/msnd.h
@@ -249,7 +249,7 @@ struct snd_msnd {
 
         /* State variables */
         enum { msndClassic, msndPinnacle } type;
-        mode_t mode;
+        fmode_t mode;
         unsigned long flags;
 #define F_RESETTING                     0
 #define F_HAVEDIGITAL                   1