5 files changed, 266 insertions, 54 deletions

diff --git a/fs/proc/array.c b/fs/proc/array.c
index b9be6e355cc6..63c95afb561f 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -77,6 +77,7 @@
 #include <linux/cpuset.h>
 #include <linux/rcupdate.h>
 #include <linux/delayacct.h>
+#include <linux/pid_namespace.h>
 
 #include <asm/pgtable.h>
 #include <asm/processor.h>
@@ -145,8 +146,7 @@ static inline const char *get_task_state(struct task_struct *tsk)
                                             TASK_UNINTERRUPTIBLE |
                                             TASK_STOPPED |
                                             TASK_TRACED)) |
-                        (tsk->exit_state & (EXIT_ZOMBIE |
-                                            EXIT_DEAD));
+                                           tsk->exit_state;
         const char **p = &task_state_array[0];
 
         while (state) {
@@ -161,8 +161,15 @@ static inline char *task_state(struct task_struct *p, char *buffer)
         struct group_info *group_info;
         int g;
         struct fdtable *fdt = NULL;
+        struct pid_namespace *ns;
+        pid_t ppid, tpid;
 
+        ns = current->nsproxy->pid_ns;
         rcu_read_lock();
+        ppid = pid_alive(p) ?
+                task_tgid_nr_ns(rcu_dereference(p->real_parent), ns) : 0;
+        tpid = pid_alive(p) && p->ptrace ?
+                task_ppid_nr_ns(rcu_dereference(p->parent), ns) : 0;
         buffer += sprintf(buffer,
                 "State:\t%s\n"
                 "Tgid:\t%d\n"
@@ -172,9 +179,9 @@ static inline char *task_state(struct task_struct *p, char *buffer)
                 "Uid:\t%d\t%d\t%d\t%d\n"
                 "Gid:\t%d\t%d\t%d\t%d\n",
                 get_task_state(p),
-                p->tgid, p->pid,
-                pid_alive(p) ? rcu_dereference(p->real_parent)->tgid : 0,
-                pid_alive(p) && p->ptrace ? rcu_dereference(p->parent)->pid : 0,
+                task_tgid_nr_ns(p, ns),
+                task_pid_nr_ns(p, ns),
+                ppid, tpid,
                 p->uid, p->euid, p->suid, p->fsuid,
                 p->gid, p->egid, p->sgid, p->fsgid);
 
@@ -394,6 +401,9 @@ static int do_task_stat(struct task_struct *task, char *buffer, int whole)
         unsigned long rsslim = 0;
         char tcomm[sizeof(task->comm)];
         unsigned long flags;
+        struct pid_namespace *ns;
+
+        ns = current->nsproxy->pid_ns;
 
         state = *get_task_state(task);
         vsize = eip = esp = 0;
@@ -416,7 +426,7 @@ static int do_task_stat(struct task_struct *task, char *buffer, int whole)
                 struct signal_struct *sig = task->signal;
 
                 if (sig->tty) {
-                        tty_pgrp = pid_nr(sig->tty->pgrp);
+                        tty_pgrp = pid_nr_ns(sig->tty->pgrp, ns);
                         tty_nr = new_encode_dev(tty_devnum(sig->tty));
                 }
 
@@ -449,9 +459,9 @@ static int do_task_stat(struct task_struct *task, char *buffer, int whole)
                         gtime = cputime_add(gtime, sig->gtime);
                 }
 
-                sid = signal_session(sig);
-                pgid = process_group(task);
-                ppid = rcu_dereference(task->real_parent)->tgid;
+                sid = task_session_nr_ns(task, ns);
+                pgid = task_pgrp_nr_ns(task, ns);
+                ppid = task_ppid_nr_ns(task, ns);
 
                 unlock_task_sighand(task, &flags);
         }
@@ -483,7 +493,7 @@ static int do_task_stat(struct task_struct *task, char *buffer, int whole)
         res = sprintf(buffer, "%d (%s) %c %d %d %d %d %d %u %lu \
 %lu %lu %lu %lu %lu %ld %ld %ld %ld %d 0 %llu %lu %ld %lu %lu %lu %lu %lu \
 %lu %lu %lu %lu %lu %lu %lu %lu %d %d %u %u %llu %lu %ld\n",
-                task->pid,
+                task_pid_nr_ns(task, ns),
                 tcomm,
                 state,
                 ppid,
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 4fe74d156416..39a3d7c969c5 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -63,16 +63,19 @@
 #include <linux/mm.h>
 #include <linux/rcupdate.h>
 #include <linux/kallsyms.h>
+#include <linux/resource.h>
 #include <linux/module.h>
 #include <linux/mount.h>
 #include <linux/security.h>
 #include <linux/ptrace.h>
+#include <linux/cgroup.h>
 #include <linux/cpuset.h>
 #include <linux/audit.h>
 #include <linux/poll.h>
 #include <linux/nsproxy.h>
 #include <linux/oom.h>
 #include <linux/elf.h>
+#include <linux/pid_namespace.h>
 #include "internal.h"
 
 /* NOTE:
@@ -301,6 +304,78 @@ static int proc_oom_score(struct task_struct *task, char *buffer)
         return sprintf(buffer, "%lu\n", points);
 }
 
+struct limit_names {
+        char *name;
+        char *unit;
+};
+
+static const struct limit_names lnames[RLIM_NLIMITS] = {
+        [RLIMIT_CPU] = {"Max cpu time", "ms"},
+        [RLIMIT_FSIZE] = {"Max file size", "bytes"},
+        [RLIMIT_DATA] = {"Max data size", "bytes"},
+        [RLIMIT_STACK] = {"Max stack size", "bytes"},
+        [RLIMIT_CORE] = {"Max core file size", "bytes"},
+        [RLIMIT_RSS] = {"Max resident set", "bytes"},
+        [RLIMIT_NPROC] = {"Max processes", "processes"},
+        [RLIMIT_NOFILE] = {"Max open files", "files"},
+        [RLIMIT_MEMLOCK] = {"Max locked memory", "bytes"},
+        [RLIMIT_AS] = {"Max address space", "bytes"},
+        [RLIMIT_LOCKS] = {"Max file locks", "locks"},
+        [RLIMIT_SIGPENDING] = {"Max pending signals", "signals"},
+        [RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"},
+        [RLIMIT_NICE] = {"Max nice priority", NULL},
+        [RLIMIT_RTPRIO] = {"Max realtime priority", NULL},
+};
+
+/* Display limits for a process */
+static int proc_pid_limits(struct task_struct *task, char *buffer)
+{
+        unsigned int i;
+        int count = 0;
+        unsigned long flags;
+        char *bufptr = buffer;
+
+        struct rlimit rlim[RLIM_NLIMITS];
+
+        rcu_read_lock();
+        if (!lock_task_sighand(task,&flags)) {
+                rcu_read_unlock();
+                return 0;
+        }
+        memcpy(rlim, task->signal->rlim, sizeof(struct rlimit) * RLIM_NLIMITS);
+        unlock_task_sighand(task, &flags);
+        rcu_read_unlock();
+
+        /*
+         * print the file header
+         */
+        count += sprintf(&bufptr[count], "%-25s %-20s %-20s %-10s\n",
+                        "Limit", "Soft Limit", "Hard Limit", "Units");
+
+        for (i = 0; i < RLIM_NLIMITS; i++) {
+                if (rlim[i].rlim_cur == RLIM_INFINITY)
+                        count += sprintf(&bufptr[count], "%-25s %-20s ",
+                                         lnames[i].name, "unlimited");
+                else
+                        count += sprintf(&bufptr[count], "%-25s %-20lu ",
+                                         lnames[i].name, rlim[i].rlim_cur);
+
+                if (rlim[i].rlim_max == RLIM_INFINITY)
+                        count += sprintf(&bufptr[count], "%-20s ", "unlimited");
+                else
+                        count += sprintf(&bufptr[count], "%-20lu ",
+                                         rlim[i].rlim_max);
+
+                if (lnames[i].unit)
+                        count += sprintf(&bufptr[count], "%-10s\n",
+                                         lnames[i].unit);
+                else
+                        count += sprintf(&bufptr[count], "\n");
+        }
+
+        return count;
+}
+
 /************************************************************************/
 /*                       Here the fs part begins                        */
 /************************************************************************/
@@ -349,18 +424,21 @@ struct proc_mounts {
 static int mounts_open(struct inode *inode, struct file *file)
 {
         struct task_struct *task = get_proc_task(inode);
+        struct nsproxy *nsp;
         struct mnt_namespace *ns = NULL;
         struct proc_mounts *p;
         int ret = -EINVAL;
 
         if (task) {
-                task_lock(task);
-                if (task->nsproxy) {
-                        ns = task->nsproxy->mnt_ns;
+                rcu_read_lock();
+                nsp = task_nsproxy(task);
+                if (nsp) {
+                        ns = nsp->mnt_ns;
                         if (ns)
                                 get_mnt_ns(ns);
                 }
-                task_unlock(task);
+                rcu_read_unlock();
+
                 put_task_struct(task);
         }
 
@@ -423,16 +501,20 @@ static int mountstats_open(struct inode *inode, struct file *file)
 
         if (!ret) {
                 struct seq_file *m = file->private_data;
+                struct nsproxy *nsp;
                 struct mnt_namespace *mnt_ns = NULL;
                 struct task_struct *task = get_proc_task(inode);
 
                 if (task) {
-                        task_lock(task);
-                        if (task->nsproxy)
-                                mnt_ns = task->nsproxy->mnt_ns;
-                        if (mnt_ns)
-                                get_mnt_ns(mnt_ns);
-                        task_unlock(task);
+                        rcu_read_lock();
+                        nsp = task_nsproxy(task);
+                        if (nsp) {
+                                mnt_ns = nsp->mnt_ns;
+                                if (mnt_ns)
+                                        get_mnt_ns(mnt_ns);
+                        }
+                        rcu_read_unlock();
+
                         put_task_struct(task);
                 }
 
@@ -1437,7 +1519,7 @@ static int proc_readfd_common(struct file * filp, void * dirent,
         struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         struct task_struct *p = get_proc_task(inode);
-        unsigned int fd, tid, ino;
+        unsigned int fd, ino;
         int retval;
         struct files_struct * files;
         struct fdtable *fdt;
@@ -1446,7 +1528,6 @@ static int proc_readfd_common(struct file * filp, void * dirent,
         if (!p)
                 goto out_no_task;
         retval = 0;
-        tid = p->pid;
 
         fd = filp->f_pos;
         switch (fd) {
@@ -1681,7 +1762,6 @@ static int proc_pident_readdir(struct file *filp,
                 const struct pid_entry *ents, unsigned int nents)
 {
         int i;
-        int pid;
         struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         struct task_struct *task = get_proc_task(inode);
@@ -1694,7 +1774,6 @@ static int proc_pident_readdir(struct file *filp,
                 goto out_no_task;
 
         ret = 0;
-        pid = task->pid;
         i = filp->f_pos;
         switch (i) {
         case 0:
@@ -1928,14 +2007,14 @@ static int proc_self_readlink(struct dentry *dentry, char __user *buffer,
                               int buflen)
 {
         char tmp[PROC_NUMBUF];
-        sprintf(tmp, "%d", current->tgid);
+        sprintf(tmp, "%d", task_tgid_vnr(current));
         return vfs_readlink(dentry,buffer,buflen,tmp);
 }
 
 static void *proc_self_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
         char tmp[PROC_NUMBUF];
-        sprintf(tmp, "%d", current->tgid);
+        sprintf(tmp, "%d", task_tgid_vnr(current));
         return ERR_PTR(vfs_follow_link(nd,tmp));
 }
 
@@ -2101,6 +2180,7 @@ static const struct pid_entry tgid_base_stuff[] = {
         REG("environ",    S_IRUSR, environ),
         INF("auxv",       S_IRUSR, pid_auxv),
         INF("status",     S_IRUGO, pid_status),
+        INF("limits",     S_IRUSR, pid_limits),
 #ifdef CONFIG_SCHED_DEBUG
         REG("sched",      S_IRUGO|S_IWUSR, pid_sched),
 #endif
@@ -2130,9 +2210,12 @@ static const struct pid_entry tgid_base_stuff[] = {
 #ifdef CONFIG_SCHEDSTATS
         INF("schedstat",  S_IRUGO, pid_schedstat),
 #endif
-#ifdef CONFIG_CPUSETS
+#ifdef CONFIG_PROC_PID_CPUSET
         REG("cpuset",     S_IRUGO, cpuset),
 #endif
+#ifdef CONFIG_CGROUPS
+        REG("cgroup",  S_IRUGO, cgroup),
+#endif
         INF("oom_score",  S_IRUGO, oom_score),
         REG("oom_adj",    S_IRUGO|S_IWUSR, oom_adjust),
 #ifdef CONFIG_AUDITSYSCALL
@@ -2193,27 +2276,27 @@ static const struct inode_operations proc_tgid_base_inode_operations = {
  *       that no dcache entries will exist at process exit time it
  *       just makes it very unlikely that any will persist.
  */
-void proc_flush_task(struct task_struct *task)
+static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
 {
         struct dentry *dentry, *leader, *dir;
         char buf[PROC_NUMBUF];
         struct qstr name;
 
         name.name = buf;
-        name.len = snprintf(buf, sizeof(buf), "%d", task->pid);
-        dentry = d_hash_and_lookup(proc_mnt->mnt_root, &name);
+        name.len = snprintf(buf, sizeof(buf), "%d", pid);
+        dentry = d_hash_and_lookup(mnt->mnt_root, &name);
         if (dentry) {
                 shrink_dcache_parent(dentry);
                 d_drop(dentry);
                 dput(dentry);
         }
 
-        if (thread_group_leader(task))
+        if (tgid == 0)
                 goto out;
 
         name.name = buf;
-        name.len = snprintf(buf, sizeof(buf), "%d", task->tgid);
-        leader = d_hash_and_lookup(proc_mnt->mnt_root, &name);
+        name.len = snprintf(buf, sizeof(buf), "%d", tgid);
+        leader = d_hash_and_lookup(mnt->mnt_root, &name);
         if (!leader)
                 goto out;
 
@@ -2224,7 +2307,7 @@ void proc_flush_task(struct task_struct *task)
                 goto out_put_leader;
 
         name.name = buf;
-        name.len = snprintf(buf, sizeof(buf), "%d", task->pid);
+        name.len = snprintf(buf, sizeof(buf), "%d", pid);
         dentry = d_hash_and_lookup(dir, &name);
         if (dentry) {
                 shrink_dcache_parent(dentry);
@@ -2239,6 +2322,36 @@ out:
         return;
 }
 
+/*
+ * when flushing dentries from proc one need to flush them from global
+ * proc (proc_mnt) and from all the namespaces' procs this task was seen
+ * in. this call is supposed to make all this job.
+ */
+
+void proc_flush_task(struct task_struct *task)
+{
+        int i, leader;
+        struct pid *pid, *tgid;
+        struct upid *upid;
+
+        leader = thread_group_leader(task);
+        proc_flush_task_mnt(proc_mnt, task->pid, leader ? task->tgid : 0);
+        pid = task_pid(task);
+        if (pid->level == 0)
+                return;
+
+        tgid = task_tgid(task);
+        for (i = 1; i <= pid->level; i++) {
+                upid = &pid->numbers[i];
+                proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr,
+                                leader ? 0 : tgid->numbers[i].nr);
+        }
+
+        upid = &pid->numbers[pid->level];
+        if (upid->nr == 1)
+                pid_ns_release_proc(upid->ns);
+}
+
 static struct dentry *proc_pid_instantiate(struct inode *dir,
                                            struct dentry * dentry,
                                            struct task_struct *task, const void *ptr)
@@ -2274,6 +2387,7 @@ struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct
         struct dentry *result = ERR_PTR(-ENOENT);
         struct task_struct *task;
         unsigned tgid;
+        struct pid_namespace *ns;
 
         result = proc_base_lookup(dir, dentry);
         if (!IS_ERR(result) || PTR_ERR(result) != -ENOENT)
@@ -2283,8 +2397,9 @@ struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct
         if (tgid == ~0U)
                 goto out;
 
+        ns = dentry->d_sb->s_fs_info;
         rcu_read_lock();
-        task = find_task_by_pid(tgid);
+        task = find_task_by_pid_ns(tgid, ns);
         if (task)
                 get_task_struct(task);
         rcu_read_unlock();
@@ -2301,7 +2416,8 @@ out:
  * Find the first task with tgid >= tgid
  *
  */
-static struct task_struct *next_tgid(unsigned int tgid)
+static struct task_struct *next_tgid(unsigned int tgid,
+                struct pid_namespace *ns)
 {
         struct task_struct *task;
         struct pid *pid;
@@ -2309,9 +2425,9 @@ static struct task_struct *next_tgid(unsigned int tgid)
         rcu_read_lock();
 retry:
         task = NULL;
-        pid = find_ge_pid(tgid);
+        pid = find_ge_pid(tgid, ns);
         if (pid) {
-                tgid = pid->nr + 1;
+                tgid = pid_nr_ns(pid, ns) + 1;
                 task = pid_task(pid, PIDTYPE_PID);
                 /* What we to know is if the pid we have find is the
                  * pid of a thread_group_leader.  Testing for task
@@ -2351,6 +2467,7 @@ int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir)
         struct task_struct *reaper = get_proc_task(filp->f_path.dentry->d_inode);
         struct task_struct *task;
         int tgid;
+        struct pid_namespace *ns;
 
         if (!reaper)
                 goto out_no_task;
@@ -2361,11 +2478,12 @@ int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir)
                         goto out;
         }
 
+        ns = filp->f_dentry->d_sb->s_fs_info;
         tgid = filp->f_pos - TGID_OFFSET;
-        for (task = next_tgid(tgid);
+        for (task = next_tgid(tgid, ns);
              task;
-             put_task_struct(task), task = next_tgid(tgid + 1)) {
-                tgid = task->pid;
+             put_task_struct(task), task = next_tgid(tgid + 1, ns)) {
+                tgid = task_pid_nr_ns(task, ns);
                 filp->f_pos = tgid + TGID_OFFSET;
                 if (proc_pid_fill_cache(filp, dirent, filldir, task, tgid) < 0) {
                         put_task_struct(task);
@@ -2388,6 +2506,7 @@ static const struct pid_entry tid_base_stuff[] = {
         REG("environ",   S_IRUSR, environ),
         INF("auxv",      S_IRUSR, pid_auxv),
         INF("status",    S_IRUGO, pid_status),
+        INF("limits",    S_IRUSR, pid_limits),
 #ifdef CONFIG_SCHED_DEBUG
         REG("sched",     S_IRUGO|S_IWUSR, pid_sched),
 #endif
@@ -2416,9 +2535,12 @@ static const struct pid_entry tid_base_stuff[] = {
 #ifdef CONFIG_SCHEDSTATS
         INF("schedstat", S_IRUGO, pid_schedstat),
 #endif
-#ifdef CONFIG_CPUSETS
+#ifdef CONFIG_PROC_PID_CPUSET
         REG("cpuset",    S_IRUGO, cpuset),
 #endif
+#ifdef CONFIG_CGROUPS
+        REG("cgroup",  S_IRUGO, cgroup),
+#endif
         INF("oom_score", S_IRUGO, oom_score),
         REG("oom_adj",   S_IRUGO|S_IWUSR, oom_adjust),
 #ifdef CONFIG_AUDITSYSCALL
@@ -2486,6 +2608,7 @@ static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry
         struct task_struct *task;
         struct task_struct *leader = get_proc_task(dir);
         unsigned tid;
+        struct pid_namespace *ns;
 
         if (!leader)
                 goto out_no_task;
@@ -2494,14 +2617,15 @@ static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry
         if (tid == ~0U)
                 goto out;
 
+        ns = dentry->d_sb->s_fs_info;
         rcu_read_lock();
-        task = find_task_by_pid(tid);
+        task = find_task_by_pid_ns(tid, ns);
         if (task)
                 get_task_struct(task);
         rcu_read_unlock();
         if (!task)
                 goto out;
-        if (leader->tgid != task->tgid)
+        if (!same_thread_group(leader, task))
                 goto out_drop_task;
 
         result = proc_task_instantiate(dir, dentry, task, NULL);
@@ -2526,14 +2650,14 @@ out_no_task:
  * threads past it.
  */
 static struct task_struct *first_tid(struct task_struct *leader,
-                                        int tid, int nr)
+                int tid, int nr, struct pid_namespace *ns)
 {
         struct task_struct *pos;
 
         rcu_read_lock();
         /* Attempt to start with the pid of a thread */
         if (tid && (nr > 0)) {
-                pos = find_task_by_pid(tid);
+                pos = find_task_by_pid_ns(tid, ns);
                 if (pos && (pos->group_leader == leader))
                         goto found;
         }
@@ -2602,6 +2726,7 @@ static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldi
         ino_t ino;
         int tid;
         unsigned long pos = filp->f_pos;  /* avoiding "long long" filp->f_pos */
+        struct pid_namespace *ns;
 
         task = get_proc_task(inode);
         if (!task)
@@ -2635,12 +2760,13 @@ static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldi
         /* f_version caches the tgid value that the last readdir call couldn't
          * return. lseek aka telldir automagically resets f_version to 0.
          */
+        ns = filp->f_dentry->d_sb->s_fs_info;
         tid = (int)filp->f_version;
         filp->f_version = 0;
-        for (task = first_tid(leader, tid, pos - 2);
+        for (task = first_tid(leader, tid, pos - 2, ns);
              task;
              task = next_tid(task), pos++) {
-                tid = task->pid;
+                tid = task_pid_nr_ns(task, ns);
                 if (proc_task_fill_cache(filp, dirent, filldir, task, tid) < 0) {
                         /* returning this tgid failed, save it as the first
                          * pid for the next readir call */
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 99ca00485fc3..abe6a3f04368 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -448,7 +448,7 @@ out_mod:
         return NULL;
 }                       
 
-int proc_fill_super(struct super_block *s, void *data, int silent)
+int proc_fill_super(struct super_block *s)
 {
         struct inode * root_inode;
 
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index d6dc72c78bc1..e0d064e9764e 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -91,7 +91,8 @@ static int loadavg_read_proc(char *page, char **start, off_t off,
                 LOAD_INT(a), LOAD_FRAC(a),
                 LOAD_INT(b), LOAD_FRAC(b),
                 LOAD_INT(c), LOAD_FRAC(c),
-                nr_running(), nr_threads, current->nsproxy->pid_ns->last_pid);
+                nr_running(), nr_threads,
+                task_active_pid_ns(current)->last_pid);
         return proc_calc_metrics(page, start, off, count, eof, len);
 }
 
diff --git a/fs/proc/root.c b/fs/proc/root.c
index cf3046638b09..ec9cb3b6c93b 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -18,32 +18,90 @@
 #include <linux/bitops.h>
 #include <linux/smp_lock.h>
 #include <linux/mount.h>
+#include <linux/pid_namespace.h>
 
 #include "internal.h"
 
 struct proc_dir_entry *proc_bus, *proc_root_fs, *proc_root_driver;
 
+static int proc_test_super(struct super_block *sb, void *data)
+{
+        return sb->s_fs_info == data;
+}
+
+static int proc_set_super(struct super_block *sb, void *data)
+{
+        struct pid_namespace *ns;
+
+        ns = (struct pid_namespace *)data;
+        sb->s_fs_info = get_pid_ns(ns);
+        return set_anon_super(sb, NULL);
+}
+
 static int proc_get_sb(struct file_system_type *fs_type,
         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
+        int err;
+        struct super_block *sb;
+        struct pid_namespace *ns;
+        struct proc_inode *ei;
+
         if (proc_mnt) {
                 /* Seed the root directory with a pid so it doesn't need
                  * to be special in base.c.  I would do this earlier but
                  * the only task alive when /proc is mounted the first time
                  * is the init_task and it doesn't have any pids.
                  */
-                struct proc_inode *ei;
                 ei = PROC_I(proc_mnt->mnt_sb->s_root->d_inode);
                 if (!ei->pid)
                         ei->pid = find_get_pid(1);
         }
-        return get_sb_single(fs_type, flags, data, proc_fill_super, mnt);
+
+        if (flags & MS_KERNMOUNT)
+                ns = (struct pid_namespace *)data;
+        else
+                ns = current->nsproxy->pid_ns;
+
+        sb = sget(fs_type, proc_test_super, proc_set_super, ns);
+        if (IS_ERR(sb))
+                return PTR_ERR(sb);
+
+        if (!sb->s_root) {
+                sb->s_flags = flags;
+                err = proc_fill_super(sb);
+                if (err) {
+                        up_write(&sb->s_umount);
+                        deactivate_super(sb);
+                        return err;
+                }
+
+                ei = PROC_I(sb->s_root->d_inode);
+                if (!ei->pid) {
+                        rcu_read_lock();
+                        ei->pid = get_pid(find_pid_ns(1, ns));
+                        rcu_read_unlock();
+                }
+
+                sb->s_flags |= MS_ACTIVE;
+                ns->proc_mnt = mnt;
+        }
+
+        return simple_set_mnt(mnt, sb);
+}
+
+static void proc_kill_sb(struct super_block *sb)
+{
+        struct pid_namespace *ns;
+
+        ns = (struct pid_namespace *)sb->s_fs_info;
+        kill_anon_super(sb);
+        put_pid_ns(ns);
 }
 
 static struct file_system_type proc_fs_type = {
         .name           = "proc",
         .get_sb         = proc_get_sb,
-        .kill_sb        = kill_anon_super,
+        .kill_sb        = proc_kill_sb,
 };
 
 void __init proc_root_init(void)
@@ -54,12 +112,13 @@ void __init proc_root_init(void)
         err = register_filesystem(&proc_fs_type);
         if (err)
                 return;
-        proc_mnt = kern_mount(&proc_fs_type);
+        proc_mnt = kern_mount_data(&proc_fs_type, &init_pid_ns);
         err = PTR_ERR(proc_mnt);
         if (IS_ERR(proc_mnt)) {
                 unregister_filesystem(&proc_fs_type);
                 return;
         }
+
         proc_misc_init();
 
         proc_net_init();
@@ -153,6 +212,22 @@ struct proc_dir_entry proc_root = {
         .parent         = &proc_root,
 };
 
+int pid_ns_prepare_proc(struct pid_namespace *ns)
+{
+        struct vfsmount *mnt;
+
+        mnt = kern_mount_data(&proc_fs_type, ns);
+        if (IS_ERR(mnt))
+                return PTR_ERR(mnt);
+
+        return 0;
+}
+
+void pid_ns_release_proc(struct pid_namespace *ns)
+{
+        mntput(ns->proc_mnt);
+}
+
 EXPORT_SYMBOL(proc_symlink);
 EXPORT_SYMBOL(proc_mkdir);
 EXPORT_SYMBOL(create_proc_entry);