1 files changed, 46 insertions, 20 deletions

diff --git a/fs/inode.c b/fs/inode.c
index 069721f0cc0e..d30640f7a193 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -841,7 +841,11 @@ unsigned int get_next_ino(void)
         }
 #endif
 
-        *p = ++res;
+        res++;
+        /* get_next_ino should not provide a 0 inode number */
+        if (unlikely(!res))
+                res++;
+        *p = res;
         put_cpu_var(last_ino);
         return res;
 }
@@ -1674,7 +1678,31 @@ int should_remove_suid(struct dentry *dentry)
 }
 EXPORT_SYMBOL(should_remove_suid);
 
-static int __remove_suid(struct dentry *dentry, int kill)
+/*
+ * Return mask of changes for notify_change() that need to be done as a
+ * response to write or truncate. Return 0 if nothing has to be changed.
+ * Negative value on error (change should be denied).
+ */
+int dentry_needs_remove_privs(struct dentry *dentry)
+{
+        struct inode *inode = d_inode(dentry);
+        int mask = 0;
+        int ret;
+
+        if (IS_NOSEC(inode))
+                return 0;
+
+        mask = should_remove_suid(dentry);
+        ret = security_inode_need_killpriv(dentry);
+        if (ret < 0)
+                return ret;
+        if (ret)
+                mask |= ATTR_KILL_PRIV;
+        return mask;
+}
+EXPORT_SYMBOL(dentry_needs_remove_privs);
+
+static int __remove_privs(struct dentry *dentry, int kill)
 {
         struct iattr newattrs;
 
@@ -1686,33 +1714,32 @@ static int __remove_suid(struct dentry *dentry, int kill)
         return notify_change(dentry, &newattrs, NULL);
 }
 
-int file_remove_suid(struct file *file)
+/*
+ * Remove special file priviledges (suid, capabilities) when file is written
+ * to or truncated.
+ */
+int file_remove_privs(struct file *file)
 {
         struct dentry *dentry = file->f_path.dentry;
         struct inode *inode = d_inode(dentry);
-        int killsuid;
-        int killpriv;
+        int kill;
         int error = 0;
 
         /* Fast path for nothing security related */
         if (IS_NOSEC(inode))
                 return 0;
 
-        killsuid = should_remove_suid(dentry);
-        killpriv = security_inode_need_killpriv(dentry);
-
-        if (killpriv < 0)
-                return killpriv;
-        if (killpriv)
-                error = security_inode_killpriv(dentry);
-        if (!error && killsuid)
-                error = __remove_suid(dentry, killsuid);
-        if (!error && (inode->i_sb->s_flags & MS_NOSEC))
-                inode->i_flags |= S_NOSEC;
+        kill = file_needs_remove_privs(file);
+        if (kill < 0)
+                return kill;
+        if (kill)
+                error = __remove_privs(dentry, kill);
+        if (!error)
+                inode_has_no_xattr(inode);
 
         return error;
 }
-EXPORT_SYMBOL(file_remove_suid);
+EXPORT_SYMBOL(file_remove_privs);
 
 /**
  *      file_update_time        -       update mtime and ctime time
@@ -1967,9 +1994,8 @@ EXPORT_SYMBOL(inode_dio_wait);
  * inode is being instantiated).  The reason for the cmpxchg() loop
  * --- which wouldn't be necessary if all code paths which modify
  * i_flags actually followed this rule, is that there is at least one
- * code path which doesn't today --- for example,
- * __generic_file_aio_write() calls file_remove_suid() without holding
- * i_mutex --- so we use cmpxchg() out of an abundance of caution.
+ * code path which doesn't today so we use cmpxchg() out of an abundance
+ * of caution.
  *
  * In the long run, i_mutex is overkill, and we should probably look
  * at using the i_lock spinlock to protect i_flags, and then make sure