Isolate some explicit usage of task->tgid

With pid namespaces this field is now dangerous to use explicitly, so hide
it behind the helpers.

Also the pid and pgrp fields o task_struct and signal_struct are to be
deprecated.  Unfortunately this patch cannot be sent right now as this
leads to tons of warnings, so start isolating them, and deprecate later.

Actually the p->tgid == pid has to be changed to has_group_leader_pid(),
but Oleg pointed out that in case of posix cpu timers this is the same, and
thread_group_leader() is more preferable.

Signed-off-by: Pavel Emelyanov <xemul@openvz.org>
Acked-by: Oleg Nesterov <oleg@tv-sign.ru>
Cc: Sukadev Bhattiprolu <sukadev@us.ibm.com>
Cc: "Eric W. Biederman" <ebiederm@xmission.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

4 files changed, 10 insertions, 10 deletions

diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c
index b53c8fcd9d82..68c96376e84a 100644
--- a/kernel/posix-cpu-timers.c
+++ b/kernel/posix-cpu-timers.c
@@ -21,8 +21,8 @@ static int check_clock(const clockid_t which_clock)
 
         read_lock(&tasklist_lock);
         p = find_task_by_pid(pid);
-        if (!p || (CPUCLOCK_PERTHREAD(which_clock) ?
-                   p->tgid != current->tgid : p->tgid != pid)) {
+        if (!p || !(CPUCLOCK_PERTHREAD(which_clock) ?
+                   same_thread_group(p, current) : thread_group_leader(p))) {
                 error = -EINVAL;
         }
         read_unlock(&tasklist_lock);
@@ -308,13 +308,13 @@ int posix_cpu_clock_get(const clockid_t which_clock, struct timespec *tp)
                 p = find_task_by_pid(pid);
                 if (p) {
                         if (CPUCLOCK_PERTHREAD(which_clock)) {
-                                if (p->tgid == current->tgid) {
+                                if (same_thread_group(p, current)) {
                                         error = cpu_clock_sample(which_clock,
                                                                  p, &rtn);
                                 }
                         } else {
                                 read_lock(&tasklist_lock);
-                                if (p->tgid == pid && p->signal) {
+                                if (thread_group_leader(p) && p->signal) {
                                         error =
                                             cpu_clock_sample_group(which_clock,
                                                                    p, &rtn);
@@ -355,7 +355,7 @@ int posix_cpu_timer_create(struct k_itimer *new_timer)
                         p = current;
                 } else {
                         p = find_task_by_pid(pid);
-                        if (p && p->tgid != current->tgid)
+                        if (p && !same_thread_group(p, current))
                                 p = NULL;
                 }
         } else {
@@ -363,7 +363,7 @@ int posix_cpu_timer_create(struct k_itimer *new_timer)
                         p = current->group_leader;
                 } else {
                         p = find_task_by_pid(pid);
-                        if (p && p->tgid != pid)
+                        if (p && !thread_group_leader(p))
                                 p = NULL;
                 }
         }
diff --git a/kernel/posix-timers.c b/kernel/posix-timers.c
index d11f579d189a..35b4bbfc78ff 100644
--- a/kernel/posix-timers.c
+++ b/kernel/posix-timers.c
@@ -404,7 +404,7 @@ static struct task_struct * good_sigevent(sigevent_t * event)
 
         if ((event->sigev_notify & SIGEV_THREAD_ID ) &&
                 (!(rtn = find_task_by_pid(event->sigev_notify_thread_id)) ||
-                 rtn->tgid != current->tgid ||
+                 !same_thread_group(rtn, current) ||
                  (event->sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_SIGNAL))
                 return NULL;
 
@@ -608,7 +608,7 @@ static struct k_itimer * lock_timer(timer_t timer_id, unsigned long *flags)
                 spin_lock(&timr->it_lock);
 
                 if ((timr->it_id != timer_id) || !(timr->it_process) ||
-                                timr->it_process->tgid != current->tgid) {
+                                !same_thread_group(timr->it_process, current)) {
                         spin_unlock(&timr->it_lock);
                         spin_unlock_irqrestore(&idr_lock, *flags);
                         timr = NULL;
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index b0ace60ce596..7c76f2ffaeaa 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -169,7 +169,7 @@ int ptrace_attach(struct task_struct *task)
         retval = -EPERM;
         if (task->pid <= 1)
                 goto out;
-        if (task->tgid == current->tgid)
+        if (same_thread_group(task, current))
                 goto out;
 
 repeat:
diff --git a/kernel/signal.c b/kernel/signal.c
index 783b33a0af06..08364e75bb58 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -1150,7 +1150,7 @@ static int kill_something_info(int sig, struct siginfo *info, int pid)
 
                 read_lock(&tasklist_lock);
                 for_each_process(p) {
-                        if (p->pid > 1 && p->tgid != current->tgid) {
+                        if (p->pid > 1 && !same_thread_group(p, current)) {
                                 int err = group_send_sig_info(sig, info, p);
                                 ++count;
                                 if (err != -EPERM)