11 files changed, 132 insertions, 71 deletions

diff --git a/kernel/capability.c b/kernel/capability.c
index f02ad47320b9..d4377c5a36c9 100644
--- a/kernel/capability.c
+++ b/kernel/capability.c
@@ -62,8 +62,9 @@ asmlinkage long sys_capget(cap_user_header_t header, cap_user_data_t dataptr)
         spin_lock(&task_capability_lock);
         read_lock(&tasklist_lock);
 
-        if (pid && pid != current->pid) {
-                target = find_task_by_pid(pid);
+        if (pid && pid != task_pid_vnr(current)) {
+                target = find_task_by_pid_ns(pid,
+                                current->nsproxy->pid_ns);
                 if (!target) {
                         ret = -ESRCH;
                         goto out;
@@ -96,7 +97,7 @@ static inline int cap_set_pg(int pgrp_nr, kernel_cap_t *effective,
         int found = 0;
         struct pid *pgrp;
 
-        pgrp = find_pid(pgrp_nr);
+        pgrp = find_pid_ns(pgrp_nr, current->nsproxy->pid_ns);
         do_each_pid_task(pgrp, PIDTYPE_PGID, g) {
                 target = g;
                 while_each_thread(g, target) {
@@ -185,7 +186,7 @@ asmlinkage long sys_capset(cap_user_header_t header, const cap_user_data_t data)
         if (get_user(pid, &header->pid))
                 return -EFAULT;
 
-        if (pid && pid != current->pid && !capable(CAP_SETPCAP))
+        if (pid && pid != task_pid_vnr(current) && !capable(CAP_SETPCAP))
                 return -EPERM;
 
         if (copy_from_user(&effective, &data->effective, sizeof(effective)) ||
@@ -196,8 +197,9 @@ asmlinkage long sys_capset(cap_user_header_t header, const cap_user_data_t data)
         spin_lock(&task_capability_lock);
         read_lock(&tasklist_lock);
 
-        if (pid > 0 && pid != current->pid) {
-                target = find_task_by_pid(pid);
+        if (pid > 0 && pid != task_pid_vnr(current)) {
+                target = find_task_by_pid_ns(pid,
+                                current->nsproxy->pid_ns);
                 if (!target) {
                         ret = -ESRCH;
                         goto out;
diff --git a/kernel/exit.c b/kernel/exit.c
index 567909fd6be4..68d27039ef7d 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -1112,15 +1112,17 @@ asmlinkage void sys_exit_group(int error_code)
 static int eligible_child(pid_t pid, int options, struct task_struct *p)
 {
         int err;
+        struct pid_namespace *ns;
 
+        ns = current->nsproxy->pid_ns;
         if (pid > 0) {
-                if (p->pid != pid)
+                if (task_pid_nr_ns(p, ns) != pid)
                         return 0;
         } else if (!pid) {
-                if (task_pgrp_nr(p) != task_pgrp_nr(current))
+                if (task_pgrp_nr_ns(p, ns) != task_pgrp_vnr(current))
                         return 0;
         } else if (pid != -1) {
-                if (task_pgrp_nr(p) != -pid)
+                if (task_pgrp_nr_ns(p, ns) != -pid)
                         return 0;
         }
 
@@ -1190,9 +1192,12 @@ static int wait_task_zombie(struct task_struct *p, int noreap,
 {
         unsigned long state;
         int retval, status, traced;
+        struct pid_namespace *ns;
+
+        ns = current->nsproxy->pid_ns;
 
         if (unlikely(noreap)) {
-                pid_t pid = p->pid;
+                pid_t pid = task_pid_nr_ns(p, ns);
                 uid_t uid = p->uid;
                 int exit_code = p->exit_code;
                 int why, status;
@@ -1311,11 +1316,11 @@ static int wait_task_zombie(struct task_struct *p, int noreap,
                         retval = put_user(status, &infop->si_status);
         }
         if (!retval && infop)
-                retval = put_user(p->pid, &infop->si_pid);
+                retval = put_user(task_pid_nr_ns(p, ns), &infop->si_pid);
         if (!retval && infop)
                 retval = put_user(p->uid, &infop->si_uid);
         if (!retval)
-                retval = p->pid;
+                retval = task_pid_nr_ns(p, ns);
 
         if (traced) {
                 write_lock_irq(&tasklist_lock);
@@ -1352,6 +1357,7 @@ static int wait_task_stopped(struct task_struct *p, int delayed_group_leader,
                              int __user *stat_addr, struct rusage __user *ru)
 {
         int retval, exit_code;
+        struct pid_namespace *ns;
 
         if (!p->exit_code)
                 return 0;
@@ -1370,11 +1376,12 @@ static int wait_task_stopped(struct task_struct *p, int delayed_group_leader,
          * keep holding onto the tasklist_lock while we call getrusage and
          * possibly take page faults for user memory.
          */
+        ns = current->nsproxy->pid_ns;
         get_task_struct(p);
         read_unlock(&tasklist_lock);
 
         if (unlikely(noreap)) {
-                pid_t pid = p->pid;
+                pid_t pid = task_pid_nr_ns(p, ns);
                 uid_t uid = p->uid;
                 int why = (p->ptrace & PT_PTRACED) ? CLD_TRAPPED : CLD_STOPPED;
 
@@ -1445,11 +1452,11 @@ bail_ref:
         if (!retval && infop)
                 retval = put_user(exit_code, &infop->si_status);
         if (!retval && infop)
-                retval = put_user(p->pid, &infop->si_pid);
+                retval = put_user(task_pid_nr_ns(p, ns), &infop->si_pid);
         if (!retval && infop)
                 retval = put_user(p->uid, &infop->si_uid);
         if (!retval)
-                retval = p->pid;
+                retval = task_pid_nr_ns(p, ns);
         put_task_struct(p);
 
         BUG_ON(!retval);
@@ -1469,6 +1476,7 @@ static int wait_task_continued(struct task_struct *p, int noreap,
         int retval;
         pid_t pid;
         uid_t uid;
+        struct pid_namespace *ns;
 
         if (!(p->signal->flags & SIGNAL_STOP_CONTINUED))
                 return 0;
@@ -1483,7 +1491,8 @@ static int wait_task_continued(struct task_struct *p, int noreap,
                 p->signal->flags &= ~SIGNAL_STOP_CONTINUED;
         spin_unlock_irq(&p->sighand->siglock);
 
-        pid = p->pid;
+        ns = current->nsproxy->pid_ns;
+        pid = task_pid_nr_ns(p, ns);
         uid = p->uid;
         get_task_struct(p);
         read_unlock(&tasklist_lock);
@@ -1494,7 +1503,7 @@ static int wait_task_continued(struct task_struct *p, int noreap,
                 if (!retval && stat_addr)
                         retval = put_user(0xffff, stat_addr);
                 if (!retval)
-                        retval = p->pid;
+                        retval = task_pid_nr_ns(p, ns);
         } else {
                 retval = wait_noreap_copyout(p, pid, uid,
                                              CLD_CONTINUED, SIGCONT,
diff --git a/kernel/fork.c b/kernel/fork.c
index ce9297e4e7d4..a794bfcf6003 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -950,7 +950,7 @@ asmlinkage long sys_set_tid_address(int __user *tidptr)
 {
         current->clear_child_tid = tidptr;
 
-        return current->pid;
+        return task_pid_vnr(current);
 }
 
 static inline void rt_mutex_init_task(struct task_struct *p)
diff --git a/kernel/futex.c b/kernel/futex.c
index e45a65e41686..86b2600381b6 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -53,6 +53,9 @@
 #include <linux/signal.h>
 #include <linux/module.h>
 #include <linux/magic.h>
+#include <linux/pid.h>
+#include <linux/nsproxy.h>
+
 #include <asm/futex.h>
 
 #include "rtmutex_common.h"
@@ -443,7 +446,8 @@ static struct task_struct * futex_find_get_task(pid_t pid)
         struct task_struct *p;
 
         rcu_read_lock();
-        p = find_task_by_pid(pid);
+        p = find_task_by_pid_ns(pid,
+                        current->nsproxy->pid_ns);
 
         if (!p || ((current->euid != p->euid) && (current->euid != p->uid)))
                 p = ERR_PTR(-ESRCH);
@@ -653,7 +657,7 @@ static int wake_futex_pi(u32 __user *uaddr, u32 uval, struct futex_q *this)
         if (!(uval & FUTEX_OWNER_DIED)) {
                 int ret = 0;
 
-                newval = FUTEX_WAITERS | new_owner->pid;
+                newval = FUTEX_WAITERS | task_pid_vnr(new_owner);
 
                 curval = cmpxchg_futex_value_locked(uaddr, uval, newval);
 
@@ -1106,7 +1110,7 @@ static void unqueue_me_pi(struct futex_q *q)
 static int fixup_pi_state_owner(u32 __user *uaddr, struct futex_q *q,
                                 struct task_struct *curr)
 {
-        u32 newtid = curr->pid | FUTEX_WAITERS;
+        u32 newtid = task_pid_vnr(curr) | FUTEX_WAITERS;
         struct futex_pi_state *pi_state = q->pi_state;
         u32 uval, curval, newval;
         int ret;
@@ -1368,7 +1372,7 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
          * (by doing a 0 -> TID atomic cmpxchg), while holding all
          * the locks. It will most likely not succeed.
          */
-        newval = current->pid;
+        newval = task_pid_vnr(current);
 
         curval = cmpxchg_futex_value_locked(uaddr, 0, newval);
 
@@ -1379,7 +1383,7 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
          * Detect deadlocks. In case of REQUEUE_PI this is a valid
          * situation and we return success to user space.
          */
-        if (unlikely((curval & FUTEX_TID_MASK) == current->pid)) {
+        if (unlikely((curval & FUTEX_TID_MASK) == task_pid_vnr(current))) {
                 ret = -EDEADLK;
                 goto out_unlock_release_sem;
         }
@@ -1408,7 +1412,7 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
          */
         if (unlikely(ownerdied || !(curval & FUTEX_TID_MASK))) {
                 /* Keep the OWNER_DIED bit */
-                newval = (curval & ~FUTEX_TID_MASK) | current->pid;
+                newval = (curval & ~FUTEX_TID_MASK) | task_pid_vnr(current);
                 ownerdied = 0;
                 lock_taken = 1;
         }
@@ -1587,7 +1591,7 @@ retry:
         /*
          * We release only a lock we actually own:
          */
-        if ((uval & FUTEX_TID_MASK) != current->pid)
+        if ((uval & FUTEX_TID_MASK) != task_pid_vnr(current))
                 return -EPERM;
         /*
          * First take all the futex related locks:
@@ -1608,7 +1612,7 @@ retry_unlocked:
          * anyone else up:
          */
         if (!(uval & FUTEX_OWNER_DIED))
-                uval = cmpxchg_futex_value_locked(uaddr, current->pid, 0);
+                uval = cmpxchg_futex_value_locked(uaddr, task_pid_vnr(current), 0);
 
 
         if (unlikely(uval == -EFAULT))
@@ -1617,7 +1621,7 @@ retry_unlocked:
          * Rare case: we managed to release the lock atomically,
          * no need to wake anyone else up:
          */
-        if (unlikely(uval == current->pid))
+        if (unlikely(uval == task_pid_vnr(current)))
                 goto out_unlock;
 
         /*
@@ -1854,7 +1858,8 @@ sys_get_robust_list(int pid, struct robust_list_head __user * __user *head_ptr,
 
                 ret = -ESRCH;
                 rcu_read_lock();
-                p = find_task_by_pid(pid);
+                p = find_task_by_pid_ns(pid,
+                                current->nsproxy->pid_ns);
                 if (!p)
                         goto err_unlock;
                 ret = -EPERM;
@@ -1887,7 +1892,7 @@ retry:
         if (get_user(uval, uaddr))
                 return -1;
 
-        if ((uval & FUTEX_TID_MASK) == curr->pid) {
+        if ((uval & FUTEX_TID_MASK) == task_pid_vnr(curr)) {
                 /*
                  * Ok, this dying thread is truly holding a futex
                  * of interest. Set the OWNER_DIED bit atomically
diff --git a/kernel/futex_compat.c b/kernel/futex_compat.c
index 2c2e2954b713..cc098e1de960 100644
--- a/kernel/futex_compat.c
+++ b/kernel/futex_compat.c
@@ -8,6 +8,7 @@
 
 #include <linux/linkage.h>
 #include <linux/compat.h>
+#include <linux/nsproxy.h>
 #include <linux/futex.h>
 
 #include <asm/uaccess.h>
@@ -124,7 +125,8 @@ compat_sys_get_robust_list(int pid, compat_uptr_t __user *head_ptr,
 
                 ret = -ESRCH;
                 read_lock(&tasklist_lock);
-                p = find_task_by_pid(pid);
+                p = find_task_by_pid_ns(pid,
+                                current->nsproxy->pid_ns);
                 if (!p)
                         goto err_unlock;
                 ret = -EPERM;
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index a73ebd3b9d4c..66e99eb2d8a6 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -19,6 +19,7 @@
 #include <linux/security.h>
 #include <linux/signal.h>
 #include <linux/audit.h>
+#include <linux/pid_namespace.h>
 
 #include <asm/pgtable.h>
 #include <asm/uaccess.h>
@@ -443,7 +444,8 @@ struct task_struct *ptrace_get_task_struct(pid_t pid)
                 return ERR_PTR(-EPERM);
 
         read_lock(&tasklist_lock);
-        child = find_task_by_pid(pid);
+        child = find_task_by_pid_ns(pid,
+                        current->nsproxy->pid_ns);
         if (child)
                 get_task_struct(child);
 
diff --git a/kernel/sched.c b/kernel/sched.c
index 72a2a16e2214..4ac56fe3c394 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -44,6 +44,7 @@
 #include <linux/vmalloc.h>
 #include <linux/blkdev.h>
 #include <linux/delay.h>
+#include <linux/pid_namespace.h>
 #include <linux/smp.h>
 #include <linux/threads.h>
 #include <linux/timer.h>
@@ -1876,7 +1877,7 @@ asmlinkage void schedule_tail(struct task_struct *prev)
         preempt_enable();
 #endif
         if (current->set_child_tid)
-                put_user(current->pid, current->set_child_tid);
+                put_user(task_pid_vnr(current), current->set_child_tid);
 }
 
 /*
@@ -4167,7 +4168,8 @@ struct task_struct *idle_task(int cpu)
  */
 static struct task_struct *find_process_by_pid(pid_t pid)
 {
-        return pid ? find_task_by_pid(pid) : current;
+        return pid ?
+                find_task_by_pid_ns(pid, current->nsproxy->pid_ns) : current;
 }
 
 /* Actually do priority change: must hold rq lock. */
diff --git a/kernel/signal.c b/kernel/signal.c
index 98923882ba57..d809cdd6c0f1 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -694,7 +694,7 @@ static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
                         q->info.si_signo = sig;
                         q->info.si_errno = 0;
                         q->info.si_code = SI_USER;
-                        q->info.si_pid = current->pid;
+                        q->info.si_pid = task_pid_vnr(current);
                         q->info.si_uid = current->uid;
                         break;
                 case (unsigned long) SEND_SIG_PRIV:
@@ -1089,7 +1089,7 @@ kill_proc_info(int sig, struct siginfo *info, pid_t pid)
 {
         int error;
         rcu_read_lock();
-        error = kill_pid_info(sig, info, find_pid(pid));
+        error = kill_pid_info(sig, info, find_vpid(pid));
         rcu_read_unlock();
         return error;
 }
@@ -1160,9 +1160,9 @@ static int kill_something_info(int sig, struct siginfo *info, int pid)
                 read_unlock(&tasklist_lock);
                 ret = count ? retval : -ESRCH;
         } else if (pid < 0) {
-                ret = kill_pgrp_info(sig, info, find_pid(-pid));
+                ret = kill_pgrp_info(sig, info, find_vpid(-pid));
         } else {
-                ret = kill_pid_info(sig, info, find_pid(pid));
+                ret = kill_pid_info(sig, info, find_vpid(pid));
         }
         rcu_read_unlock();
         return ret;
@@ -1266,7 +1266,12 @@ EXPORT_SYMBOL(kill_pid);
 int
 kill_proc(pid_t pid, int sig, int priv)
 {
-        return kill_proc_info(sig, __si_special(priv), pid);
+        int ret;
+
+        rcu_read_lock();
+        ret = kill_pid_info(sig, __si_special(priv), find_pid(pid));
+        rcu_read_unlock();
+        return ret;
 }
 
 /*
@@ -1443,7 +1448,22 @@ void do_notify_parent(struct task_struct *tsk, int sig)
 
         info.si_signo = sig;
         info.si_errno = 0;
-        info.si_pid = tsk->pid;
+        /*
+         * we are under tasklist_lock here so our parent is tied to
+         * us and cannot exit and release its namespace.
+         *
+         * the only it can is to switch its nsproxy with sys_unshare,
+         * bu uncharing pid namespaces is not allowed, so we'll always
+         * see relevant namespace
+         *
+         * write_lock() currently calls preempt_disable() which is the
+         * same as rcu_read_lock(), but according to Oleg, this is not
+         * correct to rely on this
+         */
+        rcu_read_lock();
+        info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
+        rcu_read_unlock();
+
         info.si_uid = tsk->uid;
 
         /* FIXME: find out whether or not this is supposed to be c*time. */
@@ -1508,7 +1528,13 @@ static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
 
         info.si_signo = SIGCHLD;
         info.si_errno = 0;
-        info.si_pid = tsk->pid;
+        /*
+         * see comment in do_notify_parent() abot the following 3 lines
+         */
+        rcu_read_lock();
+        info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
+        rcu_read_unlock();
+
         info.si_uid = tsk->uid;
 
         /* FIXME: find out whether or not this is supposed to be c*time. */
@@ -1634,7 +1660,7 @@ void ptrace_notify(int exit_code)
         memset(&info, 0, sizeof info);
         info.si_signo = SIGTRAP;
         info.si_code = exit_code;
-        info.si_pid = current->pid;
+        info.si_pid = task_pid_vnr(current);
         info.si_uid = current->uid;
 
         /* Let the debugger run.  */
@@ -1804,7 +1830,7 @@ relock:
                                 info->si_signo = signr;
                                 info->si_errno = 0;
                                 info->si_code = SI_USER;
-                                info->si_pid = current->parent->pid;
+                                info->si_pid = task_pid_vnr(current->parent);
                                 info->si_uid = current->parent->uid;
                         }
 
@@ -2191,7 +2217,7 @@ sys_kill(int pid, int sig)
         info.si_signo = sig;
         info.si_errno = 0;
         info.si_code = SI_USER;
-        info.si_pid = current->tgid;
+        info.si_pid = task_tgid_vnr(current);
         info.si_uid = current->uid;
 
         return kill_something_info(sig, &info, pid);
@@ -2207,12 +2233,12 @@ static int do_tkill(int tgid, int pid, int sig)
         info.si_signo = sig;
         info.si_errno = 0;
         info.si_code = SI_TKILL;
-        info.si_pid = current->tgid;
+        info.si_pid = task_tgid_vnr(current);
         info.si_uid = current->uid;
 
         read_lock(&tasklist_lock);
-        p = find_task_by_pid(pid);
-        if (p && (tgid <= 0 || p->tgid == tgid)) {
+        p = find_task_by_pid_ns(pid, current->nsproxy->pid_ns);
+        if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
                 error = check_kill_permission(sig, &info, p);
                 /*
                  * The null signal is a permissions and process existence
diff --git a/kernel/sys.c b/kernel/sys.c
index 4cfa213a5ac2..23620d52cf37 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -152,7 +152,8 @@ asmlinkage long sys_setpriority(int which, int who, int niceval)
         switch (which) {
                 case PRIO_PROCESS:
                         if (who)
-                                p = find_task_by_pid(who);
+                                p = find_task_by_pid_ns(who,
+                                                current->nsproxy->pid_ns);
                         else
                                 p = current;
                         if (p)
@@ -160,7 +161,7 @@ asmlinkage long sys_setpriority(int which, int who, int niceval)
                         break;
                 case PRIO_PGRP:
                         if (who)
-                                pgrp = find_pid(who);
+                                pgrp = find_vpid(who);
                         else
                                 pgrp = task_pgrp(current);
                         do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
@@ -209,7 +210,8 @@ asmlinkage long sys_getpriority(int which, int who)
         switch (which) {
                 case PRIO_PROCESS:
                         if (who)
-                                p = find_task_by_pid(who);
+                                p = find_task_by_pid_ns(who,
+                                                current->nsproxy->pid_ns);
                         else
                                 p = current;
                         if (p) {
@@ -220,7 +222,7 @@ asmlinkage long sys_getpriority(int which, int who)
                         break;
                 case PRIO_PGRP:
                         if (who)
-                                pgrp = find_pid(who);
+                                pgrp = find_vpid(who);
                         else
                                 pgrp = task_pgrp(current);
                         do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
@@ -917,9 +919,10 @@ asmlinkage long sys_setpgid(pid_t pid, pid_t pgid)
         struct task_struct *p;
         struct task_struct *group_leader = current->group_leader;
         int err = -EINVAL;
+        struct pid_namespace *ns;
 
         if (!pid)
-                pid = group_leader->pid;
+                pid = task_pid_vnr(group_leader);
         if (!pgid)
                 pgid = pid;
         if (pgid < 0)
@@ -928,10 +931,12 @@ asmlinkage long sys_setpgid(pid_t pid, pid_t pgid)
         /* From this point forward we keep holding onto the tasklist lock
          * so that our parent does not change from under us. -DaveM
          */
+        ns = current->nsproxy->pid_ns;
+
         write_lock_irq(&tasklist_lock);
 
         err = -ESRCH;
-        p = find_task_by_pid(pid);
+        p = find_task_by_pid_ns(pid, ns);
         if (!p)
                 goto out;
 
@@ -957,9 +962,9 @@ asmlinkage long sys_setpgid(pid_t pid, pid_t pgid)
                 goto out;
 
         if (pgid != pid) {
-                struct task_struct *g =
-                        find_task_by_pid_type(PIDTYPE_PGID, pgid);
+                struct task_struct *g;
 
+                g = find_task_by_pid_type_ns(PIDTYPE_PGID, pgid, ns);
                 if (!g || task_session(g) != task_session(group_leader))
                         goto out;
         }
@@ -968,10 +973,13 @@ asmlinkage long sys_setpgid(pid_t pid, pid_t pgid)
         if (err)
                 goto out;
 
-        if (task_pgrp_nr(p) != pgid) {
+        if (task_pgrp_nr_ns(p, ns) != pgid) {
+                struct pid *pid;
+
                 detach_pid(p, PIDTYPE_PGID);
-                p->signal->pgrp = pgid;
-                attach_pid(p, PIDTYPE_PGID, find_pid(pgid));
+                pid = find_vpid(pgid);
+                attach_pid(p, PIDTYPE_PGID, pid);
+                p->signal->pgrp = pid_nr(pid);
         }
 
         err = 0;
@@ -984,19 +992,21 @@ out:
 asmlinkage long sys_getpgid(pid_t pid)
 {
         if (!pid)
-                return task_pgrp_nr(current);
+                return task_pgrp_vnr(current);
         else {
                 int retval;
                 struct task_struct *p;
+                struct pid_namespace *ns;
 
-                read_lock(&tasklist_lock);
-                p = find_task_by_pid(pid);
+                ns = current->nsproxy->pid_ns;
 
+                read_lock(&tasklist_lock);
+                p = find_task_by_pid_ns(pid, ns);
                 retval = -ESRCH;
                 if (p) {
                         retval = security_task_getpgid(p);
                         if (!retval)
-                                retval = task_pgrp_nr(p);
+                                retval = task_pgrp_nr_ns(p, ns);
                 }
                 read_unlock(&tasklist_lock);
                 return retval;
@@ -1008,7 +1018,7 @@ asmlinkage long sys_getpgid(pid_t pid)
 asmlinkage long sys_getpgrp(void)
 {
         /* SMP - assuming writes are word atomic this is fine */
-        return task_pgrp_nr(current);
+        return task_pgrp_vnr(current);
 }
 
 #endif
@@ -1016,19 +1026,21 @@ asmlinkage long sys_getpgrp(void)
 asmlinkage long sys_getsid(pid_t pid)
 {
         if (!pid)
-                return task_session_nr(current);
+                return task_session_vnr(current);
         else {
                 int retval;
                 struct task_struct *p;
+                struct pid_namespace *ns;
 
-                read_lock(&tasklist_lock);
-                p = find_task_by_pid(pid);
+                ns = current->nsproxy->pid_ns;
 
+                read_lock(&tasklist_lock);
+                p = find_task_by_pid_ns(pid, ns);
                 retval = -ESRCH;
                 if (p) {
                         retval = security_task_getsid(p);
                         if (!retval)
-                                retval = task_session_nr(p);
+                                retval = task_session_nr_ns(p, ns);
                 }
                 read_unlock(&tasklist_lock);
                 return retval;
@@ -1065,7 +1077,7 @@ asmlinkage long sys_setsid(void)
         group_leader->signal->tty = NULL;
         spin_unlock(&group_leader->sighand->siglock);
 
-        err = task_pgrp_nr(group_leader);
+        err = task_pgrp_vnr(group_leader);
 out:
         write_unlock_irq(&tasklist_lock);
         return err;
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 44868e4df1d3..3b4efbe26445 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -2278,7 +2278,7 @@ static int proc_do_cad_pid(struct ctl_table *table, int write, struct file *filp
         pid_t tmp;
         int r;
 
-        tmp = pid_nr(cad_pid);
+        tmp = pid_nr_ns(cad_pid, current->nsproxy->pid_ns);
 
         r = __do_proc_dointvec(&tmp, table, write, filp, buffer,
                                lenp, ppos, NULL, NULL);
diff --git a/kernel/timer.c b/kernel/timer.c
index 8521d10fbb27..fb4e67d5dd60 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -26,6 +26,7 @@
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/swap.h>
+#include <linux/pid_namespace.h>
 #include <linux/notifier.h>
 #include <linux/thread_info.h>
 #include <linux/time.h>
@@ -956,7 +957,7 @@ asmlinkage unsigned long sys_alarm(unsigned int seconds)
  */
 asmlinkage long sys_getpid(void)
 {
-        return current->tgid;
+        return task_tgid_vnr(current);
 }
 
 /*
@@ -970,7 +971,7 @@ asmlinkage long sys_getppid(void)
         int pid;
 
         rcu_read_lock();
-        pid = rcu_dereference(current->real_parent)->tgid;
+        pid = task_ppid_nr_ns(current, current->nsproxy->pid_ns);
         rcu_read_unlock();
 
         return pid;
@@ -1102,7 +1103,7 @@ EXPORT_SYMBOL(schedule_timeout_uninterruptible);
 /* Thread ID - the internal kernel "pid" */
 asmlinkage long sys_gettid(void)
 {
-        return current->pid;
+        return task_pid_vnr(current);
 }
 
 /**