85 files changed, 1787 insertions, 605 deletions
diff --git a/arch/arm/kernel/sys_oabi-compat.c b/arch/arm/kernel/sys_oabi-compat.c
index af0aaebf4de6..3e94811690ce 100644
--- a/arch/arm/kernel/sys_oabi-compat.c
+++ b/arch/arm/kernel/sys_oabi-compat.c
@@ -124,8 +124,8 @@ static long cp_oldabi_stat64(struct kstat *stat,
        tmp.__st_ino = stat->ino;
        tmp.st_mode = stat->mode;
        tmp.st_nlink = stat->nlink;
-        tmp.st_uid = stat->uid;
+        tmp.st_uid = from_kuid_munged(current_user_ns(), stat->uid);
-        tmp.st_gid = stat->gid;
+        tmp.st_gid = from_kgid_munged(current_user_ns(), stat->gid);
        tmp.st_rdev = huge_encode_dev(stat->rdev);
        tmp.st_size = stat->size;
        tmp.st_blocks = stat->blocks;
diff --git a/arch/parisc/hpux/fs.c b/arch/parisc/hpux/fs.c
index 0dc8543acb4f..c71eb6c79897 100644
--- a/arch/parisc/hpux/fs.c
+++ b/arch/parisc/hpux/fs.c
@@ -159,8 +159,8 @@ static int cp_hpux_stat(struct kstat *stat, struct hpux_stat64 __user *statbuf)
        tmp.st_ino = stat->ino;
        tmp.st_mode = stat->mode;
        tmp.st_nlink = stat->nlink;
-        tmp.st_uid = stat->uid;
+        tmp.st_uid = from_kuid_munged(current_user_ns(), stat->uid);
-        tmp.st_gid = stat->gid;
+        tmp.st_gid = from_kgid_munged(current_user_ns(), stat->gid);
        tmp.st_rdev = new_encode_dev(stat->rdev);
        tmp.st_size = stat->size;
        tmp.st_atime = stat->atime.tv_sec;
diff --git a/arch/s390/kernel/compat_linux.c b/arch/s390/kernel/compat_linux.c
index ab64bdbab2ae..65426525d9f2 100644
--- a/arch/s390/kernel/compat_linux.c
+++ b/arch/s390/kernel/compat_linux.c
@@ -173,11 +173,14 @@ asmlinkage long sys32_setfsgid16(u16 gid)
 static int groups16_to_user(u16 __user *grouplist, struct group_info *group_info)
 {
+        struct user_namespace *user_ns = current_user_ns();
        int i;
        u16 group;
+        kgid_t kgid;
        for (i = 0; i < group_info->ngroups; i++) {
-                group = (u16)GROUP_AT(group_info, i);
+                kgid = GROUP_AT(group_info, i);
+                group = (u16)from_kgid_munged(user_ns, kgid);
                if (put_user(group, grouplist+i))
                        return -EFAULT;
        }
@@ -187,13 +190,20 @@ static int groups16_to_user(u16 __user *grouplist, struct group_info *group_info
 static int groups16_from_user(struct group_info *group_info, u16 __user *grouplist)
 {
+        struct user_namespace *user_ns = current_user_ns();
        int i;
        u16 group;
+        kgid_t kgid;
        for (i = 0; i < group_info->ngroups; i++) {
                if (get_user(group, grouplist+i))
                        return  -EFAULT;
-                GROUP_AT(group_info, i) = (gid_t)group;
+                kgid = make_kgid(user_ns, (gid_t)group);
+                if (!gid_valid(kgid))
+                        return -EINVAL;
+                GROUP_AT(group_info, i) = kgid;
        }
        return 0;
@@ -537,8 +547,8 @@ static int cp_stat64(struct stat64_emu31 __user *ubuf, struct kstat *stat)
        tmp.__st_ino = (u32)stat->ino;
        tmp.st_mode = stat->mode;
        tmp.st_nlink = (unsigned int)stat->nlink;
-        tmp.st_uid = stat->uid;
+        tmp.st_uid = from_kuid_munged(current_user_ns(), stat->uid);
-        tmp.st_gid = stat->gid;
+        tmp.st_gid = from_kgid_munged(current_user_ns(), stat->gid);
        tmp.st_rdev = huge_encode_dev(stat->rdev);
        tmp.st_size = stat->size;
        tmp.st_blksize = (u32)stat->blksize;
diff --git a/arch/sparc/kernel/sys_sparc32.c b/arch/sparc/kernel/sys_sparc32.c
index 29c478ffed91..f7392336961f 100644
--- a/arch/sparc/kernel/sys_sparc32.c
+++ b/arch/sparc/kernel/sys_sparc32.c
@@ -139,8 +139,8 @@ static int cp_compat_stat64(struct kstat *stat,
        err |= put_user(stat->ino, &statbuf->st_ino);
        err |= put_user(stat->mode, &statbuf->st_mode);
        err |= put_user(stat->nlink, &statbuf->st_nlink);
-        err |= put_user(stat->uid, &statbuf->st_uid);
+        err |= put_user(from_kuid_munged(current_user_ns(), stat->uid), &statbuf->st_uid);
-        err |= put_user(stat->gid, &statbuf->st_gid);
+        err |= put_user(from_kgid_munged(current_user_ns(), stat->gid), &statbuf->st_gid);
        err |= put_user(huge_encode_dev(stat->rdev), &statbuf->st_rdev);
        err |= put_user(0, (unsigned long __user *) &statbuf->__pad3[0]);
        err |= put_user(stat->size, &statbuf->st_size);
diff --git a/arch/x86/ia32/sys_ia32.c b/arch/x86/ia32/sys_ia32.c
index edca9c0a79cc..4540bece0946 100644
--- a/arch/x86/ia32/sys_ia32.c
+++ b/arch/x86/ia32/sys_ia32.c
@@ -71,8 +71,8 @@ static int cp_stat64(struct stat64 __user *ubuf, struct kstat *stat)
 {
        typeof(ubuf->st_uid) uid = 0;
        typeof(ubuf->st_gid) gid = 0;
-        SET_UID(uid, stat->uid);
+        SET_UID(uid, from_kuid_munged(current_user_ns(), stat->uid));
-        SET_GID(gid, stat->gid);
+        SET_GID(gid, from_kgid_munged(current_user_ns(), stat->gid));
        if (!access_ok(VERIFY_WRITE, ubuf, sizeof(struct stat64)) ||
            __put_user(huge_encode_dev(stat->dev), &ubuf->st_dev) ||
            __put_user(stat->ino, &ubuf->__st_ino) ||
diff --git a/arch/x86/mm/fault.c b/arch/x86/mm/fault.c
index 3ecfd1aaf214..76dcd9d8e0bc 100644
--- a/arch/x86/mm/fault.c
+++ b/arch/x86/mm/fault.c
@@ -582,7 +582,7 @@ show_fault_oops(struct pt_regs *regs, unsigned long error_code,
                pte_t *pte = lookup_address(address, &level);
                if (pte && pte_present(*pte) && !pte_exec(*pte))
-                        printk(nx_warning, current_uid());
+                        printk(nx_warning, from_kuid(&init_user_ns, current_uid()));
        }
        printk(KERN_ALERT "BUG: unable to handle kernel ");
diff --git a/fs/attr.c b/fs/attr.c
index 73f69a6ce9ed..584620e5dee5 100644
--- a/fs/attr.c
+++ b/fs/attr.c
@@ -47,14 +47,14 @@ int inode_change_ok(const struct inode *inode, struct iattr *attr)
        /* Make sure a caller can chown. */
        if ((ia_valid & ATTR_UID) &&
-            (current_fsuid() != inode->i_uid ||
+            (!uid_eq(current_fsuid(), inode->i_uid) ||
-             attr->ia_uid != inode->i_uid) && !capable(CAP_CHOWN))
+             !uid_eq(attr->ia_uid, inode->i_uid)) && !capable(CAP_CHOWN))
                return -EPERM;
        /* Make sure caller can chgrp. */
        if ((ia_valid & ATTR_GID) &&
-            (current_fsuid() != inode->i_uid ||
+            (!uid_eq(current_fsuid(), inode->i_uid) ||
-            (!in_group_p(attr->ia_gid) && attr->ia_gid != inode->i_gid)) &&
+            (!in_group_p(attr->ia_gid) && !gid_eq(attr->ia_gid, inode->i_gid))) &&
            !capable(CAP_CHOWN))
                return -EPERM;
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 16f735417072..e658dd134b95 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -226,10 +226,10 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
        NEW_AUX_ENT(AT_BASE, interp_load_addr);
        NEW_AUX_ENT(AT_FLAGS, 0);
        NEW_AUX_ENT(AT_ENTRY, exec->e_entry);
-        NEW_AUX_ENT(AT_UID, cred->uid);
+        NEW_AUX_ENT(AT_UID, from_kuid_munged(cred->user_ns, cred->uid));
-        NEW_AUX_ENT(AT_EUID, cred->euid);
+        NEW_AUX_ENT(AT_EUID, from_kuid_munged(cred->user_ns, cred->euid));
-        NEW_AUX_ENT(AT_GID, cred->gid);
+        NEW_AUX_ENT(AT_GID, from_kgid_munged(cred->user_ns, cred->gid));
-        NEW_AUX_ENT(AT_EGID, cred->egid);
+        NEW_AUX_ENT(AT_EGID, from_kgid_munged(cred->user_ns, cred->egid));
        NEW_AUX_ENT(AT_SECURE, security_bprm_secureexec(bprm));
        NEW_AUX_ENT(AT_RANDOM, (elf_addr_t)(unsigned long)u_rand_bytes);
        NEW_AUX_ENT(AT_EXECFN, bprm->exec);
@@ -1356,8 +1356,8 @@ static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
        psinfo->pr_flag = p->flags;
        rcu_read_lock();
        cred = __task_cred(p);
-        SET_UID(psinfo->pr_uid, cred->uid);
+        SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));
-        SET_GID(psinfo->pr_gid, cred->gid);
+        SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));
        rcu_read_unlock();
        strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
        
diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
index d390a0fffc65..3d77cf81ba3c 100644
--- a/fs/binfmt_elf_fdpic.c
+++ b/fs/binfmt_elf_fdpic.c
@@ -627,10 +627,10 @@ static int create_elf_fdpic_tables(struct linux_binprm *bprm,
        NEW_AUX_ENT(AT_BASE,    interp_params->elfhdr_addr);
        NEW_AUX_ENT(AT_FLAGS,   0);
        NEW_AUX_ENT(AT_ENTRY,   exec_params->entry_addr);
-        NEW_AUX_ENT(AT_UID,     (elf_addr_t) cred->uid);
+        NEW_AUX_ENT(AT_UID,     (elf_addr_t) from_kuid_munged(cred->user_ns, cred->uid));
-        NEW_AUX_ENT(AT_EUID,    (elf_addr_t) cred->euid);
+        NEW_AUX_ENT(AT_EUID,    (elf_addr_t) from_kuid_munged(cred->user_ns, cred->euid));
-        NEW_AUX_ENT(AT_GID,     (elf_addr_t) cred->gid);
+        NEW_AUX_ENT(AT_GID,     (elf_addr_t) from_kgid_munged(cred->user_ns, cred->gid));
-        NEW_AUX_ENT(AT_EGID,    (elf_addr_t) cred->egid);
+        NEW_AUX_ENT(AT_EGID,    (elf_addr_t) from_kgid_munged(cred->user_ns, cred->egid));
        NEW_AUX_ENT(AT_SECURE,  security_bprm_secureexec(bprm));
        NEW_AUX_ENT(AT_EXECFN,  bprm->exec);
@@ -1421,8 +1421,8 @@ static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
        psinfo->pr_flag = p->flags;
        rcu_read_lock();
        cred = __task_cred(p);
-        SET_UID(psinfo->pr_uid, cred->uid);
+        SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));
-        SET_GID(psinfo->pr_gid, cred->gid);
+        SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));
        rcu_read_unlock();
        strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
diff --git a/fs/compat.c b/fs/compat.c
index f2944ace7a7b..0781e619a62a 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -144,8 +144,8 @@ static int cp_compat_stat(struct kstat *stat, struct compat_stat __user *ubuf)
        tmp.st_nlink = stat->nlink;
        if (tmp.st_nlink != stat->nlink)
                return -EOVERFLOW;
-        SET_UID(tmp.st_uid, stat->uid);
+        SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
-        SET_GID(tmp.st_gid, stat->gid);
+        SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
        tmp.st_rdev = old_encode_dev(stat->rdev);
        if ((u64) stat->size > MAX_NON_LFS)
                return -EOVERFLOW;
diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
index 10f5e0b484db..979c1e309c73 100644
--- a/fs/devpts/inode.c
+++ b/fs/devpts/inode.c
@@ -98,8 +98,8 @@ static struct vfsmount *devpts_mnt;
 struct pts_mount_opts {
        int setuid;
        int setgid;
-        uid_t   uid;
+        kuid_t   uid;
-        gid_t   gid;
+        kgid_t   gid;
        umode_t mode;
        umode_t ptmxmode;
        int newinstance;
@@ -158,11 +158,13 @@ static inline struct super_block *pts_sb_from_inode(struct inode *inode)
 static int parse_mount_options(char *data, int op, struct pts_mount_opts *opts)
 {
        char *p;
+        kuid_t uid;
+        kgid_t gid;
        opts->setuid  = 0;
        opts->setgid  = 0;
-        opts->uid     = 0;
+        opts->uid     = GLOBAL_ROOT_UID;
-        opts->gid     = 0;
+        opts->gid     = GLOBAL_ROOT_GID;
        opts->mode    = DEVPTS_DEFAULT_MODE;
        opts->ptmxmode = DEVPTS_DEFAULT_PTMX_MODE;
        opts->max     = NR_UNIX98_PTY_MAX;
@@ -184,13 +186,19 @@ static int parse_mount_options(char *data, int op, struct pts_mount_opts *opts)
                case Opt_uid:
                        if (match_int(&args[0], &option))
                                return -EINVAL;
-                        opts->uid = option;
+                        uid = make_kuid(current_user_ns(), option);
+                        if (!uid_valid(uid))
+                                return -EINVAL;
+                        opts->uid = uid;
                        opts->setuid = 1;
                        break;
                case Opt_gid:
                        if (match_int(&args[0], &option))
                                return -EINVAL;
-                        opts->gid = option;
+                        gid = make_kgid(current_user_ns(), option);
+                        if (!gid_valid(gid))
+                                return -EINVAL;
+                        opts->gid = gid;
                        opts->setgid = 1;
                        break;
                case Opt_mode:
@@ -315,9 +323,9 @@ static int devpts_show_options(struct seq_file *seq, struct dentry *root)
        struct pts_mount_opts *opts = &fsi->mount_opts;
        if (opts->setuid)
-                seq_printf(seq, ",uid=%u", opts->uid);
+                seq_printf(seq, ",uid=%u", from_kuid_munged(&init_user_ns, opts->uid));
        if (opts->setgid)
-                seq_printf(seq, ",gid=%u", opts->gid);
+                seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, opts->gid));
        seq_printf(seq, ",mode=%03o", opts->mode);
 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
        seq_printf(seq, ",ptmxmode=%03o", opts->ptmxmode);
diff --git a/fs/ecryptfs/messaging.c b/fs/ecryptfs/messaging.c
index ab2248090515..a750f957b145 100644
--- a/fs/ecryptfs/messaging.c
+++ b/fs/ecryptfs/messaging.c
@@ -303,7 +303,7 @@ int ecryptfs_process_response(struct ecryptfs_message *msg, uid_t euid,
                mutex_unlock(&ecryptfs_daemon_hash_mux);
                goto wake_up;
        }
-        tsk_user_ns = __task_cred(msg_ctx->task)->user->user_ns;
+        tsk_user_ns = __task_cred(msg_ctx->task)->user_ns;
        ctx_euid = task_euid(msg_ctx->task);
        rc = ecryptfs_find_daemon_by_euid(&daemon, ctx_euid, tsk_user_ns);
        rcu_read_unlock();
diff --git a/fs/exec.c b/fs/exec.c
index 1e8efdc80412..52c9e2ff6e6b 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -1139,7 +1139,7 @@ void setup_new_exec(struct linux_binprm * bprm)
        /* This is the point of no return */
        current->sas_ss_sp = current->sas_ss_size = 0;
-        if (current_euid() == current_uid() && current_egid() == current_gid())
+        if (uid_eq(current_euid(), current_uid()) && gid_eq(current_egid(), current_gid()))
                set_dumpable(current->mm, 1);
        else
                set_dumpable(current->mm, suid_dumpable);
@@ -1153,8 +1153,8 @@ void setup_new_exec(struct linux_binprm * bprm)
        current->mm->task_size = TASK_SIZE;
        /* install the new credentials */
-        if (bprm->cred->uid != current_euid() ||
+        if (!uid_eq(bprm->cred->uid, current_euid()) ||
-            bprm->cred->gid != current_egid()) {
+            !gid_eq(bprm->cred->gid, current_egid())) {
                current->pdeath_signal = 0;
        } else {
                would_dump(bprm, bprm->file);
@@ -1299,8 +1299,11 @@ int prepare_binprm(struct linux_binprm *bprm)
            !current->no_new_privs) {
                /* Set-uid? */
                if (mode & S_ISUID) {
+                        if (!kuid_has_mapping(bprm->cred->user_ns, inode->i_uid))
+                                return -EPERM;
                        bprm->per_clear |= PER_CLEAR_ON_SETID;
                        bprm->cred->euid = inode->i_uid;
                }
                /* Set-gid? */
@@ -1310,6 +1313,8 @@ int prepare_binprm(struct linux_binprm *bprm)
                 * executable.
                 */
                if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
+                        if (!kgid_has_mapping(bprm->cred->user_ns, inode->i_gid))
+                                return -EPERM;
                        bprm->per_clear |= PER_CLEAR_ON_SETID;
                        bprm->cred->egid = inode->i_gid;
                }
@@ -2142,7 +2147,7 @@ void do_coredump(long signr, int exit_code, struct pt_regs *regs)
        if (__get_dumpable(cprm.mm_flags) == 2) {
                /* Setuid core dump mode */
                flag = O_EXCL;          /* Stop rewrite attacks */
-                cred->fsuid = 0;        /* Dump root private */
+                cred->fsuid = GLOBAL_ROOT_UID;  /* Dump root private */
        }
        retval = coredump_wait(exit_code, &core_state);
@@ -2243,7 +2248,7 @@ void do_coredump(long signr, int exit_code, struct pt_regs *regs)
                 * Dont allow local users get cute and trick others to coredump
                 * into their pre-created files.
                 */
-                if (inode->i_uid != current_fsuid())
+                if (!uid_eq(inode->i_uid, current_fsuid()))
                        goto close_fail;
                if (!cprm.file->f_op || !cprm.file->f_op->write)
                        goto close_fail;
diff --git a/fs/ext2/balloc.c b/fs/ext2/balloc.c
index a8cbe1bc6ad4..030c6d277e14 100644
--- a/fs/ext2/balloc.c
+++ b/fs/ext2/balloc.c
@@ -1193,8 +1193,9 @@ static int ext2_has_free_blocks(struct ext2_sb_info *sbi)
        free_blocks = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
        root_blocks = le32_to_cpu(sbi->s_es->s_r_blocks_count);
        if (free_blocks < root_blocks + 1 && !capable(CAP_SYS_RESOURCE) &&
-                sbi->s_resuid != current_fsuid() &&
+                !uid_eq(sbi->s_resuid, current_fsuid()) &&
-                (sbi->s_resgid == 0 || !in_group_p (sbi->s_resgid))) {
+                (gid_eq(sbi->s_resgid, GLOBAL_ROOT_GID) ||
+                 !in_group_p (sbi->s_resgid))) {
                return 0;
        }
        return 1;
diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index 0b2b4db5bdcd..d9a17d0b124d 100644
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -82,8 +82,8 @@ struct ext2_sb_info {
        struct buffer_head ** s_group_desc;
        unsigned long  s_mount_opt;
        unsigned long s_sb_block;
-        uid_t s_resuid;
+        kuid_t s_resuid;
-        gid_t s_resgid;
+        kgid_t s_resgid;
        unsigned short s_mount_state;
        unsigned short s_pad;
        int s_addr_per_block_bits;
@@ -637,8 +637,8 @@ static inline void verify_offsets(void)
 */
 struct ext2_mount_options {
        unsigned long s_mount_opt;
-        uid_t s_resuid;
+        kuid_t s_resuid;
-        gid_t s_resgid;
+        kgid_t s_resgid;
 };
 /*
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 740cad8dcd8d..f9fa95f8443d 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -1293,6 +1293,8 @@ struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
        struct inode *inode;
        long ret = -EIO;
        int n;
+        uid_t i_uid;
+        gid_t i_gid;
        inode = iget_locked(sb, ino);
        if (!inode)
@@ -1310,12 +1312,14 @@ struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
        }
        inode->i_mode = le16_to_cpu(raw_inode->i_mode);
-        inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
+        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_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;
+                i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
-                inode->i_gid |= le16_to_cpu(raw_inode->i_gid_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));
        inode->i_size = le32_to_cpu(raw_inode->i_size);
        inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
@@ -1413,8 +1417,8 @@ static int __ext2_write_inode(struct inode *inode, int do_sync)
        struct ext2_inode_info *ei = EXT2_I(inode);
        struct super_block *sb = inode->i_sb;
        ino_t ino = inode->i_ino;
-        uid_t uid = inode->i_uid;
+        uid_t uid = i_uid_read(inode);
-        gid_t gid = inode->i_gid;
+        gid_t gid = i_gid_read(inode);
        struct buffer_head * bh;
        struct ext2_inode * raw_inode = ext2_get_inode(sb, ino, &bh);
        int n;
@@ -1529,8 +1533,8 @@ int ext2_setattr(struct dentry *dentry, struct iattr *iattr)
        if (is_quota_modification(inode, iattr))
                dquot_initialize(inode);
-        if ((iattr->ia_valid & ATTR_UID && iattr->ia_uid != inode->i_uid) ||
+        if ((iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid)) ||
-            (iattr->ia_valid & ATTR_GID && iattr->ia_gid != inode->i_gid)) {
+            (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid))) {
                error = dquot_transfer(inode, iattr);
                if (error)
                        return error;
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index e1025c7a437a..38f816071ddb 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -228,13 +228,15 @@ static int ext2_show_options(struct seq_file *seq, struct dentry *root)
                seq_puts(seq, ",grpid");
        if (!test_opt(sb, GRPID) && (def_mount_opts & EXT2_DEFM_BSDGROUPS))
                seq_puts(seq, ",nogrpid");
-        if (sbi->s_resuid != EXT2_DEF_RESUID ||
+        if (!uid_eq(sbi->s_resuid, make_kuid(&init_user_ns, EXT2_DEF_RESUID)) ||
            le16_to_cpu(es->s_def_resuid) != EXT2_DEF_RESUID) {
-                seq_printf(seq, ",resuid=%u", sbi->s_resuid);
+                seq_printf(seq, ",resuid=%u",
+                                from_kuid_munged(&init_user_ns, sbi->s_resuid));
        }
-        if (sbi->s_resgid != EXT2_DEF_RESGID ||
+        if (!gid_eq(sbi->s_resgid, make_kgid(&init_user_ns, EXT2_DEF_RESGID)) ||
            le16_to_cpu(es->s_def_resgid) != EXT2_DEF_RESGID) {
-                seq_printf(seq, ",resgid=%u", sbi->s_resgid);
+                seq_printf(seq, ",resgid=%u",
+                                from_kgid_munged(&init_user_ns, sbi->s_resgid));
        }
        if (test_opt(sb, ERRORS_RO)) {
                int def_errors = le16_to_cpu(es->s_errors);
@@ -436,6 +438,8 @@ static int parse_options(char *options, struct super_block *sb)
        struct ext2_sb_info *sbi = EXT2_SB(sb);
        substring_t args[MAX_OPT_ARGS];
        int option;
+        kuid_t uid;
+        kgid_t gid;
        if (!options)
                return 1;
@@ -462,12 +466,23 @@ static int parse_options(char *options, struct super_block *sb)
                case Opt_resuid:
                        if (match_int(&args[0], &option))
                                return 0;
-                        sbi->s_resuid = option;
+                        uid = make_kuid(current_user_ns(), option);
+                        if (!uid_valid(uid)) {
+                                ext2_msg(sb, KERN_ERR, "Invalid uid value %d", option);
+                                return -1;
+                        }
+                        sbi->s_resuid = uid;
                        break;
                case Opt_resgid:
                        if (match_int(&args[0], &option))
                                return 0;
-                        sbi->s_resgid = option;
+                        gid = make_kgid(current_user_ns(), option);
+                        if (!gid_valid(gid)) {
+                                ext2_msg(sb, KERN_ERR, "Invalid gid value %d", option);
+                                return -1;
+                        }
+                        sbi->s_resgid = gid;
                        break;
                case Opt_sb:
                        /* handled by get_sb_block() instead of here */
@@ -841,8 +856,8 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
        else
                set_opt(sbi->s_mount_opt, ERRORS_RO);
-        sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
+        sbi->s_resuid = make_kuid(&init_user_ns, le16_to_cpu(es->s_def_resuid));
-        sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
+        sbi->s_resgid = make_kgid(&init_user_ns, le16_to_cpu(es->s_def_resgid));
        
        set_opt(sbi->s_mount_opt, RESERVATION);
diff --git a/fs/ext3/balloc.c b/fs/ext3/balloc.c
index baac1b129fba..25cd60892116 100644
--- a/fs/ext3/balloc.c
+++ b/fs/ext3/balloc.c
@@ -1439,8 +1439,9 @@ static int ext3_has_free_blocks(struct ext3_sb_info *sbi, int use_reservation)
        free_blocks = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
        root_blocks = le32_to_cpu(sbi->s_es->s_r_blocks_count);
        if (free_blocks < root_blocks + 1 && !capable(CAP_SYS_RESOURCE) &&
-                !use_reservation && sbi->s_resuid != current_fsuid() &&
+                !use_reservation && !uid_eq(sbi->s_resuid, current_fsuid()) &&
-                (sbi->s_resgid == 0 || !in_group_p (sbi->s_resgid))) {
+                (gid_eq(sbi->s_resgid, GLOBAL_ROOT_GID) ||
+                 !in_group_p (sbi->s_resgid))) {
                return 0;
        }
        return 1;
diff --git a/fs/ext3/ext3.h b/fs/ext3/ext3.h
index b6515fd7e56c..7977973a24f0 100644
--- a/fs/ext3/ext3.h
+++ b/fs/ext3/ext3.h
@@ -243,8 +243,8 @@ struct ext3_new_group_data {
 */
 struct ext3_mount_options {
        unsigned long s_mount_opt;
-        uid_t s_resuid;
+        kuid_t s_resuid;
-        gid_t s_resgid;
+        kgid_t s_resgid;
        unsigned long s_commit_interval;
 #ifdef CONFIG_QUOTA
        int s_jquota_fmt;
@@ -637,8 +637,8 @@ struct ext3_sb_info {
        struct buffer_head ** s_group_desc;
        unsigned long  s_mount_opt;
        ext3_fsblk_t s_sb_block;
-        uid_t s_resuid;
+        kuid_t s_resuid;
-        gid_t s_resgid;
+        kgid_t s_resgid;
        unsigned short s_mount_state;
        unsigned short s_pad;
        int s_addr_per_block_bits;
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index 10d7812f6021..a09790a412b1 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -2891,6 +2891,8 @@ struct inode *ext3_iget(struct super_block *sb, unsigned long ino)
        transaction_t *transaction;
        long ret;
        int block;
+        uid_t i_uid;
+        gid_t i_gid;
        inode = iget_locked(sb, ino);
        if (!inode)
@@ -2907,12 +2909,14 @@ struct inode *ext3_iget(struct super_block *sb, unsigned long ino)
        bh = iloc.bh;
        raw_inode = ext3_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);
+        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_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;
+                i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
-                inode->i_gid |= le16_to_cpu(raw_inode->i_gid_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));
        inode->i_size = le32_to_cpu(raw_inode->i_size);
        inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
@@ -3068,6 +3072,8 @@ static int ext3_do_update_inode(handle_t *handle,
        struct ext3_inode_info *ei = EXT3_I(inode);
        struct buffer_head *bh = iloc->bh;
        int err = 0, rc, block;
+        uid_t i_uid;
+        gid_t i_gid;
 again:
        /* we can't allow multiple procs in here at once, its a bit racey */
@@ -3080,27 +3086,29 @@ again:
        ext3_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_uid_low = cpu_to_le16(low_16_bits(i_uid));
-                raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid));
+                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));
+                        cpu_to_le16(fs_high2lowuid(i_uid));
                raw_inode->i_gid_low =
-                        cpu_to_le16(fs_high2lowgid(inode->i_gid));
+                        cpu_to_le16(fs_high2lowgid(i_gid));
                raw_inode->i_uid_high = 0;
                raw_inode->i_gid_high = 0;
        }
@@ -3262,8 +3270,8 @@ int ext3_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) ||
+        if ((ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, inode->i_uid)) ||
-                (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
+            (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/ext3/super.c b/fs/ext3/super.c
index cf0b5921cf0f..94ef7e616129 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -617,13 +617,15 @@ static int ext3_show_options(struct seq_file *seq, struct dentry *root)
                seq_puts(seq, ",grpid");
        if (!test_opt(sb, GRPID) && (def_mount_opts & EXT3_DEFM_BSDGROUPS))
                seq_puts(seq, ",nogrpid");
-        if (sbi->s_resuid != EXT3_DEF_RESUID ||
+        if (!uid_eq(sbi->s_resuid, make_kuid(&init_user_ns, EXT3_DEF_RESUID)) ||
            le16_to_cpu(es->s_def_resuid) != EXT3_DEF_RESUID) {
-                seq_printf(seq, ",resuid=%u", sbi->s_resuid);
+                seq_printf(seq, ",resuid=%u",
+                                from_kuid_munged(&init_user_ns, sbi->s_resuid));
        }
-        if (sbi->s_resgid != EXT3_DEF_RESGID ||
+        if (!gid_eq(sbi->s_resgid, make_kgid(&init_user_ns, EXT3_DEF_RESGID)) ||
            le16_to_cpu(es->s_def_resgid) != EXT3_DEF_RESGID) {
-                seq_printf(seq, ",resgid=%u", sbi->s_resgid);
+                seq_printf(seq, ",resgid=%u",
+                                from_kgid_munged(&init_user_ns, sbi->s_resgid));
        }
        if (test_opt(sb, ERRORS_RO)) {
                int def_errors = le16_to_cpu(es->s_errors);
@@ -967,6 +969,8 @@ static int parse_options (char *options, struct super_block *sb,
        substring_t args[MAX_OPT_ARGS];
        int data_opt = 0;
        int option;
+        kuid_t uid;
+        kgid_t gid;
 #ifdef CONFIG_QUOTA
        int qfmt;
 #endif
@@ -1000,12 +1004,23 @@ static int parse_options (char *options, struct super_block *sb,
                case Opt_resuid:
                        if (match_int(&args[0], &option))
                                return 0;
-                        sbi->s_resuid = option;
+                        uid = make_kuid(current_user_ns(), option);
+                        if (!uid_valid(uid)) {
+                                ext3_msg(sb, KERN_ERR, "Invalid uid value %d", option);
+                                return -1;
+                        }
+                        sbi->s_resuid = uid;
                        break;
                case Opt_resgid:
                        if (match_int(&args[0], &option))
                                return 0;
-                        sbi->s_resgid = option;
+                        gid = make_kgid(current_user_ns(), option);
+                        if (!gid_valid(gid)) {
+                                ext3_msg(sb, KERN_ERR, "Invalid gid value %d", option);
+                                return -1;
+                        }
+                        sbi->s_resgid = gid;
                        break;
                case Opt_sb:
                        /* handled by get_sb_block() instead of here */
@@ -1651,8 +1666,8 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
        }
        sb->s_fs_info = sbi;
        sbi->s_mount_opt = 0;
-        sbi->s_resuid = EXT3_DEF_RESUID;
+        sbi->s_resuid = make_kuid(&init_user_ns, EXT3_DEF_RESUID);
-        sbi->s_resgid = EXT3_DEF_RESGID;
+        sbi->s_resgid = make_kgid(&init_user_ns, EXT3_DEF_RESGID);
        sbi->s_sb_block = sb_block;
        blocksize = sb_min_blocksize(sb, EXT3_MIN_BLOCK_SIZE);
@@ -1716,8 +1731,8 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
        else
                set_opt(sbi->s_mount_opt, ERRORS_RO);
-        sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
+        sbi->s_resuid = make_kuid(&init_user_ns, le16_to_cpu(es->s_def_resuid));
-        sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
+        sbi->s_resgid = make_kgid(&init_user_ns, le16_to_cpu(es->s_def_resgid));
        /* enable barriers by default */
        set_opt(sbi->s_mount_opt, BARRIER);
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() ||
+        if (uid_eq(sbi->s_resuid, current_fsuid()) ||
-            ((sbi->s_resgid != 0) && in_group_p(sbi->s_resgid)) ||
+            (!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;
+        kuid_t s_resuid;
-        gid_t s_resgid;
+        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];
+                i_uid_write(inode, owner[0]);
-                inode->i_gid = owner[1];
+                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);
+        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_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;
+                i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
-                inode->i_gid |= le16_to_cpu(raw_inode->i_gid_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_uid_low = cpu_to_le16(low_16_bits(i_uid));
-                raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid));
+                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 =
+                raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(i_uid));
-                        cpu_to_le16(fs_high2lowuid(inode->i_uid));
+                raw_inode->i_gid_low = cpu_to_le16(fs_high2lowgid(i_gid));
-                raw_inode->i_gid_low =
-                        cpu_to_le16(fs_high2lowgid(inode->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) ||
+        if ((ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, inode->i_uid)) ||
-                (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
+            (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[0] = i_uid_read(inode);
-        owner[1] = inode->i_gid;
+        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);
+                SEQ_OPTS_PRINT("resuid=%u",
-        if (nodefs || sbi->s_resgid != EXT4_DEF_RESGID ||
+                                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_resuid = make_kuid(&init_user_ns, EXT4_DEF_RESUID);
-        sbi->s_resgid = EXT4_DEF_RESGID;
+        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_resuid = make_kuid(&init_user_ns, le16_to_cpu(es->s_def_resuid));
-        sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
+        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;
+        kuid_t s_resuid;
-        gid_t s_resgid;
+        kgid_t s_resgid;
        unsigned long s_commit_interval;
        u32 s_min_batch_time, s_max_batch_time;
 #ifdef CONFIG_QUOTA
diff --git a/fs/fcntl.c b/fs/fcntl.c
index 75e7c1f3a080..d078b75572a7 100644
--- a/fs/fcntl.c
+++ b/fs/fcntl.c
@@ -532,9 +532,9 @@ static inline int sigio_perm(struct task_struct *p,
        rcu_read_lock();
        cred = __task_cred(p);
-        ret = ((fown->euid == 0 ||
+        ret = ((uid_eq(fown->euid, GLOBAL_ROOT_UID) ||
-                fown->euid == cred->suid || fown->euid == cred->uid ||
+                uid_eq(fown->euid, cred->suid) || uid_eq(fown->euid, cred->uid) ||
-                fown->uid  == cred->suid || fown->uid  == cred->uid) &&
+                uid_eq(fown->uid,  cred->suid) || uid_eq(fown->uid,  cred->uid)) &&
               !security_file_send_sigiotask(p, fown, sig));
        rcu_read_unlock();
        return ret;
diff --git a/fs/inode.c b/fs/inode.c
index 9f4f5fecc096..deb72f6c2b4f 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -135,8 +135,8 @@ int inode_init_always(struct super_block *sb, struct inode *inode)
        inode->i_fop = &empty_fops;
        inode->__i_nlink = 1;
        inode->i_opflags = 0;
-        inode->i_uid = 0;
+        i_uid_write(inode, 0);
-        inode->i_gid = 0;
+        i_gid_write(inode, 0);
        atomic_set(&inode->i_writecount, 0);
        inode->i_size = 0;
        inode->i_blocks = 0;
@@ -1732,11 +1732,9 @@ EXPORT_SYMBOL(inode_init_owner);
 */
 bool inode_owner_or_capable(const struct inode *inode)
 {
-        struct user_namespace *ns = inode_userns(inode);
+        if (uid_eq(current_fsuid(), inode->i_uid))
-        if (current_user_ns() == ns && current_fsuid() == inode->i_uid)
                return true;
-        if (ns_capable(ns, CAP_FOWNER))
+        if (inode_capable(inode, CAP_FOWNER))
                return true;
        return false;
 }
diff --git a/fs/ioprio.c b/fs/ioprio.c
index 0f1b9515213b..5e6dbe8958fc 100644
--- a/fs/ioprio.c
+++ b/fs/ioprio.c
@@ -37,8 +37,8 @@ int set_task_ioprio(struct task_struct *task, int ioprio)
        rcu_read_lock();
        tcred = __task_cred(task);
-        if (tcred->uid != cred->euid &&
+        if (!uid_eq(tcred->uid, cred->euid) &&
-            tcred->uid != cred->uid && !capable(CAP_SYS_NICE)) {
+            !uid_eq(tcred->uid, cred->uid) && !capable(CAP_SYS_NICE)) {
                rcu_read_unlock();
                return -EPERM;
        }
@@ -65,6 +65,7 @@ SYSCALL_DEFINE3(ioprio_set, int, which, int, who, int, ioprio)
        struct task_struct *p, *g;
        struct user_struct *user;
        struct pid *pgrp;
+        kuid_t uid;
        int ret;
        switch (class) {
@@ -110,16 +111,19 @@ SYSCALL_DEFINE3(ioprio_set, int, which, int, who, int, ioprio)
                        } while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
                        break;
                case IOPRIO_WHO_USER:
+                        uid = make_kuid(current_user_ns(), who);
+                        if (!uid_valid(uid))
+                                break;
                        if (!who)
                                user = current_user();
                        else
-                                user = find_user(who);
+                                user = find_user(uid);
                        if (!user)
                                break;
                        do_each_thread(g, p) {
-                                if (__task_cred(p)->uid != who)
+                                if (!uid_eq(task_uid(p), uid))
                                        continue;
                                ret = set_task_ioprio(p, ioprio);
                                if (ret)
@@ -174,6 +178,7 @@ SYSCALL_DEFINE2(ioprio_get, int, which, int, who)
        struct task_struct *g, *p;
        struct user_struct *user;
        struct pid *pgrp;
+        kuid_t uid;
        int ret = -ESRCH;
        int tmpio;
@@ -203,16 +208,17 @@ SYSCALL_DEFINE2(ioprio_get, int, which, int, who)
                        } while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
                        break;
                case IOPRIO_WHO_USER:
+                        uid = make_kuid(current_user_ns(), who);
                        if (!who)
                                user = current_user();
                        else
-                                user = find_user(who);
+                                user = find_user(uid);
                        if (!user)
                                break;
                        do_each_thread(g, p) {
-                                if (__task_cred(p)->uid != user->uid)
+                                if (!uid_eq(task_uid(p), user->uid))
                                        continue;
                                tmpio = get_task_ioprio(p);
                                if (tmpio < 0)
diff --git a/fs/locks.c b/fs/locks.c
index 0d68f1f81799..4f441e46cef4 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -1446,7 +1446,7 @@ int generic_setlease(struct file *filp, long arg, struct file_lock **flp)
        struct inode *inode = dentry->d_inode;
        int error;
-        if ((current_fsuid() != inode->i_uid) && !capable(CAP_LEASE))
+        if ((!uid_eq(current_fsuid(), inode->i_uid)) && !capable(CAP_LEASE))
                return -EACCES;
        if (!S_ISREG(inode->i_mode))
                return -EINVAL;
diff --git a/fs/namei.c b/fs/namei.c
index f9e883c1b856..e70ebab9624b 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -218,10 +218,7 @@ static int acl_permission_check(struct inode *inode, int mask)
 {
        unsigned int mode = inode->i_mode;
-        if (current_user_ns() != inode_userns(inode))
+        if (likely(uid_eq(current_fsuid(), inode->i_uid)))
-                goto other_perms;
-        if (likely(current_fsuid() == inode->i_uid))
                mode >>= 6;
        else {
                if (IS_POSIXACL(inode) && (mode & S_IRWXG)) {
@@ -234,7 +231,6 @@ static int acl_permission_check(struct inode *inode, int mask)
                        mode >>= 3;
        }
-other_perms:
        /*
         * If the DACs are ok we don't need any capability check.
         */
@@ -270,10 +266,10 @@ int generic_permission(struct inode *inode, int mask)
        if (S_ISDIR(inode->i_mode)) {
                /* DACs are overridable for directories */
-                if (ns_capable(inode_userns(inode), CAP_DAC_OVERRIDE))
+                if (inode_capable(inode, CAP_DAC_OVERRIDE))
                        return 0;
                if (!(mask & MAY_WRITE))
-                        if (ns_capable(inode_userns(inode), CAP_DAC_READ_SEARCH))
+                        if (inode_capable(inode, CAP_DAC_READ_SEARCH))
                                return 0;
                return -EACCES;
        }
@@ -283,7 +279,7 @@ int generic_permission(struct inode *inode, int mask)
         * at least one exec bit set.
         */
        if (!(mask & MAY_EXEC) || (inode->i_mode & S_IXUGO))
-                if (ns_capable(inode_userns(inode), CAP_DAC_OVERRIDE))
+                if (inode_capable(inode, CAP_DAC_OVERRIDE))
                        return 0;
        /*
@@ -291,7 +287,7 @@ int generic_permission(struct inode *inode, int mask)
         */
        mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
        if (mask == MAY_READ)
-                if (ns_capable(inode_userns(inode), CAP_DAC_READ_SEARCH))
+                if (inode_capable(inode, CAP_DAC_READ_SEARCH))
                        return 0;
        return -EACCES;
@@ -1934,19 +1930,15 @@ static int user_path_parent(int dfd, const char __user *path,
 */
 static inline int check_sticky(struct inode *dir, struct inode *inode)
 {
-        uid_t fsuid = current_fsuid();
+        kuid_t fsuid = current_fsuid();
        if (!(dir->i_mode & S_ISVTX))
                return 0;
-        if (current_user_ns() != inode_userns(inode))
+        if (uid_eq(inode->i_uid, fsuid))
-                goto other_userns;
-        if (inode->i_uid == fsuid)
                return 0;
-        if (dir->i_uid == fsuid)
+        if (uid_eq(dir->i_uid, fsuid))
                return 0;
+        return !inode_capable(inode, CAP_FOWNER);
-other_userns:
-        return !ns_capable(inode_userns(inode), CAP_FOWNER);
 }
 /*
@@ -2534,8 +2526,7 @@ int vfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
        if (error)
                return error;
-        if ((S_ISCHR(mode) || S_ISBLK(mode)) &&
+        if ((S_ISCHR(mode) || S_ISBLK(mode)) && !capable(CAP_MKNOD))
-            !ns_capable(inode_userns(dir), CAP_MKNOD))
                return -EPERM;
        if (!dir->i_op->mknod)
diff --git a/fs/nfsd/auth.c b/fs/nfsd/auth.c
index 79717a40daba..204438cc914e 100644
--- a/fs/nfsd/auth.c
+++ b/fs/nfsd/auth.c
@@ -1,6 +1,7 @@
 /* Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de> */
 #include <linux/sched.h>
+#include <linux/user_namespace.h>
 #include "nfsd.h"
 #include "auth.h"
@@ -56,8 +57,8 @@ int nfsd_setuser(struct svc_rqst *rqstp, struct svc_export *exp)
                        goto oom;
                for (i = 0; i < rqgi->ngroups; i++) {
-                        if (!GROUP_AT(rqgi, i))
+                        if (gid_eq(GLOBAL_ROOT_GID, GROUP_AT(rqgi, i)))
-                                GROUP_AT(gi, i) = exp->ex_anon_gid;
+                                GROUP_AT(gi, i) = make_kgid(&init_user_ns, exp->ex_anon_gid);
                        else
                                GROUP_AT(gi, i) = GROUP_AT(rqgi, i);
                }
diff --git a/fs/open.c b/fs/open.c
index 5eccdcea2d1b..d54301219d04 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -316,7 +316,8 @@ SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode)
        if (!issecure(SECURE_NO_SETUID_FIXUP)) {
                /* Clear the capabilities if we switch to a non-root user */
-                if (override_cred->uid)
+                kuid_t root_uid = make_kuid(override_cred->user_ns, 0);
+                if (!uid_eq(override_cred->uid, root_uid))
                        cap_clear(override_cred->cap_effective);
                else
                        override_cred->cap_effective =
@@ -505,15 +506,24 @@ static int chown_common(struct path *path, uid_t user, gid_t group)
        struct inode *inode = path->dentry->d_inode;
        int error;
        struct iattr newattrs;
+        kuid_t uid;
+        kgid_t gid;
+        uid = make_kuid(current_user_ns(), user);
+        gid = make_kgid(current_user_ns(), group);
        newattrs.ia_valid =  ATTR_CTIME;
        if (user != (uid_t) -1) {
+                if (!uid_valid(uid))
+                        return -EINVAL;
                newattrs.ia_valid |= ATTR_UID;
-                newattrs.ia_uid = user;
+                newattrs.ia_uid = uid;
        }
        if (group != (gid_t) -1) {
+                if (!gid_valid(gid))
+                        return -EINVAL;
                newattrs.ia_valid |= ATTR_GID;
-                newattrs.ia_gid = group;
+                newattrs.ia_gid = gid;
        }
        if (!S_ISDIR(inode->i_mode))
                newattrs.ia_valid |=
diff --git a/fs/proc/array.c b/fs/proc/array.c
index f9bd395b3473..dc4c5a7b9ece 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -81,6 +81,7 @@
 #include <linux/pid_namespace.h>
 #include <linux/ptrace.h>
 #include <linux/tracehook.h>
+#include <linux/user_namespace.h>
 #include <asm/pgtable.h>
 #include <asm/processor.h>
@@ -161,6 +162,7 @@ static inline const char *get_task_state(struct task_struct *tsk)
 static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
                                struct pid *pid, struct task_struct *p)
 {
+        struct user_namespace *user_ns = current_user_ns();
        struct group_info *group_info;
        int g;
        struct fdtable *fdt = NULL;
@@ -189,8 +191,14 @@ static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
                task_tgid_nr_ns(p, ns),
                pid_nr_ns(pid, ns),
                ppid, tpid,
-                cred->uid, cred->euid, cred->suid, cred->fsuid,
+                from_kuid_munged(user_ns, cred->uid),
-                cred->gid, cred->egid, cred->sgid, cred->fsgid);
+                from_kuid_munged(user_ns, cred->euid),
+                from_kuid_munged(user_ns, cred->suid),
+                from_kuid_munged(user_ns, cred->fsuid),
+                from_kgid_munged(user_ns, cred->gid),
+                from_kgid_munged(user_ns, cred->egid),
+                from_kgid_munged(user_ns, cred->sgid),
+                from_kgid_munged(user_ns, cred->fsgid));
        task_lock(p);
        if (p->files)
@@ -205,7 +213,8 @@ static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
        task_unlock(p);
        for (g = 0; g < min(group_info->ngroups, NGROUPS_SMALL); g++)
-                seq_printf(m, "%d ", GROUP_AT(group_info, g));
+                seq_printf(m, "%d ",
+                           from_kgid_munged(user_ns, GROUP_AT(group_info, g)));
        put_cred(cred);
        seq_putc(m, '\n');
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 57b8159f26f3..d2d3108a611c 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -81,6 +81,7 @@
 #include <linux/oom.h>
 #include <linux/elf.h>
 #include <linux/pid_namespace.h>
+#include <linux/user_namespace.h>
 #include <linux/fs_struct.h>
 #include <linux/slab.h>
 #include <linux/flex_array.h>
@@ -1561,8 +1562,8 @@ int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
        generic_fillattr(inode, stat);
        rcu_read_lock();
-        stat->uid = 0;
+        stat->uid = GLOBAL_ROOT_UID;
-        stat->gid = 0;
+        stat->gid = GLOBAL_ROOT_GID;
        task = pid_task(proc_pid(inode), PIDTYPE_PID);
        if (task) {
                if (!has_pid_permissions(pid, task, 2)) {
@@ -1622,8 +1623,8 @@ int pid_revalidate(struct dentry *dentry, struct nameidata *nd)
                        inode->i_gid = cred->egid;
                        rcu_read_unlock();
                } else {
-                        inode->i_uid = 0;
+                        inode->i_uid = GLOBAL_ROOT_UID;
-                        inode->i_gid = 0;
+                        inode->i_gid = GLOBAL_ROOT_GID;
                }
                inode->i_mode &= ~(S_ISUID | S_ISGID);
                security_task_to_inode(task, inode);
@@ -1815,8 +1816,8 @@ static int tid_fd_revalidate(struct dentry *dentry, struct nameidata *nd)
                                        inode->i_gid = cred->egid;
                                        rcu_read_unlock();
                                } else {
-                                        inode->i_uid = 0;
+                                        inode->i_uid = GLOBAL_ROOT_UID;
-                                        inode->i_gid = 0;
+                                        inode->i_gid = GLOBAL_ROOT_GID;
                                }
                                i_mode = S_IFLNK;
@@ -2045,8 +2046,8 @@ static int map_files_d_revalidate(struct dentry *dentry, struct nameidata *nd)
                        inode->i_gid = cred->egid;
                        rcu_read_unlock();
                } else {
-                        inode->i_uid = 0;
+                        inode->i_uid = GLOBAL_ROOT_UID;
-                        inode->i_gid = 0;
+                        inode->i_gid = GLOBAL_ROOT_GID;
                }
                security_task_to_inode(task, inode);
                status = 1;
@@ -2924,6 +2925,74 @@ static int proc_tgid_io_accounting(struct task_struct *task, char *buffer)
 }
 #endif /* CONFIG_TASK_IO_ACCOUNTING */
+#ifdef CONFIG_USER_NS
+static int proc_id_map_open(struct inode *inode, struct file *file,
+        struct seq_operations *seq_ops)
+{
+        struct user_namespace *ns = NULL;
+        struct task_struct *task;
+        struct seq_file *seq;
+        int ret = -EINVAL;
+        task = get_proc_task(inode);
+        if (task) {
+                rcu_read_lock();
+                ns = get_user_ns(task_cred_xxx(task, user_ns));
+                rcu_read_unlock();
+                put_task_struct(task);
+        }
+        if (!ns)
+                goto err;
+        ret = seq_open(file, seq_ops);
+        if (ret)
+                goto err_put_ns;
+        seq = file->private_data;
+        seq->private = ns;
+        return 0;
+err_put_ns:
+        put_user_ns(ns);
+err:
+        return ret;
+}
+static int proc_id_map_release(struct inode *inode, struct file *file)
+{
+        struct seq_file *seq = file->private_data;
+        struct user_namespace *ns = seq->private;
+        put_user_ns(ns);
+        return seq_release(inode, file);
+}
+static int proc_uid_map_open(struct inode *inode, struct file *file)
+{
+        return proc_id_map_open(inode, file, &proc_uid_seq_operations);
+}
+static int proc_gid_map_open(struct inode *inode, struct file *file)
+{
+        return proc_id_map_open(inode, file, &proc_gid_seq_operations);
+}
+static const struct file_operations proc_uid_map_operations = {
+        .open           = proc_uid_map_open,
+        .write          = proc_uid_map_write,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = proc_id_map_release,
+};
+static const struct file_operations proc_gid_map_operations = {
+        .open           = proc_gid_map_open,
+        .write          = proc_gid_map_write,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = proc_id_map_release,
+};
+#endif /* CONFIG_USER_NS */
 static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns,
                                struct pid *pid, struct task_struct *task)
 {
@@ -3026,6 +3095,10 @@ static const struct pid_entry tgid_base_stuff[] = {
 #ifdef CONFIG_HARDWALL
        INF("hardwall",   S_IRUGO, proc_pid_hardwall),
 #endif
+#ifdef CONFIG_USER_NS
+        REG("uid_map",    S_IRUGO|S_IWUSR, proc_uid_map_operations),
+        REG("gid_map",    S_IRUGO|S_IWUSR, proc_gid_map_operations),
+#endif
 };
 static int proc_tgid_base_readdir(struct file * filp,
@@ -3381,6 +3454,10 @@ static const struct pid_entry tid_base_stuff[] = {
 #ifdef CONFIG_HARDWALL
        INF("hardwall",   S_IRUGO, proc_pid_hardwall),
 #endif
+#ifdef CONFIG_USER_NS
+        REG("uid_map",    S_IRUGO|S_IWUSR, proc_uid_map_operations),
+        REG("gid_map",    S_IRUGO|S_IWUSR, proc_gid_map_operations),
+#endif
 };
 static int proc_tid_base_readdir(struct file * filp,
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 205c92280838..554ecc54799f 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -108,8 +108,8 @@ static int proc_show_options(struct seq_file *seq, struct dentry *root)
        struct super_block *sb = root->d_sb;
        struct pid_namespace *pid = sb->s_fs_info;
-        if (pid->pid_gid)
+        if (!gid_eq(pid->pid_gid, GLOBAL_ROOT_GID))
-                seq_printf(seq, ",gid=%lu", (unsigned long)pid->pid_gid);
+                seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, pid->pid_gid));
        if (pid->hide_pid != 0)
                seq_printf(seq, ",hidepid=%u", pid->hide_pid);
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index 21d836f40292..3476bca8f7af 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -371,9 +371,9 @@ void register_sysctl_root(struct ctl_table_root *root)
 static int test_perm(int mode, int op)
 {
-        if (!current_euid())
+        if (uid_eq(current_euid(), GLOBAL_ROOT_UID))
                mode >>= 6;
-        else if (in_egroup_p(0))
+        else if (in_egroup_p(GLOBAL_ROOT_GID))
                mode >>= 3;
        if ((op & ~mode & (MAY_READ|MAY_WRITE|MAY_EXEC)) == 0)
                return 0;
diff --git a/fs/proc/root.c b/fs/proc/root.c
index eed44bfc85db..7c30fce037c0 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -67,7 +67,7 @@ static int proc_parse_options(char *options, struct pid_namespace *pid)
                case Opt_gid:
                        if (match_int(&args[0], &option))
                                return 0;
-                        pid->pid_gid = option;
+                        pid->pid_gid = make_kgid(current_user_ns(), option);
                        break;
                case Opt_hidepid:
                        if (match_int(&args[0], &option))
diff --git a/fs/stat.c b/fs/stat.c
index 0cef3366a919..b6ff11825fc8 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -138,8 +138,8 @@ static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * sta
        tmp.st_nlink = stat->nlink;
        if (tmp.st_nlink != stat->nlink)
                return -EOVERFLOW;
-        SET_UID(tmp.st_uid, stat->uid);
+        SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
-        SET_GID(tmp.st_gid, stat->gid);
+        SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
        tmp.st_rdev = old_encode_dev(stat->rdev);
 #if BITS_PER_LONG == 32
        if (stat->size > MAX_NON_LFS)
@@ -224,8 +224,8 @@ static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
        tmp.st_nlink = stat->nlink;
        if (tmp.st_nlink != stat->nlink)
                return -EOVERFLOW;
-        SET_UID(tmp.st_uid, stat->uid);
+        SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
-        SET_GID(tmp.st_gid, stat->gid);
+        SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
        tmp.st_rdev = encode_dev(stat->rdev);
        tmp.st_size = stat->size;
        tmp.st_atime = stat->atime.tv_sec;
@@ -355,8 +355,8 @@ static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
 #endif
        tmp.st_mode = stat->mode;
        tmp.st_nlink = stat->nlink;
-        tmp.st_uid = stat->uid;
+        tmp.st_uid = from_kuid_munged(current_user_ns(), stat->uid);
-        tmp.st_gid = stat->gid;
+        tmp.st_gid = from_kgid_munged(current_user_ns(), stat->gid);
        tmp.st_atime = stat->atime.tv_sec;
        tmp.st_atime_nsec = stat->atime.tv_nsec;
        tmp.st_mtime = stat->mtime.tv_sec;
diff --git a/fs/sysfs/inode.c b/fs/sysfs/inode.c
index feb2d69396cf..907c2b3af758 100644
--- a/fs/sysfs/inode.c
+++ b/fs/sysfs/inode.c
@@ -62,8 +62,8 @@ static struct sysfs_inode_attrs *sysfs_init_inode_attrs(struct sysfs_dirent *sd)
        /* assign default attributes */
        iattrs->ia_mode = sd->s_mode;
-        iattrs->ia_uid = 0;
+        iattrs->ia_uid = GLOBAL_ROOT_UID;
-        iattrs->ia_gid = 0;
+        iattrs->ia_gid = GLOBAL_ROOT_GID;
        iattrs->ia_atime = iattrs->ia_mtime = iattrs->ia_ctime = CURRENT_TIME;
        return attrs;
diff --git a/include/linux/capability.h b/include/linux/capability.h
index c398cff3dab7..68d56effc328 100644
--- a/include/linux/capability.h
+++ b/include/linux/capability.h
@@ -377,6 +377,7 @@ struct cpu_vfs_cap_data {
 #ifdef __KERNEL__
+struct inode;
 struct dentry;
 struct user_namespace;
@@ -551,6 +552,7 @@ extern bool has_ns_capability_noaudit(struct task_struct *t,
 extern bool capable(int cap);
 extern bool ns_capable(struct user_namespace *ns, int cap);
 extern bool nsown_capable(int cap);
+extern bool inode_capable(const struct inode *inode, int cap);
 /* audit system wants to get cap info from files as well */
 extern int get_vfs_caps_from_disk(const struct dentry *dentry, struct cpu_vfs_cap_data *cpu_caps);
diff --git a/include/linux/cred.h b/include/linux/cred.h
index adadf71a7327..917dc5aeb1d4 100644
--- a/include/linux/cred.h
+++ b/include/linux/cred.h
@@ -17,6 +17,7 @@
 #include <linux/key.h>
 #include <linux/selinux.h>
 #include <linux/atomic.h>
+#include <linux/uidgid.h>
 struct user_struct;
 struct cred;
@@ -26,14 +27,14 @@ struct inode;
 * COW Supplementary groups list
 */
 #define NGROUPS_SMALL           32
-#define NGROUPS_PER_BLOCK       ((unsigned int)(PAGE_SIZE / sizeof(gid_t)))
+#define NGROUPS_PER_BLOCK       ((unsigned int)(PAGE_SIZE / sizeof(kgid_t)))
 struct group_info {
        atomic_t        usage;
        int             ngroups;
        int             nblocks;
-        gid_t           small_block[NGROUPS_SMALL];
+        kgid_t          small_block[NGROUPS_SMALL];
-        gid_t           *blocks[0];
+        kgid_t          *blocks[0];
 };
 /**
@@ -66,14 +67,14 @@ extern struct group_info init_groups;
 extern void groups_free(struct group_info *);
 extern int set_current_groups(struct group_info *);
 extern int set_groups(struct cred *, struct group_info *);
-extern int groups_search(const struct group_info *, gid_t);
+extern int groups_search(const struct group_info *, kgid_t);
 /* access the groups "array" with this macro */
 #define GROUP_AT(gi, i) \
        ((gi)->blocks[(i) / NGROUPS_PER_BLOCK][(i) % NGROUPS_PER_BLOCK])
-extern int in_group_p(gid_t);
+extern int in_group_p(kgid_t);
-extern int in_egroup_p(gid_t);
+extern int in_egroup_p(kgid_t);
 /*
 * The common credentials for a thread group
@@ -122,14 +123,14 @@ struct cred {
 #define CRED_MAGIC      0x43736564
 #define CRED_MAGIC_DEAD 0x44656144
 #endif
-        uid_t           uid;            /* real UID of the task */
+        kuid_t          uid;            /* real UID of the task */
-        gid_t           gid;            /* real GID of the task */
+        kgid_t          gid;            /* real GID of the task */
-        uid_t           suid;           /* saved UID of the task */
+        kuid_t          suid;           /* saved UID of the task */
-        gid_t           sgid;           /* saved GID of the task */
+        kgid_t          sgid;           /* saved GID of the task */
-        uid_t           euid;           /* effective UID of the task */
+        kuid_t          euid;           /* effective UID of the task */
-        gid_t           egid;           /* effective GID of the task */
+        kgid_t          egid;           /* effective GID of the task */
-        uid_t           fsuid;          /* UID for VFS ops */
+        kuid_t          fsuid;          /* UID for VFS ops */
-        gid_t           fsgid;          /* GID for VFS ops */
+        kgid_t          fsgid;          /* GID for VFS ops */
        unsigned        securebits;     /* SUID-less security management */
        kernel_cap_t    cap_inheritable; /* caps our children can inherit */
        kernel_cap_t    cap_permitted;  /* caps we're permitted */
@@ -146,7 +147,7 @@ struct cred {
        void            *security;      /* subjective LSM security */
 #endif
        struct user_struct *user;       /* real user ID subscription */
-        struct user_namespace *user_ns; /* cached user->user_ns */
+        struct user_namespace *user_ns; /* user_ns the caps and keyrings are relative to. */
        struct group_info *group_info;  /* supplementary groups for euid/fsgid */
        struct rcu_head rcu;            /* RCU deletion hook */
 };
@@ -357,11 +358,11 @@ static inline void put_cred(const struct cred *_cred)
 #define current_user()          (current_cred_xxx(user))
 #define current_security()      (current_cred_xxx(security))
+extern struct user_namespace init_user_ns;
 #ifdef CONFIG_USER_NS
 #define current_user_ns()       (current_cred_xxx(user_ns))
 #define task_user_ns(task)      (task_cred_xxx((task), user_ns))
 #else
-extern struct user_namespace init_user_ns;
 #define current_user_ns()       (&init_user_ns)
 #define task_user_ns(task)      (&init_user_ns)
 #endif
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 25c40b9f848a..c0e53372b082 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -402,6 +402,7 @@ struct inodes_stat_t {
 #include <linux/atomic.h>
 #include <linux/shrinker.h>
 #include <linux/migrate_mode.h>
+#include <linux/uidgid.h>
 #include <asm/byteorder.h>
@@ -469,8 +470,8 @@ typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
 struct iattr {
        unsigned int    ia_valid;
        umode_t         ia_mode;
-        uid_t           ia_uid;
+        kuid_t          ia_uid;
-        gid_t           ia_gid;
+        kgid_t          ia_gid;
        loff_t          ia_size;
        struct timespec ia_atime;
        struct timespec ia_mtime;
@@ -761,8 +762,8 @@ struct posix_acl;
 struct inode {
        umode_t                 i_mode;
        unsigned short          i_opflags;
-        uid_t                   i_uid;
+        kuid_t                  i_uid;
-        gid_t                   i_gid;
+        kgid_t                  i_gid;
        unsigned int            i_flags;
 #ifdef CONFIG_FS_POSIX_ACL
@@ -927,6 +928,31 @@ static inline void i_size_write(struct inode *inode, loff_t i_size)
 #endif
 }
+/* Helper functions so that in most cases filesystems will
+ * not need to deal directly with kuid_t and kgid_t and can
+ * instead deal with the raw numeric values that are stored
+ * in the filesystem.
+ */
+static inline uid_t i_uid_read(const struct inode *inode)
+{
+        return from_kuid(&init_user_ns, inode->i_uid);
+}
+static inline gid_t i_gid_read(const struct inode *inode)
+{
+        return from_kgid(&init_user_ns, inode->i_gid);
+}
+static inline void i_uid_write(struct inode *inode, uid_t uid)
+{
+        inode->i_uid = make_kuid(&init_user_ns, uid);
+}
+static inline void i_gid_write(struct inode *inode, gid_t gid)
+{
+        inode->i_gid = make_kgid(&init_user_ns, gid);
+}
 static inline unsigned iminor(const struct inode *inode)
 {
        return MINOR(inode->i_rdev);
@@ -943,7 +969,7 @@ struct fown_struct {
        rwlock_t lock;          /* protects pid, uid, euid fields */
        struct pid *pid;        /* pid or -pgrp where SIGIO should be sent */
        enum pid_type pid_type; /* Kind of process group SIGIO should be sent to */
-        uid_t uid, euid;        /* uid/euid of process setting the owner */
+        kuid_t uid, euid;       /* uid/euid of process setting the owner */
        int signum;             /* posix.1b rt signal to be delivered on IO */
 };
@@ -1527,12 +1553,6 @@ enum {
 #define vfs_check_frozen(sb, level) \
        wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level)))
-/*
- * until VFS tracks user namespaces for inodes, just make all files
- * belong to init_user_ns
- */
-extern struct user_namespace init_user_ns;
-#define inode_userns(inode) (&init_user_ns)
 extern bool inode_owner_or_capable(const struct inode *inode);
 /* not quite ready to be deprecated, but... */
diff --git a/include/linux/pid_namespace.h b/include/linux/pid_namespace.h
index b067bd8c49d0..00474b047145 100644
--- a/include/linux/pid_namespace.h
+++ b/include/linux/pid_namespace.h
@@ -31,7 +31,7 @@ struct pid_namespace {
 #ifdef CONFIG_BSD_PROCESS_ACCT
        struct bsd_acct_struct *bacct;
 #endif
-        gid_t pid_gid;
+        kgid_t pid_gid;
        int hide_pid;
        int reboot;     /* group exit code if this pidns was rebooted */
 };
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index 85c507306239..3fd2e871ff1b 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -52,8 +52,8 @@ struct proc_dir_entry {
        unsigned int low_ino;
        umode_t mode;
        nlink_t nlink;
-        uid_t uid;
+        kuid_t uid;
-        gid_t gid;
+        kgid_t gid;
        loff_t size;
        const struct inode_operations *proc_iops;
        /*
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index d93f95e6177c..17b977304a09 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -22,8 +22,8 @@ static inline struct quota_info *sb_dqopt(struct super_block *sb)
 static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
 {
        return (ia->ia_valid & ATTR_SIZE && ia->ia_size != inode->i_size) ||
-                (ia->ia_valid & ATTR_UID && ia->ia_uid != inode->i_uid) ||
+                (ia->ia_valid & ATTR_UID && !uid_eq(ia->ia_uid, inode->i_uid)) ||
-                (ia->ia_valid & ATTR_GID && ia->ia_gid != inode->i_gid);
+                (ia->ia_valid & ATTR_GID && !gid_eq(ia->ia_gid, inode->i_gid));
 }
 #if defined(CONFIG_QUOTA)
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 28fa9d02fd59..5ea8baea9387 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -90,6 +90,7 @@ struct sched_param {
 #include <linux/latencytop.h>
 #include <linux/cred.h>
 #include <linux/llist.h>
+#include <linux/uidgid.h>
 #include <asm/processor.h>
@@ -728,8 +729,7 @@ struct user_struct {
        /* Hash table maintenance information */
        struct hlist_node uidhash_node;
-        uid_t uid;
+        kuid_t uid;
-        struct user_namespace *user_ns;
 #ifdef CONFIG_PERF_EVENTS
        atomic_long_t locked_vm;
@@ -738,7 +738,7 @@ struct user_struct {
 extern int uids_sysfs_init(void);
-extern struct user_struct *find_user(uid_t);
+extern struct user_struct *find_user(kuid_t);
 extern struct user_struct root_user;
 #define INIT_USER (&root_user)
@@ -2142,14 +2142,13 @@ extern struct task_struct *find_task_by_pid_ns(pid_t nr,
 extern void __set_special_pids(struct pid *pid);
 /* per-UID process charging. */
-extern struct user_struct * alloc_uid(struct user_namespace *, uid_t);
+extern struct user_struct * alloc_uid(kuid_t);
 static inline struct user_struct *get_uid(struct user_struct *u)
 {
        atomic_inc(&u->__count);
        return u;
 }
 extern void free_uid(struct user_struct *);
-extern void release_uids(struct user_namespace *ns);
 #include <asm/current.h>
diff --git a/include/linux/shmem_fs.h b/include/linux/shmem_fs.h
index 79ab2555b3b0..bef2cf00b3be 100644
--- a/include/linux/shmem_fs.h
+++ b/include/linux/shmem_fs.h
@@ -28,8 +28,8 @@ struct shmem_sb_info {
        unsigned long max_inodes;   /* How many inodes are allowed */
        unsigned long free_inodes;  /* How many are left for allocation */
        spinlock_t stat_lock;       /* Serialize shmem_sb_info changes */
-        uid_t uid;                  /* Mount uid for root directory */
+        kuid_t uid;                 /* Mount uid for root directory */
-        gid_t gid;                  /* Mount gid for root directory */
+        kgid_t gid;                 /* Mount gid for root directory */
        umode_t mode;               /* Mount mode for root directory */
        struct mempolicy *mpol;     /* default memory policy for mappings */
 };
diff --git a/include/linux/stat.h b/include/linux/stat.h
index 611c398dab72..46132409a3f7 100644
--- a/include/linux/stat.h
+++ b/include/linux/stat.h
@@ -58,14 +58,15 @@
 #include <linux/types.h>
 #include <linux/time.h>
+#include <linux/uidgid.h>
 struct kstat {
        u64             ino;
        dev_t           dev;
        umode_t         mode;
        unsigned int    nlink;
-        uid_t           uid;
+        kuid_t          uid;
-        gid_t           gid;
+        kgid_t          gid;
        dev_t           rdev;
        loff_t          size;
        struct timespec  atime;
diff --git a/include/linux/uidgid.h b/include/linux/uidgid.h
new file mode 100644
index 000000000000..8e522cbcef29
--- /dev/null
+++ b/include/linux/uidgid.h
@@ -0,0 +1,200 @@
+#ifndef _LINUX_UIDGID_H
+#define _LINUX_UIDGID_H
+/*
+ * A set of types for the internal kernel types representing uids and gids.
+ *
+ * The types defined in this header allow distinguishing which uids and gids in
+ * the kernel are values used by userspace and which uid and gid values are
+ * the internal kernel values.  With the addition of user namespaces the values
+ * can be different.  Using the type system makes it possible for the compiler
+ * to detect when we overlook these differences.
+ *
+ */
+#include <linux/types.h>
+#include <linux/highuid.h>
+struct user_namespace;
+extern struct user_namespace init_user_ns;
+#ifdef CONFIG_UIDGID_STRICT_TYPE_CHECKS
+typedef struct {
+        uid_t val;
+} kuid_t;
+typedef struct {
+        gid_t val;
+} kgid_t;
+#define KUIDT_INIT(value) (kuid_t){ value }
+#define KGIDT_INIT(value) (kgid_t){ value }
+static inline uid_t __kuid_val(kuid_t uid)
+{
+        return uid.val;
+}
+static inline gid_t __kgid_val(kgid_t gid)
+{
+        return gid.val;
+}
+#else
+typedef uid_t kuid_t;
+typedef gid_t kgid_t;
+static inline uid_t __kuid_val(kuid_t uid)
+{
+        return uid;
+}
+static inline gid_t __kgid_val(kgid_t gid)
+{
+        return gid;
+}
+#define KUIDT_INIT(value) ((kuid_t) value )
+#define KGIDT_INIT(value) ((kgid_t) value )
+#endif
+#define GLOBAL_ROOT_UID KUIDT_INIT(0)
+#define GLOBAL_ROOT_GID KGIDT_INIT(0)
+#define INVALID_UID KUIDT_INIT(-1)
+#define INVALID_GID KGIDT_INIT(-1)
+static inline bool uid_eq(kuid_t left, kuid_t right)
+{
+        return __kuid_val(left) == __kuid_val(right);
+}
+static inline bool gid_eq(kgid_t left, kgid_t right)
+{
+        return __kgid_val(left) == __kgid_val(right);
+}
+static inline bool uid_gt(kuid_t left, kuid_t right)
+{
+        return __kuid_val(left) > __kuid_val(right);
+}
+static inline bool gid_gt(kgid_t left, kgid_t right)
+{
+        return __kgid_val(left) > __kgid_val(right);
+}
+static inline bool uid_gte(kuid_t left, kuid_t right)
+{
+        return __kuid_val(left) >= __kuid_val(right);
+}
+static inline bool gid_gte(kgid_t left, kgid_t right)
+{
+        return __kgid_val(left) >= __kgid_val(right);
+}
+static inline bool uid_lt(kuid_t left, kuid_t right)
+{
+        return __kuid_val(left) < __kuid_val(right);
+}
+static inline bool gid_lt(kgid_t left, kgid_t right)
+{
+        return __kgid_val(left) < __kgid_val(right);
+}
+static inline bool uid_lte(kuid_t left, kuid_t right)
+{
+        return __kuid_val(left) <= __kuid_val(right);
+}
+static inline bool gid_lte(kgid_t left, kgid_t right)
+{
+        return __kgid_val(left) <= __kgid_val(right);
+}
+static inline bool uid_valid(kuid_t uid)
+{
+        return !uid_eq(uid, INVALID_UID);
+}
+static inline bool gid_valid(kgid_t gid)
+{
+        return !gid_eq(gid, INVALID_GID);
+}
+#ifdef CONFIG_USER_NS
+extern kuid_t make_kuid(struct user_namespace *from, uid_t uid);
+extern kgid_t make_kgid(struct user_namespace *from, gid_t gid);
+extern uid_t from_kuid(struct user_namespace *to, kuid_t uid);
+extern gid_t from_kgid(struct user_namespace *to, kgid_t gid);
+extern uid_t from_kuid_munged(struct user_namespace *to, kuid_t uid);
+extern gid_t from_kgid_munged(struct user_namespace *to, kgid_t gid);
+static inline bool kuid_has_mapping(struct user_namespace *ns, kuid_t uid)
+{
+        return from_kuid(ns, uid) != (uid_t) -1;
+}
+static inline bool kgid_has_mapping(struct user_namespace *ns, kgid_t gid)
+{
+        return from_kgid(ns, gid) != (gid_t) -1;
+}
+#else
+static inline kuid_t make_kuid(struct user_namespace *from, uid_t uid)
+{
+        return KUIDT_INIT(uid);
+}
+static inline kgid_t make_kgid(struct user_namespace *from, gid_t gid)
+{
+        return KGIDT_INIT(gid);
+}
+static inline uid_t from_kuid(struct user_namespace *to, kuid_t kuid)
+{
+        return __kuid_val(kuid);
+}
+static inline gid_t from_kgid(struct user_namespace *to, kgid_t kgid)
+{
+        return __kgid_val(kgid);
+}
+static inline uid_t from_kuid_munged(struct user_namespace *to, kuid_t kuid)
+{
+        uid_t uid = from_kuid(to, kuid);
+        if (uid == (uid_t)-1)
+                uid = overflowuid;
+        return uid;
+}
+static inline gid_t from_kgid_munged(struct user_namespace *to, kgid_t kgid)
+{
+        gid_t gid = from_kgid(to, kgid);
+        if (gid == (gid_t)-1)
+                gid = overflowgid;
+        return gid;
+}
+static inline bool kuid_has_mapping(struct user_namespace *ns, kuid_t uid)
+{
+        return true;
+}
+static inline bool kgid_has_mapping(struct user_namespace *ns, kgid_t gid)
+{
+        return true;
+}
+#endif /* CONFIG_USER_NS */
+#endif /* _LINUX_UIDGID_H */
diff --git a/include/linux/user_namespace.h b/include/linux/user_namespace.h
index faf467944baf..4e72922e5a75 100644
--- a/include/linux/user_namespace.h
+++ b/include/linux/user_namespace.h
@@ -6,14 +6,24 @@
 #include <linux/sched.h>
 #include <linux/err.h>
-#define UIDHASH_BITS    (CONFIG_BASE_SMALL ? 3 : 7)
+#define UID_GID_MAP_MAX_EXTENTS 5
-#define UIDHASH_SZ      (1 << UIDHASH_BITS)
+struct uid_gid_map {    /* 64 bytes -- 1 cache line */
+        u32 nr_extents;
+        struct uid_gid_extent {
+                u32 first;
+                u32 lower_first;
+                u32 count;
+        } extent[UID_GID_MAP_MAX_EXTENTS];
+};
 struct user_namespace {
+        struct uid_gid_map      uid_map;
+        struct uid_gid_map      gid_map;
        struct kref             kref;
-        struct hlist_head       uidhash_table[UIDHASH_SZ];
+        struct user_namespace   *parent;
-        struct user_struct      *creator;
+        kuid_t                  owner;
-        struct work_struct      destroyer;
+        kgid_t                  group;
 };
 extern struct user_namespace init_user_ns;
@@ -36,9 +46,11 @@ static inline void put_user_ns(struct user_namespace *ns)
                kref_put(&ns->kref, free_user_ns);
 }
-uid_t user_ns_map_uid(struct user_namespace *to, const struct cred *cred, uid_t uid);
+struct seq_operations;
-gid_t user_ns_map_gid(struct user_namespace *to, const struct cred *cred, gid_t gid);
+extern struct seq_operations proc_uid_seq_operations;
+extern struct seq_operations proc_gid_seq_operations;
+extern ssize_t proc_uid_map_write(struct file *, const char __user *, size_t, loff_t *);
+extern ssize_t proc_gid_map_write(struct file *, const char __user *, size_t, loff_t *);
 #else
 static inline struct user_namespace *get_user_ns(struct user_namespace *ns)
@@ -55,17 +67,6 @@ static inline void put_user_ns(struct user_namespace *ns)
 {
 }
-static inline uid_t user_ns_map_uid(struct user_namespace *to,
-        const struct cred *cred, uid_t uid)
-{
-        return uid;
-}
-static inline gid_t user_ns_map_gid(struct user_namespace *to,
-        const struct cred *cred, gid_t gid)
-{
-        return gid;
-}
 #endif
 #endif /* _LINUX_USER_H */
diff --git a/include/trace/events/ext3.h b/include/trace/events/ext3.h
index 7b53c0573dc9..15d11a39be47 100644
--- a/include/trace/events/ext3.h
+++ b/include/trace/events/ext3.h
@@ -24,8 +24,8 @@ TRACE_EVENT(ext3_free_inode,
                __entry->dev    = inode->i_sb->s_dev;
                __entry->ino    = inode->i_ino;
                __entry->mode   = inode->i_mode;
-                __entry->uid    = inode->i_uid;
+                __entry->uid    = i_uid_read(inode);
-                __entry->gid    = inode->i_gid;
+                __entry->gid    = i_gid_read(inode);
                __entry->blocks = inode->i_blocks;
        ),
diff --git a/include/trace/events/ext4.h b/include/trace/events/ext4.h
index 319538bf17d2..69d8a69ea831 100644
--- a/include/trace/events/ext4.h
+++ b/include/trace/events/ext4.h
@@ -36,8 +36,8 @@ TRACE_EVENT(ext4_free_inode,
                __entry->dev    = inode->i_sb->s_dev;
                __entry->ino    = inode->i_ino;
                __entry->mode   = inode->i_mode;
-                __entry->uid    = inode->i_uid;
+                __entry->uid    = i_uid_read(inode);
-                __entry->gid    = inode->i_gid;
+                __entry->gid    = i_gid_read(inode);
                __entry->blocks = inode->i_blocks;
        ),
diff --git a/init/Kconfig b/init/Kconfig
index a30fe085940e..ccb5248474c2 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -873,7 +873,10 @@ config IPC_NS
 config USER_NS
        bool "User namespace (EXPERIMENTAL)"
        depends on EXPERIMENTAL
-        default y
+        depends on UIDGID_CONVERTED
+        select UIDGID_STRICT_TYPE_CHECKS
+        default n
        help
          This allows containers, i.e. vservers, to use user namespaces
          to provide different user info for different servers.
@@ -897,6 +900,131 @@ config NET_NS
 endif # NAMESPACES
+config UIDGID_CONVERTED
+        # True if all of the selected software conmponents are known
+        # to have uid_t and gid_t converted to kuid_t and kgid_t
+        # where appropriate and are otherwise safe to use with
+        # the user namespace.
+        bool
+        default y
+        # List of kernel pieces that need user namespace work
+        # Features
+        depends on SYSVIPC = n
+        depends on IMA = n
+        depends on EVM = n
+        depends on KEYS = n
+        depends on AUDIT = n
+        depends on AUDITSYSCALL = n
+        depends on TASKSTATS = n
+        depends on TRACING = n
+        depends on FS_POSIX_ACL = n
+        depends on QUOTA = n
+        depends on QUOTACTL = n
+        depends on DEBUG_CREDENTIALS = n
+        depends on BSD_PROCESS_ACCT = n
+        depends on DRM = n
+        depends on PROC_EVENTS = n
+        # Networking
+        depends on NET = n
+        depends on NET_9P = n
+        depends on IPX = n
+        depends on PHONET = n
+        depends on NET_CLS_FLOW = n
+        depends on NETFILTER_XT_MATCH_OWNER = n
+        depends on NETFILTER_XT_MATCH_RECENT = n
+        depends on NETFILTER_XT_TARGET_LOG = n
+        depends on NETFILTER_NETLINK_LOG = n
+        depends on INET = n
+        depends on IPV6 = n
+        depends on IP_SCTP = n
+        depends on AF_RXRPC = n
+        depends on LLC2 = n
+        depends on NET_KEY = n
+        depends on INET_DIAG = n
+        depends on DNS_RESOLVER = n
+        depends on AX25 = n
+        depends on ATALK = n
+        # Filesystems
+        depends on USB_DEVICEFS = n
+        depends on USB_GADGETFS = n
+        depends on USB_FUNCTIONFS = n
+        depends on DEVTMPFS = n
+        depends on XENFS = n
+        depends on 9P_FS = n
+        depends on ADFS_FS = n
+        depends on AFFS_FS = n
+        depends on AFS_FS = n
+        depends on AUTOFS4_FS = n
+        depends on BEFS_FS = n
+        depends on BFS_FS = n
+        depends on BTRFS_FS = n
+        depends on CEPH_FS = n
+        depends on CIFS = n
+        depends on CODA_FS = n
+        depends on CONFIGFS_FS = n
+        depends on CRAMFS = n
+        depends on DEBUG_FS = n
+        depends on ECRYPT_FS = n
+        depends on EFS_FS = n
+        depends on EXOFS_FS = n
+        depends on FAT_FS = n
+        depends on FUSE_FS = n
+        depends on GFS2_FS = n
+        depends on HFS_FS = n
+        depends on HFSPLUS_FS = n
+        depends on HPFS_FS = n
+        depends on HUGETLBFS = n
+        depends on ISO9660_FS = n
+        depends on JFFS2_FS = n
+        depends on JFS_FS = n
+        depends on LOGFS = n
+        depends on MINIX_FS = n
+        depends on NCP_FS = n
+        depends on NFSD = n
+        depends on NFS_FS = n
+        depends on NILFS2_FS = n
+        depends on NTFS_FS = n
+        depends on OCFS2_FS = n
+        depends on OMFS_FS = n
+        depends on QNX4FS_FS = n
+        depends on QNX6FS_FS = n
+        depends on REISERFS_FS = n
+        depends on SQUASHFS = n
+        depends on SYSV_FS = n
+        depends on UBIFS_FS = n
+        depends on UDF_FS = n
+        depends on UFS_FS = n
+        depends on VXFS_FS = n
+        depends on XFS_FS = n
+        depends on !UML || HOSTFS = n
+        # The rare drivers that won't build
+        depends on AIRO = n
+        depends on AIRO_CS = n
+        depends on TUN = n
+        depends on INFINIBAND_QIB = n
+        depends on BLK_DEV_LOOP = n
+        depends on ANDROID_BINDER_IPC = n
+        # Security modules
+        depends on SECURITY_TOMOYO = n
+        depends on SECURITY_APPARMOR = n
+config UIDGID_STRICT_TYPE_CHECKS
+        bool "Require conversions between uid/gids and their internal representation"
+        depends on UIDGID_CONVERTED
+        default n
+        help
+         While the nececessary conversions are being added to all subsystems this option allows
+         the code to continue to build for unconverted subsystems.
+         Say Y here if you want the strict type checking enabled
 config SCHED_AUTOGROUP
        bool "Automatic process group scheduling"
        select EVENTFD
diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index 28bd64ddeda3..b6a0d46fbad7 100644
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -66,6 +66,7 @@ struct mqueue_inode_info {
        struct sigevent notify;
        struct pid* notify_owner;
+        struct user_namespace *notify_user_ns;
        struct user_struct *user;       /* user who created, for accounting */
        struct sock *notify_sock;
        struct sk_buff *notify_cookie;
@@ -139,6 +140,7 @@ static struct inode *mqueue_get_inode(struct super_block *sb,
                INIT_LIST_HEAD(&info->e_wait_q[0].list);
                INIT_LIST_HEAD(&info->e_wait_q[1].list);
                info->notify_owner = NULL;
+                info->notify_user_ns = NULL;
                info->qsize = 0;
                info->user = NULL;      /* set when all is ok */
                memset(&info->attr, 0, sizeof(info->attr));
@@ -536,8 +538,7 @@ static void __do_notify(struct mqueue_inode_info *info)
                        rcu_read_lock();
                        sig_i.si_pid = task_tgid_nr_ns(current,
                                                ns_of_pid(info->notify_owner));
-                        sig_i.si_uid = user_ns_map_uid(info->user->user_ns,
+                        sig_i.si_uid = from_kuid_munged(info->notify_user_ns, current_uid());
-                                                current_cred(), current_uid());
                        rcu_read_unlock();
                        kill_pid_info(info->notify.sigev_signo,
@@ -550,7 +551,9 @@ static void __do_notify(struct mqueue_inode_info *info)
                }
                /* after notification unregisters process */
                put_pid(info->notify_owner);
+                put_user_ns(info->notify_user_ns);
                info->notify_owner = NULL;
+                info->notify_user_ns = NULL;
        }
        wake_up(&info->wait_q);
 }
@@ -575,7 +578,9 @@ static void remove_notification(struct mqueue_inode_info *info)
                netlink_sendskb(info->notify_sock, info->notify_cookie);
        }
        put_pid(info->notify_owner);
+        put_user_ns(info->notify_user_ns);
        info->notify_owner = NULL;
+        info->notify_user_ns = NULL;
 }
 static int mq_attr_ok(struct ipc_namespace *ipc_ns, struct mq_attr *attr)
@@ -1140,6 +1145,7 @@ retry:
                }
                info->notify_owner = get_pid(task_tgid(current));
+                info->notify_user_ns = get_user_ns(current_user_ns());
                inode->i_atime = inode->i_ctime = CURRENT_TIME;
        }
        spin_unlock(&info->lock);
diff --git a/ipc/namespace.c b/ipc/namespace.c
index ce0a647869b1..f362298c5ce4 100644
--- a/ipc/namespace.c
+++ b/ipc/namespace.c
@@ -46,7 +46,7 @@ static struct ipc_namespace *create_ipc_ns(struct task_struct *tsk,
        ipcns_notify(IPCNS_CREATED);
        register_ipcns_notifier(ns);
-        ns->user_ns = get_user_ns(task_cred_xxx(tsk, user)->user_ns);
+        ns->user_ns = get_user_ns(task_cred_xxx(tsk, user_ns));
        return ns;
 }
diff --git a/kernel/capability.c b/kernel/capability.c
index 3f1adb6c6470..493d97259484 100644
--- a/kernel/capability.c
+++ b/kernel/capability.c
@@ -419,3 +419,24 @@ bool nsown_capable(int cap)
 {
        return ns_capable(current_user_ns(), cap);
 }
+/**
+ * inode_capable - Check superior capability over inode
+ * @inode: The inode in question
+ * @cap: The capability in question
+ *
+ * Return true if the current task has the given superior capability
+ * targeted at it's own user namespace and that the given inode is owned
+ * by the current user namespace or a child namespace.
+ *
+ * Currently we check to see if an inode is owned by the current
+ * user namespace by seeing if the inode's owner maps into the
+ * current user namespace.
+ *
+ */
+bool inode_capable(const struct inode *inode, int cap)
+{
+        struct user_namespace *ns = current_user_ns();
+        return ns_capable(ns, cap) && kuid_has_mapping(ns, inode->i_uid);
+}
diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index ad8eae5bb801..a0c6af34d500 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -2214,9 +2214,9 @@ retry_find_task:
                 * only need to check permissions on one of them.
                 */
                tcred = __task_cred(tsk);
-                if (cred->euid &&
+                if (!uid_eq(cred->euid, GLOBAL_ROOT_UID) &&
-                    cred->euid != tcred->uid &&
+                    !uid_eq(cred->euid, tcred->uid) &&
-                    cred->euid != tcred->suid) {
+                    !uid_eq(cred->euid, tcred->suid)) {
                        rcu_read_unlock();
                        ret = -EACCES;
                        goto out_unlock_cgroup;
diff --git a/kernel/cred.c b/kernel/cred.c
index e70683d9ec32..430557ea488f 100644
--- a/kernel/cred.c
+++ b/kernel/cred.c
@@ -49,6 +49,14 @@ struct cred init_cred = {
        .subscribers            = ATOMIC_INIT(2),
        .magic                  = CRED_MAGIC,
 #endif
+        .uid                    = GLOBAL_ROOT_UID,
+        .gid                    = GLOBAL_ROOT_GID,
+        .suid                   = GLOBAL_ROOT_UID,
+        .sgid                   = GLOBAL_ROOT_GID,
+        .euid                   = GLOBAL_ROOT_UID,
+        .egid                   = GLOBAL_ROOT_GID,
+        .fsuid                  = GLOBAL_ROOT_UID,
+        .fsgid                  = GLOBAL_ROOT_GID,
        .securebits             = SECUREBITS_DEFAULT,
        .cap_inheritable        = CAP_EMPTY_SET,
        .cap_permitted          = CAP_FULL_SET,
@@ -148,6 +156,7 @@ static void put_cred_rcu(struct rcu_head *rcu)
        if (cred->group_info)
                put_group_info(cred->group_info);
        free_uid(cred->user);
+        put_user_ns(cred->user_ns);
        kmem_cache_free(cred_jar, cred);
 }
@@ -303,6 +312,7 @@ struct cred *prepare_creds(void)
        set_cred_subscribers(new, 0);
        get_group_info(new->group_info);
        get_uid(new->user);
+        get_user_ns(new->user_ns);
 #ifdef CONFIG_KEYS
        key_get(new->thread_keyring);
@@ -414,11 +424,6 @@ int copy_creds(struct task_struct *p, unsigned long clone_flags)
                        goto error_put;
        }
-        /* cache user_ns in cred.  Doesn't need a refcount because it will
-         * stay pinned by cred->user
-         */
-        new->user_ns = new->user->user_ns;
 #ifdef CONFIG_KEYS
        /* new threads get their own thread keyrings if their parent already
         * had one */
@@ -493,10 +498,10 @@ int commit_creds(struct cred *new)
        get_cred(new); /* we will require a ref for the subj creds too */
        /* dumpability changes */
-        if (old->euid != new->euid ||
+        if (!uid_eq(old->euid, new->euid) ||
-            old->egid != new->egid ||
+            !gid_eq(old->egid, new->egid) ||
-            old->fsuid != new->fsuid ||
+            !uid_eq(old->fsuid, new->fsuid) ||
-            old->fsgid != new->fsgid ||
+            !gid_eq(old->fsgid, new->fsgid) ||
            !cap_issubset(new->cap_permitted, old->cap_permitted)) {
                if (task->mm)
                        set_dumpable(task->mm, suid_dumpable);
@@ -505,9 +510,9 @@ int commit_creds(struct cred *new)
        }
        /* alter the thread keyring */
-        if (new->fsuid != old->fsuid)
+        if (!uid_eq(new->fsuid, old->fsuid))
                key_fsuid_changed(task);
-        if (new->fsgid != old->fsgid)
+        if (!gid_eq(new->fsgid, old->fsgid))
                key_fsgid_changed(task);
        /* do it
@@ -524,16 +529,16 @@ int commit_creds(struct cred *new)
        alter_cred_subscribers(old, -2);
        /* send notifications */
-        if (new->uid   != old->uid  ||
+        if (!uid_eq(new->uid,   old->uid)  ||
-            new->euid  != old->euid ||
+            !uid_eq(new->euid,  old->euid) ||
-            new->suid  != old->suid ||
+            !uid_eq(new->suid,  old->suid) ||
-            new->fsuid != old->fsuid)
+            !uid_eq(new->fsuid, old->fsuid))
                proc_id_connector(task, PROC_EVENT_UID);
-        if (new->gid   != old->gid  ||
+        if (!gid_eq(new->gid,   old->gid)  ||
-            new->egid  != old->egid ||
+            !gid_eq(new->egid,  old->egid) ||
-            new->sgid  != old->sgid ||
+            !gid_eq(new->sgid,  old->sgid) ||
-            new->fsgid != old->fsgid)
+            !gid_eq(new->fsgid, old->fsgid))
                proc_id_connector(task, PROC_EVENT_GID);
        /* release the old obj and subj refs both */
@@ -678,6 +683,7 @@ struct cred *prepare_kernel_cred(struct task_struct *daemon)
        atomic_set(&new->usage, 1);
        set_cred_subscribers(new, 0);
        get_uid(new->user);
+        get_user_ns(new->user_ns);
        get_group_info(new->group_info);
 #ifdef CONFIG_KEYS
diff --git a/kernel/exit.c b/kernel/exit.c
index d8bd3b425fa7..910a0716e17a 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -1214,7 +1214,7 @@ static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
        unsigned long state;
        int retval, status, traced;
        pid_t pid = task_pid_vnr(p);
-        uid_t uid = __task_cred(p)->uid;
+        uid_t uid = from_kuid_munged(current_user_ns(), __task_cred(p)->uid);
        struct siginfo __user *infop;
        if (!likely(wo->wo_flags & WEXITED))
@@ -1427,7 +1427,7 @@ static int wait_task_stopped(struct wait_opts *wo,
        if (!unlikely(wo->wo_flags & WNOWAIT))
                *p_code = 0;
-        uid = task_uid(p);
+        uid = from_kuid_munged(current_user_ns(), task_uid(p));
 unlock_sig:
        spin_unlock_irq(&p->sighand->siglock);
        if (!exit_code)
@@ -1500,7 +1500,7 @@ static int wait_task_continued(struct wait_opts *wo, struct task_struct *p)
        }
        if (!unlikely(wo->wo_flags & WNOWAIT))
                p->signal->flags &= ~SIGNAL_STOP_CONTINUED;
-        uid = task_uid(p);
+        uid = from_kuid_munged(current_user_ns(), task_uid(p));
        spin_unlock_irq(&p->sighand->siglock);
        pid = task_pid_vnr(p);
diff --git a/kernel/groups.c b/kernel/groups.c
index 99b53d1eb7ea..6b2588dd04ff 100644
--- a/kernel/groups.c
+++ b/kernel/groups.c
@@ -31,7 +31,7 @@ struct group_info *groups_alloc(int gidsetsize)
                group_info->blocks[0] = group_info->small_block;
        else {
                for (i = 0; i < nblocks; i++) {
-                        gid_t *b;
+                        kgid_t *b;
                        b = (void *)__get_free_page(GFP_USER);
                        if (!b)
                                goto out_undo_partial_alloc;
@@ -66,18 +66,15 @@ EXPORT_SYMBOL(groups_free);
 static int groups_to_user(gid_t __user *grouplist,
                          const struct group_info *group_info)
 {
+        struct user_namespace *user_ns = current_user_ns();
        int i;
        unsigned int count = group_info->ngroups;
-        for (i = 0; i < group_info->nblocks; i++) {
+        for (i = 0; i < count; i++) {
-                unsigned int cp_count = min(NGROUPS_PER_BLOCK, count);
+                gid_t gid;
-                unsigned int len = cp_count * sizeof(*grouplist);
+                gid = from_kgid_munged(user_ns, GROUP_AT(group_info, i));
+                if (put_user(gid, grouplist+i))
-                if (copy_to_user(grouplist, group_info->blocks[i], len))
                        return -EFAULT;
-                grouplist += NGROUPS_PER_BLOCK;
-                count -= cp_count;
        }
        return 0;
 }
@@ -86,18 +83,21 @@ static int groups_to_user(gid_t __user *grouplist,
 static int groups_from_user(struct group_info *group_info,
    gid_t __user *grouplist)
 {
+        struct user_namespace *user_ns = current_user_ns();
        int i;
        unsigned int count = group_info->ngroups;
-        for (i = 0; i < group_info->nblocks; i++) {
+        for (i = 0; i < count; i++) {
-                unsigned int cp_count = min(NGROUPS_PER_BLOCK, count);
+                gid_t gid;
-                unsigned int len = cp_count * sizeof(*grouplist);
+                kgid_t kgid;
+                if (get_user(gid, grouplist+i))
-                if (copy_from_user(group_info->blocks[i], grouplist, len))
                        return -EFAULT;
-                grouplist += NGROUPS_PER_BLOCK;
+                kgid = make_kgid(user_ns, gid);
-                count -= cp_count;
+                if (!gid_valid(kgid))
+                        return -EINVAL;
+                GROUP_AT(group_info, i) = kgid;
        }
        return 0;
 }
@@ -117,9 +117,9 @@ static void groups_sort(struct group_info *group_info)
                for (base = 0; base < max; base++) {
                        int left = base;
                        int right = left + stride;
-                        gid_t tmp = GROUP_AT(group_info, right);
+                        kgid_t tmp = GROUP_AT(group_info, right);
-                        while (left >= 0 && GROUP_AT(group_info, left) > tmp) {
+                        while (left >= 0 && gid_gt(GROUP_AT(group_info, left), tmp)) {
                                GROUP_AT(group_info, right) =
                                    GROUP_AT(group_info, left);
                                right = left;
@@ -132,7 +132,7 @@ static void groups_sort(struct group_info *group_info)
 }
 /* a simple bsearch */
-int groups_search(const struct group_info *group_info, gid_t grp)
+int groups_search(const struct group_info *group_info, kgid_t grp)
 {
        unsigned int left, right;
@@ -143,9 +143,9 @@ int groups_search(const struct group_info *group_info, gid_t grp)
        right = group_info->ngroups;
        while (left < right) {
                unsigned int mid = (left+right)/2;
-                if (grp > GROUP_AT(group_info, mid))
+                if (gid_gt(grp, GROUP_AT(group_info, mid)))
                        left = mid + 1;
-                else if (grp < GROUP_AT(group_info, mid))
+                else if (gid_lt(grp, GROUP_AT(group_info, mid)))
                        right = mid;
                else
                        return 1;
@@ -256,24 +256,24 @@ SYSCALL_DEFINE2(setgroups, int, gidsetsize, gid_t __user *, grouplist)
 /*
 * Check whether we're fsgid/egid or in the supplemental group..
 */
-int in_group_p(gid_t grp)
+int in_group_p(kgid_t grp)
 {
        const struct cred *cred = current_cred();
        int retval = 1;
-        if (grp != cred->fsgid)
+        if (!gid_eq(grp, cred->fsgid))
                retval = groups_search(cred->group_info, grp);
        return retval;
 }
 EXPORT_SYMBOL(in_group_p);
-int in_egroup_p(gid_t grp)
+int in_egroup_p(kgid_t grp)
 {
        const struct cred *cred = current_cred();
        int retval = 1;
-        if (grp != cred->egid)
+        if (!gid_eq(grp, cred->egid))
                retval = groups_search(cred->group_info, grp);
        return retval;
 }
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index ee8d49b9c309..a232bb59d93f 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -198,15 +198,14 @@ int __ptrace_may_access(struct task_struct *task, unsigned int mode)
                return 0;
        rcu_read_lock();
        tcred = __task_cred(task);
-        if (cred->user->user_ns == tcred->user->user_ns &&
+        if (uid_eq(cred->uid, tcred->euid) &&
-            (cred->uid == tcred->euid &&
+            uid_eq(cred->uid, tcred->suid) &&
-             cred->uid == tcred->suid &&
+            uid_eq(cred->uid, tcred->uid)  &&
-             cred->uid == tcred->uid  &&
+            gid_eq(cred->gid, tcred->egid) &&
-             cred->gid == tcred->egid &&
+            gid_eq(cred->gid, tcred->sgid) &&
-             cred->gid == tcred->sgid &&
+            gid_eq(cred->gid, tcred->gid))
-             cred->gid == tcred->gid))
                goto ok;
-        if (ptrace_has_cap(tcred->user->user_ns, mode))
+        if (ptrace_has_cap(tcred->user_ns, mode))
                goto ok;
        rcu_read_unlock();
        return -EPERM;
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index a5a9d39b845c..39eb6011bc38 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -4070,11 +4070,8 @@ static bool check_same_owner(struct task_struct *p)
        rcu_read_lock();
        pcred = __task_cred(p);
-        if (cred->user->user_ns == pcred->user->user_ns)
+        match = (uid_eq(cred->euid, pcred->euid) ||
-                match = (cred->euid == pcred->euid ||
+                 uid_eq(cred->euid, pcred->uid));
-                         cred->euid == pcred->uid);
-        else
-                match = false;
        rcu_read_unlock();
        return match;
 }
diff --git a/kernel/signal.c b/kernel/signal.c
index 1a006b5d9d9d..21ebe75ff85f 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -767,14 +767,13 @@ static int kill_ok_by_cred(struct task_struct *t)
        const struct cred *cred = current_cred();
        const struct cred *tcred = __task_cred(t);
-        if (cred->user->user_ns == tcred->user->user_ns &&
+        if (uid_eq(cred->euid, tcred->suid) ||
-            (cred->euid == tcred->suid ||
+            uid_eq(cred->euid, tcred->uid)  ||
-             cred->euid == tcred->uid ||
+            uid_eq(cred->uid,  tcred->suid) ||
-             cred->uid  == tcred->suid ||
+            uid_eq(cred->uid,  tcred->uid))
-             cred->uid  == tcred->uid))
                return 1;
-        if (ns_capable(tcred->user->user_ns, CAP_KILL))
+        if (ns_capable(tcred->user_ns, CAP_KILL))
                return 1;
        return 0;
@@ -1020,15 +1019,6 @@ static inline int legacy_queue(struct sigpending *signals, int sig)
        return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
 }
-/*
- * map the uid in struct cred into user namespace *ns
- */
-static inline uid_t map_cred_ns(const struct cred *cred,
-                                struct user_namespace *ns)
-{
-        return user_ns_map_uid(ns, cred, cred->uid);
-}
 #ifdef CONFIG_USER_NS
 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
 {
@@ -1038,8 +1028,10 @@ static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_str
        if (SI_FROMKERNEL(info))
                return;
-        info->si_uid = user_ns_map_uid(task_cred_xxx(t, user_ns),
+        rcu_read_lock();
-                                        current_cred(), info->si_uid);
+        info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns),
+                                        make_kuid(current_user_ns(), info->si_uid));
+        rcu_read_unlock();
 }
 #else
 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
@@ -1106,7 +1098,7 @@ static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
                        q->info.si_code = SI_USER;
                        q->info.si_pid = task_tgid_nr_ns(current,
                                                        task_active_pid_ns(t));
-                        q->info.si_uid = current_uid();
+                        q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
                        break;
                case (unsigned long) SEND_SIG_PRIV:
                        q->info.si_signo = sig;
@@ -1387,10 +1379,8 @@ static int kill_as_cred_perm(const struct cred *cred,
                             struct task_struct *target)
 {
        const struct cred *pcred = __task_cred(target);
-        if (cred->user_ns != pcred->user_ns)
+        if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) &&
-                return 0;
+            !uid_eq(cred->uid,  pcred->suid) && !uid_eq(cred->uid,  pcred->uid))
-        if (cred->euid != pcred->suid && cred->euid != pcred->uid &&
-            cred->uid  != pcred->suid && cred->uid  != pcred->uid)
                return 0;
        return 1;
 }
@@ -1678,8 +1668,8 @@ bool do_notify_parent(struct task_struct *tsk, int sig)
         */
        rcu_read_lock();
        info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
-        info.si_uid = map_cred_ns(__task_cred(tsk),
+        info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
-                        task_cred_xxx(tsk->parent, user_ns));
+                                       task_uid(tsk));
        rcu_read_unlock();
        info.si_utime = cputime_to_clock_t(tsk->utime + tsk->signal->utime);
@@ -1762,8 +1752,7 @@ static void do_notify_parent_cldstop(struct task_struct *tsk,
         */
        rcu_read_lock();
        info.si_pid = task_pid_nr_ns(tsk, parent->nsproxy->pid_ns);
-        info.si_uid = map_cred_ns(__task_cred(tsk),
+        info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
-                        task_cred_xxx(parent, user_ns));
        rcu_read_unlock();
        info.si_utime = cputime_to_clock_t(tsk->utime);
@@ -1973,7 +1962,7 @@ static void ptrace_do_notify(int signr, int exit_code, int why)
        info.si_signo = signr;
        info.si_code = exit_code;
        info.si_pid = task_pid_vnr(current);
-        info.si_uid = current_uid();
+        info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
        /* Let the debugger run.  */
        ptrace_stop(exit_code, why, 1, &info);
@@ -2181,8 +2170,8 @@ static int ptrace_signal(int signr, siginfo_t *info,
                info->si_code = SI_USER;
                rcu_read_lock();
                info->si_pid = task_pid_vnr(current->parent);
-                info->si_uid = map_cred_ns(__task_cred(current->parent),
+                info->si_uid = from_kuid_munged(current_user_ns(),
-                                current_user_ns());
+                                                task_uid(current->parent));
                rcu_read_unlock();
        }
@@ -2835,7 +2824,7 @@ SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
        info.si_errno = 0;
        info.si_code = SI_USER;
        info.si_pid = task_tgid_vnr(current);
-        info.si_uid = current_uid();
+        info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
        return kill_something_info(sig, &info, pid);
 }
@@ -2878,7 +2867,7 @@ static int do_tkill(pid_t tgid, pid_t pid, int sig)
        info.si_errno = 0;
        info.si_code = SI_TKILL;
        info.si_pid = task_tgid_vnr(current);
-        info.si_uid = current_uid();
+        info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
        return do_send_specific(tgid, pid, sig, &info);
 }
diff --git a/kernel/sys.c b/kernel/sys.c
index ba0ae8eea6fb..6df42624e454 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -93,10 +93,8 @@
 int overflowuid = DEFAULT_OVERFLOWUID;
 int overflowgid = DEFAULT_OVERFLOWGID;
-#ifdef CONFIG_UID16
 EXPORT_SYMBOL(overflowuid);
 EXPORT_SYMBOL(overflowgid);
-#endif
 /*
 * the same as above, but for filesystems which can only store a 16-bit
@@ -133,11 +131,10 @@ static bool set_one_prio_perm(struct task_struct *p)
 {
        const struct cred *cred = current_cred(), *pcred = __task_cred(p);
-        if (pcred->user->user_ns == cred->user->user_ns &&
+        if (uid_eq(pcred->uid,  cred->euid) ||
-            (pcred->uid  == cred->euid ||
+            uid_eq(pcred->euid, cred->euid))
-             pcred->euid == cred->euid))
                return true;
-        if (ns_capable(pcred->user->user_ns, CAP_SYS_NICE))
+        if (ns_capable(pcred->user_ns, CAP_SYS_NICE))
                return true;
        return false;
 }
@@ -177,6 +174,7 @@ SYSCALL_DEFINE3(setpriority, int, which, int, who, int, niceval)
        const struct cred *cred = current_cred();
        int error = -EINVAL;
        struct pid *pgrp;
+        kuid_t uid;
        if (which > PRIO_USER || which < PRIO_PROCESS)
                goto out;
@@ -209,18 +207,19 @@ SYSCALL_DEFINE3(setpriority, int, which, int, who, int, niceval)
                        } while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
                        break;
                case PRIO_USER:
-                        user = (struct user_struct *) cred->user;
+                        uid = make_kuid(cred->user_ns, who);
+                        user = cred->user;
                        if (!who)
-                                who = cred->uid;
+                                uid = cred->uid;
-                        else if ((who != cred->uid) &&
+                        else if (!uid_eq(uid, cred->uid) &&
-                                 !(user = find_user(who)))
+                                 !(user = find_user(uid)))
                                goto out_unlock;        /* No processes for this user */
                        do_each_thread(g, p) {
-                                if (__task_cred(p)->uid == who)
+                                if (uid_eq(task_uid(p), uid))
                                        error = set_one_prio(p, niceval, error);
                        } while_each_thread(g, p);
-                        if (who != cred->uid)
+                        if (!uid_eq(uid, cred->uid))
                                free_uid(user);         /* For find_user() */
                        break;
        }
@@ -244,6 +243,7 @@ SYSCALL_DEFINE2(getpriority, int, which, int, who)
        const struct cred *cred = current_cred();
        long niceval, retval = -ESRCH;
        struct pid *pgrp;
+        kuid_t uid;
        if (which > PRIO_USER || which < PRIO_PROCESS)
                return -EINVAL;
@@ -274,21 +274,22 @@ SYSCALL_DEFINE2(getpriority, int, which, int, who)
                        } while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
                        break;
                case PRIO_USER:
-                        user = (struct user_struct *) cred->user;
+                        uid = make_kuid(cred->user_ns, who);
+                        user = cred->user;
                        if (!who)
-                                who = cred->uid;
+                                uid = cred->uid;
-                        else if ((who != cred->uid) &&
+                        else if (!uid_eq(uid, cred->uid) &&
-                                 !(user = find_user(who)))
+                                 !(user = find_user(uid)))
                                goto out_unlock;        /* No processes for this user */
                        do_each_thread(g, p) {
-                                if (__task_cred(p)->uid == who) {
+                                if (uid_eq(task_uid(p), uid)) {
                                        niceval = 20 - task_nice(p);
                                        if (niceval > retval)
                                                retval = niceval;
                                }
                        } while_each_thread(g, p);
-                        if (who != cred->uid)
+                        if (!uid_eq(uid, cred->uid))
                                free_uid(user);         /* for find_user() */
                        break;
        }
@@ -553,9 +554,19 @@ void ctrl_alt_del(void)
 */
 SYSCALL_DEFINE2(setregid, gid_t, rgid, gid_t, egid)
 {
+        struct user_namespace *ns = current_user_ns();
        const struct cred *old;
        struct cred *new;
        int retval;
+        kgid_t krgid, kegid;
+        krgid = make_kgid(ns, rgid);
+        kegid = make_kgid(ns, egid);
+        if ((rgid != (gid_t) -1) && !gid_valid(krgid))
+                return -EINVAL;
+        if ((egid != (gid_t) -1) && !gid_valid(kegid))
+                return -EINVAL;
        new = prepare_creds();
        if (!new)
@@ -564,25 +575,25 @@ SYSCALL_DEFINE2(setregid, gid_t, rgid, gid_t, egid)
        retval = -EPERM;
        if (rgid != (gid_t) -1) {
-                if (old->gid == rgid ||
+                if (gid_eq(old->gid, krgid) ||
-                    old->egid == rgid ||
+                    gid_eq(old->egid, krgid) ||
                    nsown_capable(CAP_SETGID))
-                        new->gid = rgid;
+                        new->gid = krgid;
                else
                        goto error;
        }
        if (egid != (gid_t) -1) {
-                if (old->gid == egid ||
+                if (gid_eq(old->gid, kegid) ||
-                    old->egid == egid ||
+                    gid_eq(old->egid, kegid) ||
-                    old->sgid == egid ||
+                    gid_eq(old->sgid, kegid) ||
                    nsown_capable(CAP_SETGID))
-                        new->egid = egid;
+                        new->egid = kegid;
                else
                        goto error;
        }
        if (rgid != (gid_t) -1 ||
-            (egid != (gid_t) -1 && egid != old->gid))
+            (egid != (gid_t) -1 && !gid_eq(kegid, old->gid)))
                new->sgid = new->egid;
        new->fsgid = new->egid;
@@ -600,9 +611,15 @@ error:
 */
 SYSCALL_DEFINE1(setgid, gid_t, gid)
 {
+        struct user_namespace *ns = current_user_ns();
        const struct cred *old;
        struct cred *new;
        int retval;
+        kgid_t kgid;
+        kgid = make_kgid(ns, gid);
+        if (!gid_valid(kgid))
+                return -EINVAL;
        new = prepare_creds();
        if (!new)
@@ -611,9 +628,9 @@ SYSCALL_DEFINE1(setgid, gid_t, gid)
        retval = -EPERM;
        if (nsown_capable(CAP_SETGID))
-                new->gid = new->egid = new->sgid = new->fsgid = gid;
+                new->gid = new->egid = new->sgid = new->fsgid = kgid;
-        else if (gid == old->gid || gid == old->sgid)
+        else if (gid_eq(kgid, old->gid) || gid_eq(kgid, old->sgid))
-                new->egid = new->fsgid = gid;
+                new->egid = new->fsgid = kgid;
        else
                goto error;
@@ -631,7 +648,7 @@ static int set_user(struct cred *new)
 {
        struct user_struct *new_user;
-        new_user = alloc_uid(current_user_ns(), new->uid);
+        new_user = alloc_uid(new->uid);
        if (!new_user)
                return -EAGAIN;
@@ -670,9 +687,19 @@ static int set_user(struct cred *new)
 */
 SYSCALL_DEFINE2(setreuid, uid_t, ruid, uid_t, euid)
 {
+        struct user_namespace *ns = current_user_ns();
        const struct cred *old;
        struct cred *new;
        int retval;
+        kuid_t kruid, keuid;
+        kruid = make_kuid(ns, ruid);
+        keuid = make_kuid(ns, euid);
+        if ((ruid != (uid_t) -1) && !uid_valid(kruid))
+                return -EINVAL;
+        if ((euid != (uid_t) -1) && !uid_valid(keuid))
+                return -EINVAL;
        new = prepare_creds();
        if (!new)
@@ -681,29 +708,29 @@ SYSCALL_DEFINE2(setreuid, uid_t, ruid, uid_t, euid)
        retval = -EPERM;
        if (ruid != (uid_t) -1) {
-                new->uid = ruid;
+                new->uid = kruid;
-                if (old->uid != ruid &&
+                if (!uid_eq(old->uid, kruid) &&
-                    old->euid != ruid &&
+                    !uid_eq(old->euid, kruid) &&
                    !nsown_capable(CAP_SETUID))
                        goto error;
        }
        if (euid != (uid_t) -1) {
-                new->euid = euid;
+                new->euid = keuid;
-                if (old->uid != euid &&
+                if (!uid_eq(old->uid, keuid) &&
-                    old->euid != euid &&
+                    !uid_eq(old->euid, keuid) &&
-                    old->suid != euid &&
+                    !uid_eq(old->suid, keuid) &&
                    !nsown_capable(CAP_SETUID))
                        goto error;
        }
-        if (new->uid != old->uid) {
+        if (!uid_eq(new->uid, old->uid)) {
                retval = set_user(new);
                if (retval < 0)
                        goto error;
        }
        if (ruid != (uid_t) -1 ||
-            (euid != (uid_t) -1 && euid != old->uid))
+            (euid != (uid_t) -1 && !uid_eq(keuid, old->uid)))
                new->suid = new->euid;
        new->fsuid = new->euid;
@@ -731,9 +758,15 @@ error:
 */
 SYSCALL_DEFINE1(setuid, uid_t, uid)
 {
+        struct user_namespace *ns = current_user_ns();
        const struct cred *old;
        struct cred *new;
        int retval;
+        kuid_t kuid;
+        kuid = make_kuid(ns, uid);
+        if (!uid_valid(kuid))
+                return -EINVAL;
        new = prepare_creds();
        if (!new)
@@ -742,17 +775,17 @@ SYSCALL_DEFINE1(setuid, uid_t, uid)
        retval = -EPERM;
        if (nsown_capable(CAP_SETUID)) {
-                new->suid = new->uid = uid;
+                new->suid = new->uid = kuid;
-                if (uid != old->uid) {
+                if (!uid_eq(kuid, old->uid)) {
                        retval = set_user(new);
                        if (retval < 0)
                                goto error;
                }
-        } else if (uid != old->uid && uid != new->suid) {
+        } else if (!uid_eq(kuid, old->uid) && !uid_eq(kuid, new->suid)) {
                goto error;
        }
-        new->fsuid = new->euid = uid;
+        new->fsuid = new->euid = kuid;
        retval = security_task_fix_setuid(new, old, LSM_SETID_ID);
        if (retval < 0)
@@ -772,9 +805,24 @@ error:
 */
 SYSCALL_DEFINE3(setresuid, uid_t, ruid, uid_t, euid, uid_t, suid)
 {
+        struct user_namespace *ns = current_user_ns();
        const struct cred *old;
        struct cred *new;
        int retval;
+        kuid_t kruid, keuid, ksuid;
+        kruid = make_kuid(ns, ruid);
+        keuid = make_kuid(ns, euid);
+        ksuid = make_kuid(ns, suid);
+        if ((ruid != (uid_t) -1) && !uid_valid(kruid))
+                return -EINVAL;
+        if ((euid != (uid_t) -1) && !uid_valid(keuid))
+                return -EINVAL;
+        if ((suid != (uid_t) -1) && !uid_valid(ksuid))
+                return -EINVAL;
        new = prepare_creds();
        if (!new)
@@ -784,29 +832,29 @@ SYSCALL_DEFINE3(setresuid, uid_t, ruid, uid_t, euid, uid_t, suid)
        retval = -EPERM;
        if (!nsown_capable(CAP_SETUID)) {
-                if (ruid != (uid_t) -1 && ruid != old->uid &&
+                if (ruid != (uid_t) -1        && !uid_eq(kruid, old->uid) &&
-                    ruid != old->euid  && ruid != old->suid)
+                    !uid_eq(kruid, old->euid) && !uid_eq(kruid, old->suid))
                        goto error;
-                if (euid != (uid_t) -1 && euid != old->uid &&
+                if (euid != (uid_t) -1        && !uid_eq(keuid, old->uid) &&
-                    euid != old->euid  && euid != old->suid)
+                    !uid_eq(keuid, old->euid) && !uid_eq(keuid, old->suid))
                        goto error;
-                if (suid != (uid_t) -1 && suid != old->uid &&
+                if (suid != (uid_t) -1        && !uid_eq(ksuid, old->uid) &&
-                    suid != old->euid  && suid != old->suid)
+                    !uid_eq(ksuid, old->euid) && !uid_eq(ksuid, old->suid))
                        goto error;
        }
        if (ruid != (uid_t) -1) {
-                new->uid = ruid;
+                new->uid = kruid;
-                if (ruid != old->uid) {
+                if (!uid_eq(kruid, old->uid)) {
                        retval = set_user(new);
                        if (retval < 0)
                                goto error;
                }
        }
        if (euid != (uid_t) -1)
-                new->euid = euid;
+                new->euid = keuid;
        if (suid != (uid_t) -1)
-                new->suid = suid;
+                new->suid = ksuid;
        new->fsuid = new->euid;
        retval = security_task_fix_setuid(new, old, LSM_SETID_RES);
@@ -820,14 +868,19 @@ error:
        return retval;
 }
-SYSCALL_DEFINE3(getresuid, uid_t __user *, ruid, uid_t __user *, euid, uid_t __user *, suid)
+SYSCALL_DEFINE3(getresuid, uid_t __user *, ruidp, uid_t __user *, euidp, uid_t __user *, suidp)
 {
        const struct cred *cred = current_cred();
        int retval;
+        uid_t ruid, euid, suid;
+        ruid = from_kuid_munged(cred->user_ns, cred->uid);
+        euid = from_kuid_munged(cred->user_ns, cred->euid);
+        suid = from_kuid_munged(cred->user_ns, cred->suid);
-        if (!(retval   = put_user(cred->uid,  ruid)) &&
+        if (!(retval   = put_user(ruid, ruidp)) &&
-            !(retval   = put_user(cred->euid, euid)))
+            !(retval   = put_user(euid, euidp)))
-                retval = put_user(cred->suid, suid);
+                retval = put_user(suid, suidp);
        return retval;
 }
@@ -837,9 +890,22 @@ SYSCALL_DEFINE3(getresuid, uid_t __user *, ruid, uid_t __user *, euid, uid_t __u
 */
 SYSCALL_DEFINE3(setresgid, gid_t, rgid, gid_t, egid, gid_t, sgid)
 {
+        struct user_namespace *ns = current_user_ns();
        const struct cred *old;
        struct cred *new;
        int retval;
+        kgid_t krgid, kegid, ksgid;
+        krgid = make_kgid(ns, rgid);
+        kegid = make_kgid(ns, egid);
+        ksgid = make_kgid(ns, sgid);
+        if ((rgid != (gid_t) -1) && !gid_valid(krgid))
+                return -EINVAL;
+        if ((egid != (gid_t) -1) && !gid_valid(kegid))
+                return -EINVAL;
+        if ((sgid != (gid_t) -1) && !gid_valid(ksgid))
+                return -EINVAL;
        new = prepare_creds();
        if (!new)
@@ -848,23 +914,23 @@ SYSCALL_DEFINE3(setresgid, gid_t, rgid, gid_t, egid, gid_t, sgid)
        retval = -EPERM;
        if (!nsown_capable(CAP_SETGID)) {
-                if (rgid != (gid_t) -1 && rgid != old->gid &&
+                if (rgid != (gid_t) -1        && !gid_eq(krgid, old->gid) &&
-                    rgid != old->egid  && rgid != old->sgid)
+                    !gid_eq(krgid, old->egid) && !gid_eq(krgid, old->sgid))
                        goto error;
-                if (egid != (gid_t) -1 && egid != old->gid &&
+                if (egid != (gid_t) -1        && !gid_eq(kegid, old->gid) &&
-                    egid != old->egid  && egid != old->sgid)
+                    !gid_eq(kegid, old->egid) && !gid_eq(kegid, old->sgid))
                        goto error;
-                if (sgid != (gid_t) -1 && sgid != old->gid &&
+                if (sgid != (gid_t) -1        && !gid_eq(ksgid, old->gid) &&
-                    sgid != old->egid  && sgid != old->sgid)
+                    !gid_eq(ksgid, old->egid) && !gid_eq(ksgid, old->sgid))
                        goto error;
        }
        if (rgid != (gid_t) -1)
-                new->gid = rgid;
+                new->gid = krgid;
        if (egid != (gid_t) -1)
-                new->egid = egid;
+                new->egid = kegid;
        if (sgid != (gid_t) -1)
-                new->sgid = sgid;
+                new->sgid = ksgid;
        new->fsgid = new->egid;
        return commit_creds(new);
@@ -874,14 +940,19 @@ error:
        return retval;
 }
-SYSCALL_DEFINE3(getresgid, gid_t __user *, rgid, gid_t __user *, egid, gid_t __user *, sgid)
+SYSCALL_DEFINE3(getresgid, gid_t __user *, rgidp, gid_t __user *, egidp, gid_t __user *, sgidp)
 {
        const struct cred *cred = current_cred();
        int retval;
+        gid_t rgid, egid, sgid;
+        rgid = from_kgid_munged(cred->user_ns, cred->gid);
+        egid = from_kgid_munged(cred->user_ns, cred->egid);
+        sgid = from_kgid_munged(cred->user_ns, cred->sgid);
-        if (!(retval   = put_user(cred->gid,  rgid)) &&
+        if (!(retval   = put_user(rgid, rgidp)) &&
-            !(retval   = put_user(cred->egid, egid)))
+            !(retval   = put_user(egid, egidp)))
-                retval = put_user(cred->sgid, sgid);
+                retval = put_user(sgid, sgidp);
        return retval;
 }
@@ -898,18 +969,24 @@ SYSCALL_DEFINE1(setfsuid, uid_t, uid)
        const struct cred *old;
        struct cred *new;
        uid_t old_fsuid;
+        kuid_t kuid;
+        old = current_cred();
+        old_fsuid = from_kuid_munged(old->user_ns, old->fsuid);
+        kuid = make_kuid(old->user_ns, uid);
+        if (!uid_valid(kuid))
+                return old_fsuid;
        new = prepare_creds();
        if (!new)
-                return current_fsuid();
+                return old_fsuid;
-        old = current_cred();
-        old_fsuid = old->fsuid;
-        if (uid == old->uid  || uid == old->euid  ||
+        if (uid_eq(kuid, old->uid)  || uid_eq(kuid, old->euid)  ||
-            uid == old->suid || uid == old->fsuid ||
+            uid_eq(kuid, old->suid) || uid_eq(kuid, old->fsuid) ||
            nsown_capable(CAP_SETUID)) {
-                if (uid != old_fsuid) {
+                if (!uid_eq(kuid, old->fsuid)) {
-                        new->fsuid = uid;
+                        new->fsuid = kuid;
                        if (security_task_fix_setuid(new, old, LSM_SETID_FS) == 0)
                                goto change_okay;
                }
@@ -931,18 +1008,24 @@ SYSCALL_DEFINE1(setfsgid, gid_t, gid)
        const struct cred *old;
        struct cred *new;
        gid_t old_fsgid;
+        kgid_t kgid;
+        old = current_cred();
+        old_fsgid = from_kgid_munged(old->user_ns, old->fsgid);
+        kgid = make_kgid(old->user_ns, gid);
+        if (!gid_valid(kgid))
+                return old_fsgid;
        new = prepare_creds();
        if (!new)
-                return current_fsgid();
+                return old_fsgid;
-        old = current_cred();
-        old_fsgid = old->fsgid;
-        if (gid == old->gid  || gid == old->egid  ||
+        if (gid_eq(kgid, old->gid)  || gid_eq(kgid, old->egid)  ||
-            gid == old->sgid || gid == old->fsgid ||
+            gid_eq(kgid, old->sgid) || gid_eq(kgid, old->fsgid) ||
            nsown_capable(CAP_SETGID)) {
-                if (gid != old_fsgid) {
+                if (!gid_eq(kgid, old->fsgid)) {
-                        new->fsgid = gid;
+                        new->fsgid = kgid;
                        goto change_okay;
                }
        }
@@ -1498,15 +1581,14 @@ static int check_prlimit_permission(struct task_struct *task)
                return 0;
        tcred = __task_cred(task);
-        if (cred->user->user_ns == tcred->user->user_ns &&
+        if (uid_eq(cred->uid, tcred->euid) &&
-            (cred->uid == tcred->euid &&
+            uid_eq(cred->uid, tcred->suid) &&
-             cred->uid == tcred->suid &&
+            uid_eq(cred->uid, tcred->uid)  &&
-             cred->uid == tcred->uid  &&
+            gid_eq(cred->gid, tcred->egid) &&
-             cred->gid == tcred->egid &&
+            gid_eq(cred->gid, tcred->sgid) &&
-             cred->gid == tcred->sgid &&
+            gid_eq(cred->gid, tcred->gid))
-             cred->gid == tcred->gid))
                return 0;
-        if (ns_capable(tcred->user->user_ns, CAP_SYS_RESOURCE))
+        if (ns_capable(tcred->user_ns, CAP_SYS_RESOURCE))
                return 0;
        return -EPERM;
diff --git a/kernel/timer.c b/kernel/timer.c
index 09de9a941cd7..6ec7e7e0db43 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -1435,25 +1435,25 @@ SYSCALL_DEFINE0(getppid)
 SYSCALL_DEFINE0(getuid)
 {
        /* Only we change this so SMP safe */
-        return current_uid();
+        return from_kuid_munged(current_user_ns(), current_uid());
 }
 SYSCALL_DEFINE0(geteuid)
 {
        /* Only we change this so SMP safe */
-        return current_euid();
+        return from_kuid_munged(current_user_ns(), current_euid());
 }
 SYSCALL_DEFINE0(getgid)
 {
        /* Only we change this so SMP safe */
-        return current_gid();
+        return from_kgid_munged(current_user_ns(), current_gid());
 }
 SYSCALL_DEFINE0(getegid)
 {
        /* Only we change this so SMP safe */
-        return  current_egid();
+        return from_kgid_munged(current_user_ns(), current_egid());
 }
 #endif
diff --git a/kernel/uid16.c b/kernel/uid16.c
index 51c6e89e8619..d7948eb10225 100644
--- a/kernel/uid16.c
+++ b/kernel/uid16.c
@@ -81,14 +81,19 @@ SYSCALL_DEFINE3(setresuid16, old_uid_t, ruid, old_uid_t, euid, old_uid_t, suid)
        return ret;
 }
-SYSCALL_DEFINE3(getresuid16, old_uid_t __user *, ruid, old_uid_t __user *, euid, old_uid_t __user *, suid)
+SYSCALL_DEFINE3(getresuid16, old_uid_t __user *, ruidp, old_uid_t __user *, euidp, old_uid_t __user *, suidp)
 {
        const struct cred *cred = current_cred();
        int retval;
+        old_uid_t ruid, euid, suid;
-        if (!(retval   = put_user(high2lowuid(cred->uid),  ruid)) &&
+        ruid = high2lowuid(from_kuid_munged(cred->user_ns, cred->uid));
-            !(retval   = put_user(high2lowuid(cred->euid), euid)))
+        euid = high2lowuid(from_kuid_munged(cred->user_ns, cred->euid));
-                retval = put_user(high2lowuid(cred->suid), suid);
+        suid = high2lowuid(from_kuid_munged(cred->user_ns, cred->suid));
+        if (!(retval   = put_user(ruid, ruidp)) &&
+            !(retval   = put_user(euid, euidp)))
+                retval = put_user(suid, suidp);
        return retval;
 }
@@ -103,14 +108,19 @@ SYSCALL_DEFINE3(setresgid16, old_gid_t, rgid, old_gid_t, egid, old_gid_t, sgid)
 }
-SYSCALL_DEFINE3(getresgid16, old_gid_t __user *, rgid, old_gid_t __user *, egid, old_gid_t __user *, sgid)
+SYSCALL_DEFINE3(getresgid16, old_gid_t __user *, rgidp, old_gid_t __user *, egidp, old_gid_t __user *, sgidp)
 {
        const struct cred *cred = current_cred();
        int retval;
+        old_gid_t rgid, egid, sgid;
+        rgid = high2lowgid(from_kgid_munged(cred->user_ns, cred->gid));
+        egid = high2lowgid(from_kgid_munged(cred->user_ns, cred->egid));
+        sgid = high2lowgid(from_kgid_munged(cred->user_ns, cred->sgid));
-        if (!(retval   = put_user(high2lowgid(cred->gid),  rgid)) &&
+        if (!(retval   = put_user(rgid, rgidp)) &&
-            !(retval   = put_user(high2lowgid(cred->egid), egid)))
+            !(retval   = put_user(egid, egidp)))
-                retval = put_user(high2lowgid(cred->sgid), sgid);
+                retval = put_user(sgid, sgidp);
        return retval;
 }
@@ -134,11 +144,14 @@ SYSCALL_DEFINE1(setfsgid16, old_gid_t, gid)
 static int groups16_to_user(old_gid_t __user *grouplist,
    struct group_info *group_info)
 {
+        struct user_namespace *user_ns = current_user_ns();
        int i;
        old_gid_t group;
+        kgid_t kgid;
        for (i = 0; i < group_info->ngroups; i++) {
-                group = high2lowgid(GROUP_AT(group_info, i));
+                kgid = GROUP_AT(group_info, i);
+                group = high2lowgid(from_kgid_munged(user_ns, kgid));
                if (put_user(group, grouplist+i))
                        return -EFAULT;
        }
@@ -149,13 +162,20 @@ static int groups16_to_user(old_gid_t __user *grouplist,
 static int groups16_from_user(struct group_info *group_info,
    old_gid_t __user *grouplist)
 {
+        struct user_namespace *user_ns = current_user_ns();
        int i;
        old_gid_t group;
+        kgid_t kgid;
        for (i = 0; i < group_info->ngroups; i++) {
                if (get_user(group, grouplist+i))
                        return  -EFAULT;
-                GROUP_AT(group_info, i) = low2highgid(group);
+                kgid = make_kgid(user_ns, low2highgid(group));
+                if (!gid_valid(kgid))
+                        return -EINVAL;
+                GROUP_AT(group_info, i) = kgid;
        }
        return 0;
@@ -211,20 +231,20 @@ SYSCALL_DEFINE2(setgroups16, int, gidsetsize, old_gid_t __user *, grouplist)
 SYSCALL_DEFINE0(getuid16)
 {
-        return high2lowuid(current_uid());
+        return high2lowuid(from_kuid_munged(current_user_ns(), current_uid()));
 }
 SYSCALL_DEFINE0(geteuid16)
 {
-        return high2lowuid(current_euid());
+        return high2lowuid(from_kuid_munged(current_user_ns(), current_euid()));
 }
 SYSCALL_DEFINE0(getgid16)
 {
-        return high2lowgid(current_gid());
+        return high2lowgid(from_kgid_munged(current_user_ns(), current_gid()));
 }
 SYSCALL_DEFINE0(getegid16)
 {
-        return high2lowgid(current_egid());
+        return high2lowgid(from_kgid_munged(current_user_ns(), current_egid()));
 }
diff --git a/kernel/user.c b/kernel/user.c
index 71dd2363ab0f..b815fefbe76f 100644
--- a/kernel/user.c
+++ b/kernel/user.c
@@ -22,10 +22,27 @@
 * and 1 for... ?
 */
 struct user_namespace init_user_ns = {
+        .uid_map = {
+                .nr_extents = 1,
+                .extent[0] = {
+                        .first = 0,
+                        .lower_first = 0,
+                        .count = 4294967295U,
+                },
+        },
+        .gid_map = {
+                .nr_extents = 1,
+                .extent[0] = {
+                        .first = 0,
+                        .lower_first = 0,
+                        .count = 4294967295U,
+                },
+        },
        .kref = {
                .refcount       = ATOMIC_INIT(3),
        },
-        .creator = &root_user,
+        .owner = GLOBAL_ROOT_UID,
+        .group = GLOBAL_ROOT_GID,
 };
 EXPORT_SYMBOL_GPL(init_user_ns);
@@ -34,11 +51,14 @@ EXPORT_SYMBOL_GPL(init_user_ns);
 * when changing user ID's (ie setuid() and friends).
 */
+#define UIDHASH_BITS    (CONFIG_BASE_SMALL ? 3 : 7)
+#define UIDHASH_SZ      (1 << UIDHASH_BITS)
 #define UIDHASH_MASK            (UIDHASH_SZ - 1)
 #define __uidhashfn(uid)        (((uid >> UIDHASH_BITS) + uid) & UIDHASH_MASK)
-#define uidhashentry(ns, uid)   ((ns)->uidhash_table + __uidhashfn((uid)))
+#define uidhashentry(uid)       (uidhash_table + __uidhashfn((__kuid_val(uid))))
 static struct kmem_cache *uid_cachep;
+struct hlist_head uidhash_table[UIDHASH_SZ];
 /*
 * The uidhash_lock is mostly taken from process context, but it is
@@ -51,14 +71,14 @@ static struct kmem_cache *uid_cachep;
 */
 static DEFINE_SPINLOCK(uidhash_lock);
-/* root_user.__count is 2, 1 for init task cred, 1 for init_user_ns->user_ns */
+/* root_user.__count is 1, for init task cred */
 struct user_struct root_user = {
-        .__count        = ATOMIC_INIT(2),
+        .__count        = ATOMIC_INIT(1),
        .processes      = ATOMIC_INIT(1),
        .files          = ATOMIC_INIT(0),
        .sigpending     = ATOMIC_INIT(0),
        .locked_shm     = 0,
-        .user_ns        = &init_user_ns,
+        .uid            = GLOBAL_ROOT_UID,
 };
 /*
@@ -72,16 +92,15 @@ static void uid_hash_insert(struct user_struct *up, struct hlist_head *hashent)
 static void uid_hash_remove(struct user_struct *up)
 {
        hlist_del_init(&up->uidhash_node);
-        put_user_ns(up->user_ns);
 }
-static struct user_struct *uid_hash_find(uid_t uid, struct hlist_head *hashent)
+static struct user_struct *uid_hash_find(kuid_t uid, struct hlist_head *hashent)
 {
        struct user_struct *user;
        struct hlist_node *h;
        hlist_for_each_entry(user, h, hashent, uidhash_node) {
-                if (user->uid == uid) {
+                if (uid_eq(user->uid, uid)) {
                        atomic_inc(&user->__count);
                        return user;
                }
@@ -110,14 +129,13 @@ static void free_user(struct user_struct *up, unsigned long flags)
 *
 * If the user_struct could not be found, return NULL.
 */
-struct user_struct *find_user(uid_t uid)
+struct user_struct *find_user(kuid_t uid)
 {
        struct user_struct *ret;
        unsigned long flags;
-        struct user_namespace *ns = current_user_ns();
        spin_lock_irqsave(&uidhash_lock, flags);
-        ret = uid_hash_find(uid, uidhashentry(ns, uid));
+        ret = uid_hash_find(uid, uidhashentry(uid));
        spin_unlock_irqrestore(&uidhash_lock, flags);
        return ret;
 }
@@ -136,9 +154,9 @@ void free_uid(struct user_struct *up)
                local_irq_restore(flags);
 }
-struct user_struct *alloc_uid(struct user_namespace *ns, uid_t uid)
+struct user_struct *alloc_uid(kuid_t uid)
 {
-        struct hlist_head *hashent = uidhashentry(ns, uid);
+        struct hlist_head *hashent = uidhashentry(uid);
        struct user_struct *up, *new;
        spin_lock_irq(&uidhash_lock);
@@ -153,8 +171,6 @@ struct user_struct *alloc_uid(struct user_namespace *ns, uid_t uid)
                new->uid = uid;
                atomic_set(&new->__count, 1);
-                new->user_ns = get_user_ns(ns);
                /*
                 * Before adding this, check whether we raced
                 * on adding the same user already..
@@ -162,7 +178,6 @@ struct user_struct *alloc_uid(struct user_namespace *ns, uid_t uid)
                spin_lock_irq(&uidhash_lock);
                up = uid_hash_find(uid, hashent);
                if (up) {
-                        put_user_ns(ns);
                        key_put(new->uid_keyring);
                        key_put(new->session_keyring);
                        kmem_cache_free(uid_cachep, new);
@@ -187,11 +202,11 @@ static int __init uid_cache_init(void)
                        0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
        for(n = 0; n < UIDHASH_SZ; ++n)
-                INIT_HLIST_HEAD(init_user_ns.uidhash_table + n);
+                INIT_HLIST_HEAD(uidhash_table + n);
        /* Insert the root user immediately (init already runs as root) */
        spin_lock_irq(&uidhash_lock);
-        uid_hash_insert(&root_user, uidhashentry(&init_user_ns, 0));
+        uid_hash_insert(&root_user, uidhashentry(GLOBAL_ROOT_UID));
        spin_unlock_irq(&uidhash_lock);
        return 0;
diff --git a/kernel/user_namespace.c b/kernel/user_namespace.c
index 3b906e98b1db..86602316422d 100644
--- a/kernel/user_namespace.c
+++ b/kernel/user_namespace.c
@@ -11,9 +11,20 @@
 #include <linux/user_namespace.h>
 #include <linux/highuid.h>
 #include <linux/cred.h>
+#include <linux/securebits.h>
+#include <linux/keyctl.h>
+#include <linux/key-type.h>
+#include <keys/user-type.h>
+#include <linux/seq_file.h>
+#include <linux/fs.h>
+#include <linux/uaccess.h>
+#include <linux/ctype.h>
 static struct kmem_cache *user_ns_cachep __read_mostly;
+static bool new_idmap_permitted(struct user_namespace *ns, int cap_setid,
+                                struct uid_gid_map *map);
 /*
 * Create a new user namespace, deriving the creator from the user in the
 * passed credentials, and replacing that user with the new root user for the
@@ -24,109 +35,565 @@ static struct kmem_cache *user_ns_cachep __read_mostly;
 */
 int create_user_ns(struct cred *new)
 {
-        struct user_namespace *ns;
+        struct user_namespace *ns, *parent_ns = new->user_ns;
-        struct user_struct *root_user;
+        kuid_t owner = new->euid;
-        int n;
+        kgid_t group = new->egid;
+        /* The creator needs a mapping in the parent user namespace
+         * or else we won't be able to reasonably tell userspace who
+         * created a user_namespace.
+         */
+        if (!kuid_has_mapping(parent_ns, owner) ||
+            !kgid_has_mapping(parent_ns, group))
+                return -EPERM;
-        ns = kmem_cache_alloc(user_ns_cachep, GFP_KERNEL);
+        ns = kmem_cache_zalloc(user_ns_cachep, GFP_KERNEL);
        if (!ns)
                return -ENOMEM;
        kref_init(&ns->kref);
+        ns->parent = parent_ns;
+        ns->owner = owner;
+        ns->group = group;
-        for (n = 0; n < UIDHASH_SZ; ++n)
+        /* Start with the same capabilities as init but useless for doing
-                INIT_HLIST_HEAD(ns->uidhash_table + n);
+         * anything as the capabilities are bound to the new user namespace.
+         */
-        /* Alloc new root user.  */
+        new->securebits = SECUREBITS_DEFAULT;
-        root_user = alloc_uid(ns, 0);
+        new->cap_inheritable = CAP_EMPTY_SET;
-        if (!root_user) {
+        new->cap_permitted = CAP_FULL_SET;
-                kmem_cache_free(user_ns_cachep, ns);
+        new->cap_effective = CAP_FULL_SET;
-                return -ENOMEM;
+        new->cap_bset = CAP_FULL_SET;
-        }
-        /* set the new root user in the credentials under preparation */
-        ns->creator = new->user;
-        new->user = root_user;
-        new->uid = new->euid = new->suid = new->fsuid = 0;
-        new->gid = new->egid = new->sgid = new->fsgid = 0;
-        put_group_info(new->group_info);
-        new->group_info = get_group_info(&init_groups);
 #ifdef CONFIG_KEYS
        key_put(new->request_key_auth);
        new->request_key_auth = NULL;
 #endif
        /* tgcred will be cleared in our caller bc CLONE_THREAD won't be set */
-        /* root_user holds a reference to ns, our reference can be dropped */
+        /* Leave the new->user_ns reference with the new user namespace. */
-        put_user_ns(ns);
+        /* Leave the reference to our user_ns with the new cred. */
+        new->user_ns = ns;
        return 0;
 }
-/*
+void free_user_ns(struct kref *kref)
- * Deferred destructor for a user namespace.  This is required because
- * free_user_ns() may be called with uidhash_lock held, but we need to call
- * back to free_uid() which will want to take the lock again.
- */
-static void free_user_ns_work(struct work_struct *work)
 {
-        struct user_namespace *ns =
+        struct user_namespace *parent, *ns =
-                container_of(work, struct user_namespace, destroyer);
+                container_of(kref, struct user_namespace, kref);
-        free_uid(ns->creator);
+        parent = ns->parent;
        kmem_cache_free(user_ns_cachep, ns);
+        put_user_ns(parent);
 }
+EXPORT_SYMBOL(free_user_ns);
-void free_user_ns(struct kref *kref)
+static u32 map_id_range_down(struct uid_gid_map *map, u32 id, u32 count)
 {
-        struct user_namespace *ns =
+        unsigned idx, extents;
-                container_of(kref, struct user_namespace, kref);
+        u32 first, last, id2;
+        id2 = id + count - 1;
+        /* Find the matching extent */
+        extents = map->nr_extents;
+        smp_read_barrier_depends();
+        for (idx = 0; idx < extents; idx++) {
+                first = map->extent[idx].first;
+                last = first + map->extent[idx].count - 1;
+                if (id >= first && id <= last &&
+                    (id2 >= first && id2 <= last))
+                        break;
+        }
+        /* Map the id or note failure */
+        if (idx < extents)
+                id = (id - first) + map->extent[idx].lower_first;
+        else
+                id = (u32) -1;
-        INIT_WORK(&ns->destroyer, free_user_ns_work);
+        return id;
-        schedule_work(&ns->destroyer);
 }
-EXPORT_SYMBOL(free_user_ns);
-uid_t user_ns_map_uid(struct user_namespace *to, const struct cred *cred, uid_t uid)
+static u32 map_id_down(struct uid_gid_map *map, u32 id)
 {
-        struct user_namespace *tmp;
+        unsigned idx, extents;
+        u32 first, last;
-        if (likely(to == cred->user->user_ns))
+        /* Find the matching extent */
-                return uid;
+        extents = map->nr_extents;
+        smp_read_barrier_depends();
+        for (idx = 0; idx < extents; idx++) {
+                first = map->extent[idx].first;
+                last = first + map->extent[idx].count - 1;
+                if (id >= first && id <= last)
+                        break;
+        }
+        /* Map the id or note failure */
+        if (idx < extents)
+                id = (id - first) + map->extent[idx].lower_first;
+        else
+                id = (u32) -1;
+        return id;
+}
-        /* Is cred->user the creator of the target user_ns
+static u32 map_id_up(struct uid_gid_map *map, u32 id)
-         * or the creator of one of it's parents?
+{
-         */
+        unsigned idx, extents;
-        for ( tmp = to; tmp != &init_user_ns;
+        u32 first, last;
-              tmp = tmp->creator->user_ns ) {
-                if (cred->user == tmp->creator) {
+        /* Find the matching extent */
-                        return (uid_t)0;
+        extents = map->nr_extents;
-                }
+        smp_read_barrier_depends();
+        for (idx = 0; idx < extents; idx++) {
+                first = map->extent[idx].lower_first;
+                last = first + map->extent[idx].count - 1;
+                if (id >= first && id <= last)
+                        break;
        }
+        /* Map the id or note failure */
+        if (idx < extents)
+                id = (id - first) + map->extent[idx].first;
+        else
+                id = (u32) -1;
+        return id;
+}
+/**
+ *      make_kuid - Map a user-namespace uid pair into a kuid.
+ *      @ns:  User namespace that the uid is in
+ *      @uid: User identifier
+ *
+ *      Maps a user-namespace uid pair into a kernel internal kuid,
+ *      and returns that kuid.
+ *
+ *      When there is no mapping defined for the user-namespace uid
+ *      pair INVALID_UID is returned.  Callers are expected to test
+ *      for and handle handle INVALID_UID being returned.  INVALID_UID
+ *      may be tested for using uid_valid().
+ */
+kuid_t make_kuid(struct user_namespace *ns, uid_t uid)
+{
+        /* Map the uid to a global kernel uid */
+        return KUIDT_INIT(map_id_down(&ns->uid_map, uid));
+}
+EXPORT_SYMBOL(make_kuid);
+/**
+ *      from_kuid - Create a uid from a kuid user-namespace pair.
+ *      @targ: The user namespace we want a uid in.
+ *      @kuid: The kernel internal uid to start with.
+ *
+ *      Map @kuid into the user-namespace specified by @targ and
+ *      return the resulting uid.
+ *
+ *      There is always a mapping into the initial user_namespace.
+ *
+ *      If @kuid has no mapping in @targ (uid_t)-1 is returned.
+ */
+uid_t from_kuid(struct user_namespace *targ, kuid_t kuid)
+{
+        /* Map the uid from a global kernel uid */
+        return map_id_up(&targ->uid_map, __kuid_val(kuid));
+}
+EXPORT_SYMBOL(from_kuid);
-        /* No useful relationship so no mapping */
+/**
-        return overflowuid;
+ *      from_kuid_munged - Create a uid from a kuid user-namespace pair.
+ *      @targ: The user namespace we want a uid in.
+ *      @kuid: The kernel internal uid to start with.
+ *
+ *      Map @kuid into the user-namespace specified by @targ and
+ *      return the resulting uid.
+ *
+ *      There is always a mapping into the initial user_namespace.
+ *
+ *      Unlike from_kuid from_kuid_munged never fails and always
+ *      returns a valid uid.  This makes from_kuid_munged appropriate
+ *      for use in syscalls like stat and getuid where failing the
+ *      system call and failing to provide a valid uid are not an
+ *      options.
+ *
+ *      If @kuid has no mapping in @targ overflowuid is returned.
+ */
+uid_t from_kuid_munged(struct user_namespace *targ, kuid_t kuid)
+{
+        uid_t uid;
+        uid = from_kuid(targ, kuid);
+        if (uid == (uid_t) -1)
+                uid = overflowuid;
+        return uid;
 }
+EXPORT_SYMBOL(from_kuid_munged);
-gid_t user_ns_map_gid(struct user_namespace *to, const struct cred *cred, gid_t gid)
+/**
+ *      make_kgid - Map a user-namespace gid pair into a kgid.
+ *      @ns:  User namespace that the gid is in
+ *      @uid: group identifier
+ *
+ *      Maps a user-namespace gid pair into a kernel internal kgid,
+ *      and returns that kgid.
+ *
+ *      When there is no mapping defined for the user-namespace gid
+ *      pair INVALID_GID is returned.  Callers are expected to test
+ *      for and handle INVALID_GID being returned.  INVALID_GID may be
+ *      tested for using gid_valid().
+ */
+kgid_t make_kgid(struct user_namespace *ns, gid_t gid)
 {
-        struct user_namespace *tmp;
+        /* Map the gid to a global kernel gid */
+        return KGIDT_INIT(map_id_down(&ns->gid_map, gid));
+}
+EXPORT_SYMBOL(make_kgid);
-        if (likely(to == cred->user->user_ns))
+/**
-                return gid;
+ *      from_kgid - Create a gid from a kgid user-namespace pair.
+ *      @targ: The user namespace we want a gid in.
+ *      @kgid: The kernel internal gid to start with.
+ *
+ *      Map @kgid into the user-namespace specified by @targ and
+ *      return the resulting gid.
+ *
+ *      There is always a mapping into the initial user_namespace.
+ *
+ *      If @kgid has no mapping in @targ (gid_t)-1 is returned.
+ */
+gid_t from_kgid(struct user_namespace *targ, kgid_t kgid)
+{
+        /* Map the gid from a global kernel gid */
+        return map_id_up(&targ->gid_map, __kgid_val(kgid));
+}
+EXPORT_SYMBOL(from_kgid);
+/**
+ *      from_kgid_munged - Create a gid from a kgid user-namespace pair.
+ *      @targ: The user namespace we want a gid in.
+ *      @kgid: The kernel internal gid to start with.
+ *
+ *      Map @kgid into the user-namespace specified by @targ and
+ *      return the resulting gid.
+ *
+ *      There is always a mapping into the initial user_namespace.
+ *
+ *      Unlike from_kgid from_kgid_munged never fails and always
+ *      returns a valid gid.  This makes from_kgid_munged appropriate
+ *      for use in syscalls like stat and getgid where failing the
+ *      system call and failing to provide a valid gid are not options.
+ *
+ *      If @kgid has no mapping in @targ overflowgid is returned.
+ */
+gid_t from_kgid_munged(struct user_namespace *targ, kgid_t kgid)
+{
+        gid_t gid;
+        gid = from_kgid(targ, kgid);
-        /* Is cred->user the creator of the target user_ns
+        if (gid == (gid_t) -1)
-         * or the creator of one of it's parents?
+                gid = overflowgid;
+        return gid;
+}
+EXPORT_SYMBOL(from_kgid_munged);
+static int uid_m_show(struct seq_file *seq, void *v)
+{
+        struct user_namespace *ns = seq->private;
+        struct uid_gid_extent *extent = v;
+        struct user_namespace *lower_ns;
+        uid_t lower;
+        lower_ns = current_user_ns();
+        if ((lower_ns == ns) && lower_ns->parent)
+                lower_ns = lower_ns->parent;
+        lower = from_kuid(lower_ns, KUIDT_INIT(extent->lower_first));
+        seq_printf(seq, "%10u %10u %10u\n",
+                extent->first,
+                lower,
+                extent->count);
+        return 0;
+}
+static int gid_m_show(struct seq_file *seq, void *v)
+{
+        struct user_namespace *ns = seq->private;
+        struct uid_gid_extent *extent = v;
+        struct user_namespace *lower_ns;
+        gid_t lower;
+        lower_ns = current_user_ns();
+        if ((lower_ns == ns) && lower_ns->parent)
+                lower_ns = lower_ns->parent;
+        lower = from_kgid(lower_ns, KGIDT_INIT(extent->lower_first));
+        seq_printf(seq, "%10u %10u %10u\n",
+                extent->first,
+                lower,
+                extent->count);
+        return 0;
+}
+static void *m_start(struct seq_file *seq, loff_t *ppos, struct uid_gid_map *map)
+{
+        struct uid_gid_extent *extent = NULL;
+        loff_t pos = *ppos;
+        if (pos < map->nr_extents)
+                extent = &map->extent[pos];
+        return extent;
+}
+static void *uid_m_start(struct seq_file *seq, loff_t *ppos)
+{
+        struct user_namespace *ns = seq->private;
+        return m_start(seq, ppos, &ns->uid_map);
+}
+static void *gid_m_start(struct seq_file *seq, loff_t *ppos)
+{
+        struct user_namespace *ns = seq->private;
+        return m_start(seq, ppos, &ns->gid_map);
+}
+static void *m_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+        (*pos)++;
+        return seq->op->start(seq, pos);
+}
+static void m_stop(struct seq_file *seq, void *v)
+{
+        return;
+}
+struct seq_operations proc_uid_seq_operations = {
+        .start = uid_m_start,
+        .stop = m_stop,
+        .next = m_next,
+        .show = uid_m_show,
+};
+struct seq_operations proc_gid_seq_operations = {
+        .start = gid_m_start,
+        .stop = m_stop,
+        .next = m_next,
+        .show = gid_m_show,
+};
+static DEFINE_MUTEX(id_map_mutex);
+static ssize_t map_write(struct file *file, const char __user *buf,
+                         size_t count, loff_t *ppos,
+                         int cap_setid,
+                         struct uid_gid_map *map,
+                         struct uid_gid_map *parent_map)
+{
+        struct seq_file *seq = file->private_data;
+        struct user_namespace *ns = seq->private;
+        struct uid_gid_map new_map;
+        unsigned idx;
+        struct uid_gid_extent *extent, *last = NULL;
+        unsigned long page = 0;
+        char *kbuf, *pos, *next_line;
+        ssize_t ret = -EINVAL;
+        /*
+         * The id_map_mutex serializes all writes to any given map.
+         *
+         * Any map is only ever written once.
+         *
+         * An id map fits within 1 cache line on most architectures.
+         *
+         * On read nothing needs to be done unless you are on an
+         * architecture with a crazy cache coherency model like alpha.
+         *
+         * There is a one time data dependency between reading the
+         * count of the extents and the values of the extents.  The
+         * desired behavior is to see the values of the extents that
+         * were written before the count of the extents.
+         *
+         * To achieve this smp_wmb() is used on guarantee the write
+         * order and smp_read_barrier_depends() is guaranteed that we
+         * don't have crazy architectures returning stale data.
+         *
         */
-        for ( tmp = to; tmp != &init_user_ns;
+        mutex_lock(&id_map_mutex);
-              tmp = tmp->creator->user_ns ) {
-                if (cred->user == tmp->creator) {
+        ret = -EPERM;
-                        return (gid_t)0;
+        /* Only allow one successful write to the map */
+        if (map->nr_extents != 0)
+                goto out;
+        /* Require the appropriate privilege CAP_SETUID or CAP_SETGID
+         * over the user namespace in order to set the id mapping.
+         */
+        if (!ns_capable(ns, cap_setid))
+                goto out;
+        /* Get a buffer */
+        ret = -ENOMEM;
+        page = __get_free_page(GFP_TEMPORARY);
+        kbuf = (char *) page;
+        if (!page)
+                goto out;
+        /* Only allow <= page size writes at the beginning of the file */
+        ret = -EINVAL;
+        if ((*ppos != 0) || (count >= PAGE_SIZE))
+                goto out;
+        /* Slurp in the user data */
+        ret = -EFAULT;
+        if (copy_from_user(kbuf, buf, count))
+                goto out;
+        kbuf[count] = '\0';
+        /* Parse the user data */
+        ret = -EINVAL;
+        pos = kbuf;
+        new_map.nr_extents = 0;
+        for (;pos; pos = next_line) {
+                extent = &new_map.extent[new_map.nr_extents];
+                /* Find the end of line and ensure I don't look past it */
+                next_line = strchr(pos, '\n');
+                if (next_line) {
+                        *next_line = '\0';
+                        next_line++;
+                        if (*next_line == '\0')
+                                next_line = NULL;
                }
+                pos = skip_spaces(pos);
+                extent->first = simple_strtoul(pos, &pos, 10);
+                if (!isspace(*pos))
+                        goto out;
+                pos = skip_spaces(pos);
+                extent->lower_first = simple_strtoul(pos, &pos, 10);
+                if (!isspace(*pos))
+                        goto out;
+                pos = skip_spaces(pos);
+                extent->count = simple_strtoul(pos, &pos, 10);
+                if (*pos && !isspace(*pos))
+                        goto out;
+                /* Verify there is not trailing junk on the line */
+                pos = skip_spaces(pos);
+                if (*pos != '\0')
+                        goto out;
+                /* Verify we have been given valid starting values */
+                if ((extent->first == (u32) -1) ||
+                    (extent->lower_first == (u32) -1 ))
+                        goto out;
+                /* Verify count is not zero and does not cause the extent to wrap */
+                if ((extent->first + extent->count) <= extent->first)
+                        goto out;
+                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)))
+                        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) &&
+                    (next_line != NULL))
+                        goto out;
+        }
+        /* Be very certaint the new map actually exists */
+        if (new_map.nr_extents == 0)
+                goto out;
+        ret = -EPERM;
+        /* Validate the user is allowed to use user id's mapped to. */
+        if (!new_idmap_permitted(ns, cap_setid, &new_map))
+                goto out;
+        /* Map the lower ids from the parent user namespace to the
+         * kernel global id space.
+         */
+        for (idx = 0; idx < new_map.nr_extents; idx++) {
+                u32 lower_first;
+                extent = &new_map.extent[idx];
+                lower_first = map_id_range_down(parent_map,
+                                                extent->lower_first,
+                                                extent->count);
+                /* Fail if we can not map the specified extent to
+                 * the kernel global id space.
+                 */
+                if (lower_first == (u32) -1)
+                        goto out;
+                extent->lower_first = lower_first;
        }
-        /* No useful relationship so no mapping */
+        /* Install the map */
-        return overflowgid;
+        memcpy(map->extent, new_map.extent,
+                new_map.nr_extents*sizeof(new_map.extent[0]));
+        smp_wmb();
+        map->nr_extents = new_map.nr_extents;
+        *ppos = count;
+        ret = count;
+out:
+        mutex_unlock(&id_map_mutex);
+        if (page)
+                free_page(page);
+        return ret;
+}
+ssize_t proc_uid_map_write(struct file *file, const char __user *buf, size_t size, loff_t *ppos)
+{
+        struct seq_file *seq = file->private_data;
+        struct user_namespace *ns = seq->private;
+        if (!ns->parent)
+                return -EPERM;
+        return map_write(file, buf, size, ppos, CAP_SETUID,
+                         &ns->uid_map, &ns->parent->uid_map);
+}
+ssize_t proc_gid_map_write(struct file *file, const char __user *buf, size_t size, loff_t *ppos)
+{
+        struct seq_file *seq = file->private_data;
+        struct user_namespace *ns = seq->private;
+        if (!ns->parent)
+                return -EPERM;
+        return map_write(file, buf, size, ppos, CAP_SETGID,
+                         &ns->gid_map, &ns->parent->gid_map);
+}
+static bool new_idmap_permitted(struct user_namespace *ns, int cap_setid,
+                                struct uid_gid_map *new_map)
+{
+        /* Allow the specified ids if we have the appropriate capability
+         * (CAP_SETUID or CAP_SETGID) over the parent user namespace.
+         */
+        if (ns_capable(ns->parent, cap_setid))
+                return true;
+        return false;
 }
 static __init int user_namespaces_init(void)
diff --git a/kernel/utsname.c b/kernel/utsname.c
index 405caf91aad5..679d97a5d3fd 100644
--- a/kernel/utsname.c
+++ b/kernel/utsname.c
@@ -43,7 +43,7 @@ static struct uts_namespace *clone_uts_ns(struct task_struct *tsk,
        down_read(&uts_sem);
        memcpy(&ns->name, &old_ns->name, sizeof(ns->name));
-        ns->user_ns = get_user_ns(task_cred_xxx(tsk, user)->user_ns);
+        ns->user_ns = get_user_ns(task_cred_xxx(tsk, user_ns));
        up_read(&uts_sem);
        return ns;
 }
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index b19569137529..39fd416ae14f 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -1334,8 +1334,8 @@ SYSCALL_DEFINE4(migrate_pages, pid_t, pid, unsigned long, maxnode,
         * userid as the target process.
         */
        tcred = __task_cred(task);
-        if (cred->euid != tcred->suid && cred->euid != tcred->uid &&
+        if (!uid_eq(cred->euid, tcred->suid) && !uid_eq(cred->euid, tcred->uid) &&
-            cred->uid  != tcred->suid && cred->uid  != tcred->uid &&
+            !uid_eq(cred->uid,  tcred->suid) && !uid_eq(cred->uid,  tcred->uid) &&
            !capable(CAP_SYS_NICE)) {
                rcu_read_unlock();
                err = -EPERM;
diff --git a/mm/migrate.c b/mm/migrate.c
index 11072383ae12..ab81d482ae6f 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -1371,8 +1371,8 @@ SYSCALL_DEFINE6(move_pages, pid_t, pid, unsigned long, nr_pages,
         * userid as the target process.
         */
        tcred = __task_cred(task);
-        if (cred->euid != tcred->suid && cred->euid != tcred->uid &&
+        if (!uid_eq(cred->euid, tcred->suid) && !uid_eq(cred->euid, tcred->uid) &&
-            cred->uid  != tcred->suid && cred->uid  != tcred->uid &&
+            !uid_eq(cred->uid,  tcred->suid) && !uid_eq(cred->uid,  tcred->uid) &&
            !capable(CAP_SYS_NICE)) {
                rcu_read_unlock();
                err = -EPERM;
diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index 46bf2ed5594c..9f09a1fde9f9 100644
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -410,8 +410,8 @@ static void dump_tasks(const struct mem_cgroup *memcg, const nodemask_t *nodemas
                }
                pr_info("[%5d] %5d %5d %8lu %8lu %3u     %3d         %5d %s\n",
-                        task->pid, task_uid(task), task->tgid,
+                        task->pid, from_kuid(&init_user_ns, task_uid(task)),
-                        task->mm->total_vm, get_mm_rss(task->mm),
+                        task->tgid, task->mm->total_vm, get_mm_rss(task->mm),
                        task_cpu(task), task->signal->oom_adj,
                        task->signal->oom_score_adj, task->comm);
                task_unlock(task);
diff --git a/mm/shmem.c b/mm/shmem.c
index f99ff3e50bd6..d7b433a1ef5e 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -2075,6 +2075,8 @@ static int shmem_parse_options(char *options, struct shmem_sb_info *sbinfo,
                               bool remount)
 {
        char *this_char, *value, *rest;
+        uid_t uid;
+        gid_t gid;
        while (options != NULL) {
                this_char = options;
@@ -2134,15 +2136,21 @@ static int shmem_parse_options(char *options, struct shmem_sb_info *sbinfo,
                } else if (!strcmp(this_char,"uid")) {
                        if (remount)
                                continue;
-                        sbinfo->uid = simple_strtoul(value, &rest, 0);
+                        uid = simple_strtoul(value, &rest, 0);
                        if (*rest)
                                goto bad_val;
+                        sbinfo->uid = make_kuid(current_user_ns(), uid);
+                        if (!uid_valid(sbinfo->uid))
+                                goto bad_val;
                } else if (!strcmp(this_char,"gid")) {
                        if (remount)
                                continue;
-                        sbinfo->gid = simple_strtoul(value, &rest, 0);
+                        gid = simple_strtoul(value, &rest, 0);
                        if (*rest)
                                goto bad_val;
+                        sbinfo->gid = make_kgid(current_user_ns(), gid);
+                        if (!gid_valid(sbinfo->gid))
+                                goto bad_val;
                } else if (!strcmp(this_char,"mpol")) {
                        if (mpol_parse_str(value, &sbinfo->mpol, 1))
                                goto bad_val;
@@ -2210,10 +2218,12 @@ static int shmem_show_options(struct seq_file *seq, struct dentry *root)
                seq_printf(seq, ",nr_inodes=%lu", sbinfo->max_inodes);
        if (sbinfo->mode != (S_IRWXUGO | S_ISVTX))
                seq_printf(seq, ",mode=%03ho", sbinfo->mode);
-        if (sbinfo->uid != 0)
+        if (!uid_eq(sbinfo->uid, GLOBAL_ROOT_UID))
-                seq_printf(seq, ",uid=%u", sbinfo->uid);
+                seq_printf(seq, ",uid=%u",
-        if (sbinfo->gid != 0)
+                                from_kuid_munged(&init_user_ns, sbinfo->uid));
-                seq_printf(seq, ",gid=%u", sbinfo->gid);
+        if (!gid_eq(sbinfo->gid, GLOBAL_ROOT_GID))
+                seq_printf(seq, ",gid=%u",
+                                from_kgid_munged(&init_user_ns, sbinfo->gid));
        shmem_show_mpol(seq, sbinfo->mpol);
        return 0;
 }
diff --git a/net/core/sock.c b/net/core/sock.c
index f372d9bf4976..653f8c0aedc5 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -813,8 +813,8 @@ void cred_to_ucred(struct pid *pid, const struct cred *cred,
        if (cred) {
                struct user_namespace *current_ns = current_user_ns();
-                ucred->uid = user_ns_map_uid(current_ns, cred, cred->euid);
+                ucred->uid = from_kuid(current_ns, cred->euid);
-                ucred->gid = user_ns_map_gid(current_ns, cred, cred->egid);
+                ucred->gid = from_kgid(current_ns, cred->egid);
        }
 }
 EXPORT_SYMBOL_GPL(cred_to_ucred);
diff --git a/net/ipv4/ping.c b/net/ipv4/ping.c
index 6e930c7174dd..2c00e8bf684d 100644
--- a/net/ipv4/ping.c
+++ b/net/ipv4/ping.c
@@ -207,17 +207,22 @@ static int ping_init_sock(struct sock *sk)
        gid_t range[2];
        struct group_info *group_info = get_current_groups();
        int i, j, count = group_info->ngroups;
+        kgid_t low, high;
        inet_get_ping_group_range_net(net, range, range+1);
+        low = make_kgid(&init_user_ns, range[0]);
+        high = make_kgid(&init_user_ns, range[1]);
+        if (!gid_valid(low) || !gid_valid(high) || gid_lt(high, low))
+                return -EACCES;
        if (range[0] <= group && group <= range[1])
                return 0;
        for (i = 0; i < group_info->nblocks; i++) {
                int cp_count = min_t(int, NGROUPS_PER_BLOCK, count);
                for (j = 0; j < cp_count; j++) {
-                        group = group_info->blocks[i][j];
+                        kgid_t gid = group_info->blocks[i][j];
-                        if (range[0] <= group && group <= range[1])
+                        if (gid_lte(low, gid) && gid_lte(gid, high))
                                return 0;
                }
diff --git a/net/sunrpc/auth_generic.c b/net/sunrpc/auth_generic.c
index 75762f346975..6ed6f201b022 100644
--- a/net/sunrpc/auth_generic.c
+++ b/net/sunrpc/auth_generic.c
@@ -160,8 +160,8 @@ generic_match(struct auth_cred *acred, struct rpc_cred *cred, int flags)
        if (gcred->acred.group_info->ngroups != acred->group_info->ngroups)
                goto out_nomatch;
        for (i = 0; i < gcred->acred.group_info->ngroups; i++) {
-                if (GROUP_AT(gcred->acred.group_info, i) !=
+                if (!gid_eq(GROUP_AT(gcred->acred.group_info, i),
-                                GROUP_AT(acred->group_info, i))
+                                GROUP_AT(acred->group_info, i)))
                        goto out_nomatch;
        }
 out_match:
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
index 1600cfb1618c..28b62dbb6d1e 100644
--- a/net/sunrpc/auth_gss/svcauth_gss.c
+++ b/net/sunrpc/auth_gss/svcauth_gss.c
@@ -41,6 +41,7 @@
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/pagemap.h>
+#include <linux/user_namespace.h>
 #include <linux/sunrpc/auth_gss.h>
 #include <linux/sunrpc/gss_err.h>
@@ -470,9 +471,13 @@ static int rsc_parse(struct cache_detail *cd,
                status = -EINVAL;
                for (i=0; i<N; i++) {
                        gid_t gid;
+                        kgid_t kgid;
                        if (get_int(&mesg, &gid))
                                goto out;
-                        GROUP_AT(rsci.cred.cr_group_info, i) = gid;
+                        kgid = make_kgid(&init_user_ns, gid);
+                        if (!gid_valid(kgid))
+                                goto out;
+                        GROUP_AT(rsci.cred.cr_group_info, i) = kgid;
                }
                /* mech name */
diff --git a/net/sunrpc/auth_unix.c b/net/sunrpc/auth_unix.c
index e50502d8ceb7..52c5abdee211 100644
--- a/net/sunrpc/auth_unix.c
+++ b/net/sunrpc/auth_unix.c
@@ -12,6 +12,7 @@
 #include <linux/module.h>
 #include <linux/sunrpc/clnt.h>
 #include <linux/sunrpc/auth.h>
+#include <linux/user_namespace.h>
 #define NFS_NGROUPS     16
@@ -78,8 +79,11 @@ unx_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)
                groups = NFS_NGROUPS;
        cred->uc_gid = acred->gid;
-        for (i = 0; i < groups; i++)
+        for (i = 0; i < groups; i++) {
-                cred->uc_gids[i] = GROUP_AT(acred->group_info, i);
+                gid_t gid;
+                gid = from_kgid(&init_user_ns, GROUP_AT(acred->group_info, i));
+                cred->uc_gids[i] = gid;
+        }
        if (i < NFS_NGROUPS)
                cred->uc_gids[i] = NOGROUP;
@@ -126,9 +130,12 @@ unx_match(struct auth_cred *acred, struct rpc_cred *rcred, int flags)
                groups = acred->group_info->ngroups;
        if (groups > NFS_NGROUPS)
                groups = NFS_NGROUPS;
-        for (i = 0; i < groups ; i++)
+        for (i = 0; i < groups ; i++) {
-                if (cred->uc_gids[i] != GROUP_AT(acred->group_info, i))
+                gid_t gid;
+                gid = from_kgid(&init_user_ns, GROUP_AT(acred->group_info, i));
+                if (cred->uc_gids[i] != gid)
                        return 0;
+        }
        if (groups < NFS_NGROUPS &&
            cred->uc_gids[groups] != NOGROUP)
                return 0;
diff --git a/net/sunrpc/svcauth_unix.c b/net/sunrpc/svcauth_unix.c
index 521d8f7dc833..71ec8530ec8c 100644
--- a/net/sunrpc/svcauth_unix.c
+++ b/net/sunrpc/svcauth_unix.c
@@ -14,6 +14,7 @@
 #include <net/sock.h>
 #include <net/ipv6.h>
 #include <linux/kernel.h>
+#include <linux/user_namespace.h>
 #define RPCDBG_FACILITY RPCDBG_AUTH
 #include <linux/sunrpc/clnt.h>
@@ -530,11 +531,15 @@ static int unix_gid_parse(struct cache_detail *cd,
        for (i = 0 ; i < gids ; i++) {
                int gid;
+                kgid_t kgid;
                rv = get_int(&mesg, &gid);
                err = -EINVAL;
                if (rv)
                        goto out;
-                GROUP_AT(ug.gi, i) = gid;
+                kgid = make_kgid(&init_user_ns, gid);
+                if (!gid_valid(kgid))
+                        goto out;
+                GROUP_AT(ug.gi, i) = kgid;
        }
        ugp = unix_gid_lookup(cd, uid);
@@ -563,6 +568,7 @@ static int unix_gid_show(struct seq_file *m,
                         struct cache_detail *cd,
                         struct cache_head *h)
 {
+        struct user_namespace *user_ns = current_user_ns();
        struct unix_gid *ug;
        int i;
        int glen;
@@ -580,7 +586,7 @@ static int unix_gid_show(struct seq_file *m,
        seq_printf(m, "%u %d:", ug->uid, glen);
        for (i = 0; i < glen; i++)
-                seq_printf(m, " %d", GROUP_AT(ug->gi, i));
+                seq_printf(m, " %d", from_kgid_munged(user_ns, GROUP_AT(ug->gi, i)));
        seq_printf(m, "\n");
        return 0;
 }
@@ -831,8 +837,12 @@ svcauth_unix_accept(struct svc_rqst *rqstp, __be32 *authp)
        cred->cr_group_info = groups_alloc(slen);
        if (cred->cr_group_info == NULL)
                return SVC_CLOSE;
-        for (i = 0; i < slen; i++)
+        for (i = 0; i < slen; i++) {
-                GROUP_AT(cred->cr_group_info, i) = svc_getnl(argv);
+                kgid_t kgid = make_kgid(&init_user_ns, svc_getnl(argv));
+                if (!gid_valid(kgid))
+                        goto badcred;
+                GROUP_AT(cred->cr_group_info, i) = kgid;
+        }
        if (svc_getu32(argv) != htonl(RPC_AUTH_NULL) || svc_getu32(argv) != 0) {
                *authp = rpc_autherr_badverf;
                return SVC_DENIED;
diff --git a/security/commoncap.c b/security/commoncap.c
index f80d11609391..e771cb1b2d79 100644
--- a/security/commoncap.c
+++ b/security/commoncap.c
@@ -77,12 +77,12 @@ int cap_capable(const struct cred *cred, struct user_namespace *targ_ns,
                int cap, int audit)
 {
        for (;;) {
-                /* The creator of the user namespace has all caps. */
+                /* The owner of the user namespace has all caps. */
-                if (targ_ns != &init_user_ns && targ_ns->creator == cred->user)
+                if (targ_ns != &init_user_ns && uid_eq(targ_ns->owner, cred->euid))
                        return 0;
                /* Do we have the necessary capabilities? */
-                if (targ_ns == cred->user->user_ns)
+                if (targ_ns == cred->user_ns)
                        return cap_raised(cred->cap_effective, cap) ? 0 : -EPERM;
                /* Have we tried all of the parent namespaces? */
@@ -93,7 +93,7 @@ int cap_capable(const struct cred *cred, struct user_namespace *targ_ns,
                 *If you have a capability in a parent user ns, then you have
                 * it over all children user namespaces as well.
                 */
-                targ_ns = targ_ns->creator->user_ns;
+                targ_ns = targ_ns->parent;
        }
        /* We never get here */
@@ -137,10 +137,10 @@ int cap_ptrace_access_check(struct task_struct *child, unsigned int mode)
        rcu_read_lock();
        cred = current_cred();
        child_cred = __task_cred(child);
-        if (cred->user->user_ns == child_cred->user->user_ns &&
+        if (cred->user_ns == child_cred->user_ns &&
            cap_issubset(child_cred->cap_permitted, cred->cap_permitted))
                goto out;
-        if (ns_capable(child_cred->user->user_ns, CAP_SYS_PTRACE))
+        if (ns_capable(child_cred->user_ns, CAP_SYS_PTRACE))
                goto out;
        ret = -EPERM;
 out:
@@ -169,10 +169,10 @@ int cap_ptrace_traceme(struct task_struct *parent)
        rcu_read_lock();
        cred = __task_cred(parent);
        child_cred = current_cred();
-        if (cred->user->user_ns == child_cred->user->user_ns &&
+        if (cred->user_ns == child_cred->user_ns &&
            cap_issubset(child_cred->cap_permitted, cred->cap_permitted))
                goto out;
-        if (has_ns_capability(parent, child_cred->user->user_ns, CAP_SYS_PTRACE))
+        if (has_ns_capability(parent, child_cred->user_ns, CAP_SYS_PTRACE))
                goto out;
        ret = -EPERM;
 out:
@@ -215,7 +215,7 @@ static inline int cap_inh_is_capped(void)
        /* they are so limited unless the current task has the CAP_SETPCAP
         * capability
         */
-        if (cap_capable(current_cred(), current_cred()->user->user_ns,
+        if (cap_capable(current_cred(), current_cred()->user_ns,
                        CAP_SETPCAP, SECURITY_CAP_AUDIT) == 0)
                return 0;
        return 1;
@@ -473,19 +473,22 @@ int cap_bprm_set_creds(struct linux_binprm *bprm)
        struct cred *new = bprm->cred;
        bool effective, has_cap = false;
        int ret;
+        kuid_t root_uid;
        effective = false;
        ret = get_file_caps(bprm, &effective, &has_cap);
        if (ret < 0)
                return ret;
+        root_uid = make_kuid(new->user_ns, 0);
        if (!issecure(SECURE_NOROOT)) {
                /*
                 * If the legacy file capability is set, then don't set privs
                 * for a setuid root binary run by a non-root user.  Do set it
                 * for a root user just to cause least surprise to an admin.
                 */
-                if (has_cap && new->uid != 0 && new->euid == 0) {
+                if (has_cap && !uid_eq(new->uid, root_uid) && uid_eq(new->euid, root_uid)) {
                        warn_setuid_and_fcaps_mixed(bprm->filename);
                        goto skip;
                }
@@ -496,12 +499,12 @@ int cap_bprm_set_creds(struct linux_binprm *bprm)
                 *
                 * If only the real uid is 0, we do not set the effective bit.
                 */
-                if (new->euid == 0 || new->uid == 0) {
+                if (uid_eq(new->euid, root_uid) || uid_eq(new->uid, root_uid)) {
                        /* pP' = (cap_bset & ~0) | (pI & ~0) */
                        new->cap_permitted = cap_combine(old->cap_bset,
                                                         old->cap_inheritable);
                }
-                if (new->euid == 0)
+                if (uid_eq(new->euid, root_uid))
                        effective = true;
        }
 skip:
@@ -516,8 +519,8 @@ skip:
         *
         * In addition, if NO_NEW_PRIVS, then ensure we get no new privs.
         */
-        if ((new->euid != old->uid ||
+        if ((!uid_eq(new->euid, old->uid) ||
-             new->egid != old->gid ||
+             !gid_eq(new->egid, old->gid) ||
             !cap_issubset(new->cap_permitted, old->cap_permitted)) &&
            bprm->unsafe & ~LSM_UNSAFE_PTRACE_CAP) {
                /* downgrade; they get no more than they had, and maybe less */
@@ -553,7 +556,7 @@ skip:
         */
        if (!cap_isclear(new->cap_effective)) {
                if (!cap_issubset(CAP_FULL_SET, new->cap_effective) ||
-                    new->euid != 0 || new->uid != 0 ||
+                    !uid_eq(new->euid, root_uid) || !uid_eq(new->uid, root_uid) ||
                    issecure(SECURE_NOROOT)) {
                        ret = audit_log_bprm_fcaps(bprm, new, old);
                        if (ret < 0)
@@ -578,16 +581,17 @@ skip:
 int cap_bprm_secureexec(struct linux_binprm *bprm)
 {
        const struct cred *cred = current_cred();
+        kuid_t root_uid = make_kuid(cred->user_ns, 0);
-        if (cred->uid != 0) {
+        if (!uid_eq(cred->uid, root_uid)) {
                if (bprm->cap_effective)
                        return 1;
                if (!cap_isclear(cred->cap_permitted))
                        return 1;
        }
-        return (cred->euid != cred->uid ||
+        return (!uid_eq(cred->euid, cred->uid) ||
-                cred->egid != cred->gid);
+                !gid_eq(cred->egid, cred->gid));
 }
 /**
@@ -677,15 +681,21 @@ int cap_inode_removexattr(struct dentry *dentry, const char *name)
 */
 static inline void cap_emulate_setxuid(struct cred *new, const struct cred *old)
 {
-        if ((old->uid == 0 || old->euid == 0 || old->suid == 0) &&
+        kuid_t root_uid = make_kuid(old->user_ns, 0);
-            (new->uid != 0 && new->euid != 0 && new->suid != 0) &&
+        if ((uid_eq(old->uid, root_uid) ||
+             uid_eq(old->euid, root_uid) ||
+             uid_eq(old->suid, root_uid)) &&
+            (!uid_eq(new->uid, root_uid) &&
+             !uid_eq(new->euid, root_uid) &&
+             !uid_eq(new->suid, root_uid)) &&
            !issecure(SECURE_KEEP_CAPS)) {
                cap_clear(new->cap_permitted);
                cap_clear(new->cap_effective);
        }
-        if (old->euid == 0 && new->euid != 0)
+        if (uid_eq(old->euid, root_uid) && !uid_eq(new->euid, root_uid))
                cap_clear(new->cap_effective);
-        if (old->euid != 0 && new->euid == 0)
+        if (!uid_eq(old->euid, root_uid) && uid_eq(new->euid, root_uid))
                new->cap_effective = new->cap_permitted;
 }
@@ -718,11 +728,12 @@ int cap_task_fix_setuid(struct cred *new, const struct cred *old, int flags)
                 *          if not, we might be a bit too harsh here.
                 */
                if (!issecure(SECURE_NO_SETUID_FIXUP)) {
-                        if (old->fsuid == 0 && new->fsuid != 0)
+                        kuid_t root_uid = make_kuid(old->user_ns, 0);
+                        if (uid_eq(old->fsuid, root_uid) && !uid_eq(new->fsuid, root_uid))
                                new->cap_effective =
                                        cap_drop_fs_set(new->cap_effective);
-                        if (old->fsuid != 0 && new->fsuid == 0)
+                        if (!uid_eq(old->fsuid, root_uid) && uid_eq(new->fsuid, root_uid))
                                new->cap_effective =
                                        cap_raise_fs_set(new->cap_effective,
                                                         new->cap_permitted);
@@ -875,7 +886,7 @@ int cap_task_prctl(int option, unsigned long arg2, unsigned long arg3,
                    || ((new->securebits & SECURE_ALL_LOCKS & ~arg2))   /*[2]*/
                    || (arg2 & ~(SECURE_ALL_LOCKS | SECURE_ALL_BITS))   /*[3]*/
                    || (cap_capable(current_cred(),
-                                    current_cred()->user->user_ns, CAP_SETPCAP,
+                                    current_cred()->user_ns, CAP_SETPCAP,
                                    SECURITY_CAP_AUDIT) != 0)           /*[4]*/
                        /*
                         * [1] no changing of bits that are locked
diff --git a/security/keys/key.c b/security/keys/key.c
index c9bf66ac36e0..50d96d4e06f2 100644
--- a/security/keys/key.c
+++ b/security/keys/key.c
@@ -253,7 +253,7 @@ struct key *key_alloc(struct key_type *type, const char *desc,
        quotalen = desclen + type->def_datalen;
        /* get hold of the key tracking for this user */
-        user = key_user_lookup(uid, cred->user->user_ns);
+        user = key_user_lookup(uid, cred->user_ns);
        if (!user)
                goto no_memory_1;
diff --git a/security/keys/permission.c b/security/keys/permission.c
index 57d96363d7f1..0b4d019e027d 100644
--- a/security/keys/permission.c
+++ b/security/keys/permission.c
@@ -36,7 +36,7 @@ int key_task_permission(const key_ref_t key_ref, const struct cred *cred,
        key = key_ref_to_ptr(key_ref);
-        if (key->user->user_ns != cred->user->user_ns)
+        if (key->user->user_ns != cred->user_ns)
                goto use_other_perms;
        /* use the second 8-bits of permissions for keys the caller owns */
@@ -53,7 +53,8 @@ int key_task_permission(const key_ref_t key_ref, const struct cred *cred,
                        goto use_these_perms;
                }
-                ret = groups_search(cred->group_info, key->gid);
+                ret = groups_search(cred->group_info,
+                                    make_kgid(current_user_ns(), key->gid));
                if (ret) {
                        kperm = key->perm >> 8;
                        goto use_these_perms;
diff --git a/security/keys/process_keys.c b/security/keys/process_keys.c
index e137fcd7042c..d71056db7b67 100644
--- a/security/keys/process_keys.c
+++ b/security/keys/process_keys.c
@@ -860,7 +860,7 @@ void key_replace_session_keyring(void)
        new-> sgid      = old-> sgid;
        new->fsgid      = old->fsgid;
        new->user       = get_uid(old->user);
-        new->user_ns    = new->user->user_ns;
+        new->user_ns    = get_user_ns(new->user_ns);
        new->group_info = get_group_info(old->group_info);
        new->securebits = old->securebits;