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

Pull user namespace and namespace infrastructure changes from Eric W Biederman:
 "This set of changes starts with a few small enhnacements to the user
  namespace.  reboot support, allowing more arbitrary mappings, and
  support for mounting devpts, ramfs, tmpfs, and mqueuefs as just the
  user namespace root.

  I do my best to document that if you care about limiting your
  unprivileged users that when you have the user namespace support
  enabled you will need to enable memory control groups.

  There is a minor bug fix to prevent overflowing the stack if someone
  creates way too many user namespaces.

  The bulk of the changes are a continuation of the kuid/kgid push down
  work through the filesystems.  These changes make using uids and gids
  typesafe which ensures that these filesystems are safe to use when
  multiple user namespaces are in use.  The filesystems converted for
  3.9 are ceph, 9p, afs, ocfs2, gfs2, ncpfs, nfs, nfsd, and cifs.  The
  changes for these filesystems were a little more involved so I split
  the changes into smaller hopefully obviously correct changes.

  XFS is the only filesystem that remains.  I was hoping I could get
  that in this release so that user namespace support would be enabled
  with an allyesconfig or an allmodconfig but it looks like the xfs
  changes need another couple of days before it they are ready."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ebiederm/user-namespace: (93 commits)
  cifs: Enable building with user namespaces enabled.
  cifs: Convert struct cifs_ses to use a kuid_t and a kgid_t
  cifs: Convert struct cifs_sb_info to use kuids and kgids
  cifs: Modify struct smb_vol to use kuids and kgids
  cifs: Convert struct cifsFileInfo to use a kuid
  cifs: Convert struct cifs_fattr to use kuid and kgids
  cifs: Convert struct tcon_link to use a kuid.
  cifs: Modify struct cifs_unix_set_info_args to hold a kuid_t and a kgid_t
  cifs: Convert from a kuid before printing current_fsuid
  cifs: Use kuids and kgids SID to uid/gid mapping
  cifs: Pass GLOBAL_ROOT_UID and GLOBAL_ROOT_GID to keyring_alloc
  cifs: Use BUILD_BUG_ON to validate uids and gids are the same size
  cifs: Override unmappable incoming uids and gids
  nfsd: Enable building with user namespaces enabled.
  nfsd: Properly compare and initialize kuids and kgids
  nfsd: Store ex_anon_uid and ex_anon_gid as kuids and kgids
  nfsd: Modify nfsd4_cb_sec to use kuids and kgids
  nfsd: Handle kuids and kgids in the nfs4acl to posix_acl conversion
  nfsd: Convert nfsxdr to use kuids and kgids
  nfsd: Convert nfs3xdr to use kuids and kgids
  ...

3 files changed, 52 insertions, 19 deletions

diff --git a/kernel/sys.c b/kernel/sys.c
index 840cfdad7bfc..2e18d33ca775 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -434,11 +434,12 @@ static DEFINE_MUTEX(reboot_mutex);
 SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
                 void __user *, arg)
 {
+        struct pid_namespace *pid_ns = task_active_pid_ns(current);
         char buffer[256];
         int ret = 0;
 
         /* We only trust the superuser with rebooting the system. */
-        if (!capable(CAP_SYS_BOOT))
+        if (!ns_capable(pid_ns->user_ns, CAP_SYS_BOOT))
                 return -EPERM;
 
         /* For safety, we require "magic" arguments. */
@@ -454,7 +455,7 @@ SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
          * pid_namespace, the command is handled by reboot_pid_ns() which will
          * call do_exit().
          */
-        ret = reboot_pid_ns(task_active_pid_ns(current), cmd);
+        ret = reboot_pid_ns(pid_ns, cmd);
         if (ret)
                 return ret;
 
diff --git a/kernel/user.c b/kernel/user.c
index 33acb5e53a5f..57ebfd42023c 100644
--- a/kernel/user.c
+++ b/kernel/user.c
@@ -47,9 +47,7 @@ struct user_namespace init_user_ns = {
                         .count = 4294967295U,
                 },
         },
-        .kref = {
-                .refcount       = ATOMIC_INIT(3),
-        },
+        .count = ATOMIC_INIT(3),
         .owner = GLOBAL_ROOT_UID,
         .group = GLOBAL_ROOT_GID,
         .proc_inum = PROC_USER_INIT_INO,
diff --git a/kernel/user_namespace.c b/kernel/user_namespace.c
index 2b042c42fbc4..8b650837083e 100644
--- a/kernel/user_namespace.c
+++ b/kernel/user_namespace.c
@@ -78,7 +78,7 @@ int create_user_ns(struct cred *new)
                 return ret;
         }
 
-        kref_init(&ns->kref);
+        atomic_set(&ns->count, 1);
         /* Leave the new->user_ns reference with the new user namespace. */
         ns->parent = parent_ns;
         ns->owner = owner;
@@ -104,15 +104,16 @@ int unshare_userns(unsigned long unshare_flags, struct cred **new_cred)
         return create_user_ns(cred);
 }
 
-void free_user_ns(struct kref *kref)
+void free_user_ns(struct user_namespace *ns)
 {
-        struct user_namespace *parent, *ns =
-                container_of(kref, struct user_namespace, kref);
+        struct user_namespace *parent;
 
-        parent = ns->parent;
-        proc_free_inum(ns->proc_inum);
-        kmem_cache_free(user_ns_cachep, ns);
-        put_user_ns(parent);
+        do {
+                parent = ns->parent;
+                proc_free_inum(ns->proc_inum);
+                kmem_cache_free(user_ns_cachep, ns);
+                ns = parent;
+        } while (atomic_dec_and_test(&parent->count));
 }
 EXPORT_SYMBOL(free_user_ns);
 
@@ -519,6 +520,42 @@ struct seq_operations proc_projid_seq_operations = {
         .show = projid_m_show,
 };
 
+static bool mappings_overlap(struct uid_gid_map *new_map, struct uid_gid_extent *extent)
+{
+        u32 upper_first, lower_first, upper_last, lower_last;
+        unsigned idx;
+
+        upper_first = extent->first;
+        lower_first = extent->lower_first;
+        upper_last = upper_first + extent->count - 1;
+        lower_last = lower_first + extent->count - 1;
+
+        for (idx = 0; idx < new_map->nr_extents; idx++) {
+                u32 prev_upper_first, prev_lower_first;
+                u32 prev_upper_last, prev_lower_last;
+                struct uid_gid_extent *prev;
+
+                prev = &new_map->extent[idx];
+
+                prev_upper_first = prev->first;
+                prev_lower_first = prev->lower_first;
+                prev_upper_last = prev_upper_first + prev->count - 1;
+                prev_lower_last = prev_lower_first + prev->count - 1;
+
+                /* Does the upper range intersect a previous extent? */
+                if ((prev_upper_first <= upper_last) &&
+                    (prev_upper_last >= upper_first))
+                        return true;
+
+                /* Does the lower range intersect a previous extent? */
+                if ((prev_lower_first <= lower_last) &&
+                    (prev_lower_last >= lower_first))
+                        return true;
+        }
+        return false;
+}
+
+
 static DEFINE_MUTEX(id_map_mutex);
 
 static ssize_t map_write(struct file *file, const char __user *buf,
@@ -531,7 +568,7 @@ static ssize_t map_write(struct file *file, const char __user *buf,
         struct user_namespace *ns = seq->private;
         struct uid_gid_map new_map;
         unsigned idx;
-        struct uid_gid_extent *extent, *last = NULL;
+        struct uid_gid_extent *extent = NULL;
         unsigned long page = 0;
         char *kbuf, *pos, *next_line;
         ssize_t ret = -EINVAL;
@@ -634,14 +671,11 @@ static ssize_t map_write(struct file *file, const char __user *buf,
                 if ((extent->lower_first + extent->count) <= extent->lower_first)
                         goto out;
 
-                /* For now only accept extents that are strictly in order */
-                if (last &&
-                    (((last->first + last->count) > extent->first) ||
-                     ((last->lower_first + last->count) > extent->lower_first)))
+                /* Do the ranges in extent overlap any previous extents? */
+                if (mappings_overlap(&new_map, extent))
                         goto out;
 
                 new_map.nr_extents++;
-                last = extent;
 
                 /* Fail if the file contains too many extents */
                 if ((new_map.nr_extents == UID_GID_MAP_MAX_EXTENTS) &&