Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ebiederm/user-namespace

Pull user namespace enhancements from Eric Biederman:
 "This is a course correction for the user namespace, so that we can
  reach an inexpensive, maintainable, and reasonably complete
  implementation.

  Highlights:
   - Config guards make it impossible to enable the user namespace and
     code that has not been converted to be user namespace safe.

   - Use of the new kuid_t type ensures the if you somehow get past the
     config guards the kernel will encounter type errors if you enable
     user namespaces and attempt to compile in code whose permission
     checks have not been updated to be user namespace safe.

   - All uids from child user namespaces are mapped into the initial
     user namespace before they are processed.  Removing the need to add
     an additional check to see if the user namespace of the compared
     uids remains the same.

   - With the user namespaces compiled out the performance is as good or
     better than it is today.

   - For most operations absolutely nothing changes performance or
     operationally with the user namespace enabled.

   - The worst case performance I could come up with was timing 1
     billion cache cold stat operations with the user namespace code
     enabled.  This went from 156s to 164s on my laptop (or 156ns to
     164ns per stat operation).

   - (uid_t)-1 and (gid_t)-1 are reserved as an internal error value.
     Most uid/gid setting system calls treat these value specially
     anyway so attempting to use -1 as a uid would likely cause
     entertaining failures in userspace.

   - If setuid is called with a uid that can not be mapped setuid fails.
     I have looked at sendmail, login, ssh and every other program I
     could think of that would call setuid and they all check for and
     handle the case where setuid fails.

   - If stat or a similar system call is called from a context in which
     we can not map a uid we lie and return overflowuid.  The LFS
     experience suggests not lying and returning an error code might be
     better, but the historical precedent with uids is different and I
     can not think of anything that would break by lying about a uid we
     can't map.

   - Capabilities are localized to the current user namespace making it
     safe to give the initial user in a user namespace all capabilities.

  My git tree covers all of the modifications needed to convert the core
  kernel and enough changes to make a system bootable to runlevel 1."

Fix up trivial conflicts due to nearby independent changes in fs/stat.c

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ebiederm/user-namespace: (46 commits)
  userns:  Silence silly gcc warning.
  cred: use correct cred accessor with regards to rcu read lock
  userns: Convert the move_pages, and migrate_pages permission checks to use uid_eq
  userns: Convert cgroup permission checks to use uid_eq
  userns: Convert tmpfs to use kuid and kgid where appropriate
  userns: Convert sysfs to use kgid/kuid where appropriate
  userns: Convert sysctl permission checks to use kuid and kgids.
  userns: Convert proc to use kuid/kgid where appropriate
  userns: Convert ext4 to user kuid/kgid where appropriate
  userns: Convert ext3 to use kuid/kgid where appropriate
  userns: Convert ext2 to use kuid/kgid where appropriate.
  userns: Convert devpts to use kuid/kgid where appropriate
  userns: Convert binary formats to use kuid/kgid where appropriate
  userns: Add negative depends on entries to avoid building code that is userns unsafe
  userns: signal remove unnecessary map_cred_ns
  userns: Teach inode_capable to understand inodes whose uids map to other namespaces.
  userns: Fail exec for suid and sgid binaries with ids outside our user namespace.
  userns: Convert stat to return values mapped from kuids and kgids
  userns: Convert user specfied uids and gids in chown into kuids and kgid
  userns: Use uid_eq gid_eq helpers when comparing kuids and kgids in the vfs
  ...

6 files changed, 54 insertions, 34 deletions

diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index 4bbd07a6fa18..c45c41129a35 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -461,8 +461,8 @@ static int ext4_has_free_clusters(struct ext4_sb_info *sbi,
                 return 1;
 
         /* Hm, nope.  Are (enough) root reserved clusters available? */
-        if (sbi->s_resuid == current_fsuid() ||
-            ((sbi->s_resgid != 0) && in_group_p(sbi->s_resgid)) ||
+        if (uid_eq(sbi->s_resuid, current_fsuid()) ||
+            (!gid_eq(sbi->s_resgid, GLOBAL_ROOT_GID) && in_group_p(sbi->s_resgid)) ||
             capable(CAP_SYS_RESOURCE) ||
                 (flags & EXT4_MB_USE_ROOT_BLOCKS)) {
 
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 0e01e90add8b..c21b1de51afb 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1153,8 +1153,8 @@ struct ext4_sb_info {
         unsigned int s_mount_flags;
         unsigned int s_def_mount_opt;
         ext4_fsblk_t s_sb_block;
-        uid_t s_resuid;
-        gid_t s_resgid;
+        kuid_t s_resuid;
+        kgid_t s_resgid;
         unsigned short s_mount_state;
         unsigned short s_pad;
         int s_addr_per_block_bits;
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 409c2ee7750a..9f9acac6c43f 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -808,8 +808,8 @@ got:
         }
         if (owner) {
                 inode->i_mode = mode;
-                inode->i_uid = owner[0];
-                inode->i_gid = owner[1];
+                i_uid_write(inode, owner[0]);
+                i_gid_write(inode, owner[1]);
         } else if (test_opt(sb, GRPID)) {
                 inode->i_mode = mode;
                 inode->i_uid = current_fsuid();
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index c77b0bd2c711..07eaf565fdcb 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -3630,6 +3630,8 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
         journal_t *journal = EXT4_SB(sb)->s_journal;
         long ret;
         int block;
+        uid_t i_uid;
+        gid_t i_gid;
 
         inode = iget_locked(sb, ino);
         if (!inode)
@@ -3645,12 +3647,14 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
                 goto bad_inode;
         raw_inode = ext4_raw_inode(&iloc);
         inode->i_mode = le16_to_cpu(raw_inode->i_mode);
-        inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
-        inode->i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
+        i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
+        i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
         if (!(test_opt(inode->i_sb, NO_UID32))) {
-                inode->i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
-                inode->i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
+                i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
+                i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
         }
+        i_uid_write(inode, i_uid);
+        i_gid_write(inode, i_gid);
         set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
 
         ext4_clear_state_flags(ei);     /* Only relevant on 32-bit archs */
@@ -3870,6 +3874,8 @@ static int ext4_do_update_inode(handle_t *handle,
         struct ext4_inode_info *ei = EXT4_I(inode);
         struct buffer_head *bh = iloc->bh;
         int err = 0, rc, block;
+        uid_t i_uid;
+        gid_t i_gid;
 
         /* For fields not not tracking in the in-memory inode,
          * initialise them to zero for new inodes. */
@@ -3878,27 +3884,27 @@ static int ext4_do_update_inode(handle_t *handle,
 
         ext4_get_inode_flags(ei);
         raw_inode->i_mode = cpu_to_le16(inode->i_mode);
+        i_uid = i_uid_read(inode);
+        i_gid = i_gid_read(inode);
         if (!(test_opt(inode->i_sb, NO_UID32))) {
-                raw_inode->i_uid_low = cpu_to_le16(low_16_bits(inode->i_uid));
-                raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid));
+                raw_inode->i_uid_low = cpu_to_le16(low_16_bits(i_uid));
+                raw_inode->i_gid_low = cpu_to_le16(low_16_bits(i_gid));
 /*
  * Fix up interoperability with old kernels. Otherwise, old inodes get
  * re-used with the upper 16 bits of the uid/gid intact
  */
                 if (!ei->i_dtime) {
                         raw_inode->i_uid_high =
-                                cpu_to_le16(high_16_bits(inode->i_uid));
+                                cpu_to_le16(high_16_bits(i_uid));
                         raw_inode->i_gid_high =
-                                cpu_to_le16(high_16_bits(inode->i_gid));
+                                cpu_to_le16(high_16_bits(i_gid));
                 } else {
                         raw_inode->i_uid_high = 0;
                         raw_inode->i_gid_high = 0;
                 }
         } else {
-                raw_inode->i_uid_low =
-                        cpu_to_le16(fs_high2lowuid(inode->i_uid));
-                raw_inode->i_gid_low =
-                        cpu_to_le16(fs_high2lowgid(inode->i_gid));
+                raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(i_uid));
+                raw_inode->i_gid_low = cpu_to_le16(fs_high2lowgid(i_gid));
                 raw_inode->i_uid_high = 0;
                 raw_inode->i_gid_high = 0;
         }
@@ -4084,8 +4090,8 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr)
 
         if (is_quota_modification(inode, attr))
                 dquot_initialize(inode);
-        if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
-                (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
+        if ((ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, inode->i_uid)) ||
+            (ia_valid & ATTR_GID && !gid_eq(attr->ia_gid, inode->i_gid))) {
                 handle_t *handle;
 
                 /* (user+group)*(old+new) structure, inode write (sb,
diff --git a/fs/ext4/migrate.c b/fs/ext4/migrate.c
index f39f80f8f2c5..f1bb32ec0169 100644
--- a/fs/ext4/migrate.c
+++ b/fs/ext4/migrate.c
@@ -466,8 +466,8 @@ int ext4_ext_migrate(struct inode *inode)
         }
         goal = (((inode->i_ino - 1) / EXT4_INODES_PER_GROUP(inode->i_sb)) *
                 EXT4_INODES_PER_GROUP(inode->i_sb)) + 1;
-        owner[0] = inode->i_uid;
-        owner[1] = inode->i_gid;
+        owner[0] = i_uid_read(inode);
+        owner[1] = i_gid_read(inode);
         tmp_inode = ext4_new_inode(handle, inode->i_sb->s_root->d_inode,
                                    S_IFREG, NULL, goal, owner);
         if (IS_ERR(tmp_inode)) {
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index e1fb1d5de58e..436b4223df66 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -1448,6 +1448,8 @@ static int handle_mount_opt(struct super_block *sb, char *opt, int token,
 {
         struct ext4_sb_info *sbi = EXT4_SB(sb);
         const struct mount_opts *m;
+        kuid_t uid;
+        kgid_t gid;
         int arg = 0;
 
 #ifdef CONFIG_QUOTA
@@ -1474,10 +1476,20 @@ static int handle_mount_opt(struct super_block *sb, char *opt, int token,
                          "Ignoring removed %s option", opt);
                 return 1;
         case Opt_resuid:
-                sbi->s_resuid = arg;
+                uid = make_kuid(current_user_ns(), arg);
+                if (!uid_valid(uid)) {
+                        ext4_msg(sb, KERN_ERR, "Invalid uid value %d", arg);
+                        return -1;
+                }
+                sbi->s_resuid = uid;
                 return 1;
         case Opt_resgid:
-                sbi->s_resgid = arg;
+                gid = make_kgid(current_user_ns(), arg);
+                if (!gid_valid(gid)) {
+                        ext4_msg(sb, KERN_ERR, "Invalid gid value %d", arg);
+                        return -1;
+                }
+                sbi->s_resgid = gid;
                 return 1;
         case Opt_abort:
                 sbi->s_mount_flags |= EXT4_MF_FS_ABORTED;
@@ -1732,12 +1744,14 @@ static int _ext4_show_options(struct seq_file *seq, struct super_block *sb,
                 SEQ_OPTS_PRINT("%s", token2str(m->token));
         }
 
-        if (nodefs || sbi->s_resuid != EXT4_DEF_RESUID ||
+        if (nodefs || !uid_eq(sbi->s_resuid, make_kuid(&init_user_ns, EXT4_DEF_RESUID)) ||
             le16_to_cpu(es->s_def_resuid) != EXT4_DEF_RESUID)
-                SEQ_OPTS_PRINT("resuid=%u", sbi->s_resuid);
-        if (nodefs || sbi->s_resgid != EXT4_DEF_RESGID ||
+                SEQ_OPTS_PRINT("resuid=%u",
+                                from_kuid_munged(&init_user_ns, sbi->s_resuid));
+        if (nodefs || !gid_eq(sbi->s_resgid, make_kgid(&init_user_ns, EXT4_DEF_RESGID)) ||
             le16_to_cpu(es->s_def_resgid) != EXT4_DEF_RESGID)
-                SEQ_OPTS_PRINT("resgid=%u", sbi->s_resgid);
+                SEQ_OPTS_PRINT("resgid=%u",
+                                from_kgid_munged(&init_user_ns, sbi->s_resgid));
         def_errors = nodefs ? -1 : le16_to_cpu(es->s_errors);
         if (test_opt(sb, ERRORS_RO) && def_errors != EXT4_ERRORS_RO)
                 SEQ_OPTS_PUTS("errors=remount-ro");
@@ -2980,8 +2994,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         }
         sb->s_fs_info = sbi;
         sbi->s_mount_opt = 0;
-        sbi->s_resuid = EXT4_DEF_RESUID;
-        sbi->s_resgid = EXT4_DEF_RESGID;
+        sbi->s_resuid = make_kuid(&init_user_ns, EXT4_DEF_RESUID);
+        sbi->s_resgid = make_kgid(&init_user_ns, EXT4_DEF_RESGID);
         sbi->s_inode_readahead_blks = EXT4_DEF_INODE_READAHEAD_BLKS;
         sbi->s_sb_block = sb_block;
         if (sb->s_bdev->bd_part)
@@ -3060,8 +3074,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         if (def_mount_opts & EXT4_DEFM_DISCARD)
                 set_opt(sb, DISCARD);
 
-        sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
-        sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
+        sbi->s_resuid = make_kuid(&init_user_ns, le16_to_cpu(es->s_def_resuid));
+        sbi->s_resgid = make_kgid(&init_user_ns, le16_to_cpu(es->s_def_resgid));
         sbi->s_commit_interval = JBD2_DEFAULT_MAX_COMMIT_AGE * HZ;
         sbi->s_min_batch_time = EXT4_DEF_MIN_BATCH_TIME;
         sbi->s_max_batch_time = EXT4_DEF_MAX_BATCH_TIME;
@@ -4213,8 +4227,8 @@ static int ext4_unfreeze(struct super_block *sb)
 struct ext4_mount_options {
         unsigned long s_mount_opt;
         unsigned long s_mount_opt2;
-        uid_t s_resuid;
-        gid_t s_resgid;
+        kuid_t s_resuid;
+        kgid_t s_resgid;
         unsigned long s_commit_interval;
         u32 s_min_batch_time, s_max_batch_time;
 #ifdef CONFIG_QUOTA