1 files changed, 76 insertions, 58 deletions

diff --git a/fs/proc/array.c b/fs/proc/array.c
index c602b8d20f06..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,
-                cred->gid, cred->egid, cred->sgid, cred->fsgid);
+                from_kuid_munged(user_ns, cred->uid),
+                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');
@@ -462,59 +471,56 @@ static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
         /* convert nsec -> ticks */
         start_time = nsec_to_clock_t(start_time);
 
-        seq_printf(m, "%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 %lu %lu %lu\n",
-                pid_nr_ns(pid, ns),
-                tcomm,
-                state,
-                ppid,
-                pgid,
-                sid,
-                tty_nr,
-                tty_pgrp,
-                task->flags,
-                min_flt,
-                cmin_flt,
-                maj_flt,
-                cmaj_flt,
-                cputime_to_clock_t(utime),
-                cputime_to_clock_t(stime),
-                cputime_to_clock_t(cutime),
-                cputime_to_clock_t(cstime),
-                priority,
-                nice,
-                num_threads,
-                start_time,
-                vsize,
-                mm ? get_mm_rss(mm) : 0,
-                rsslim,
-                mm ? (permitted ? mm->start_code : 1) : 0,
-                mm ? (permitted ? mm->end_code : 1) : 0,
-                (permitted && mm) ? mm->start_stack : 0,
-                esp,
-                eip,
-                /* The signal information here is obsolete.
-                 * It must be decimal for Linux 2.0 compatibility.
-                 * Use /proc/#/status for real-time signals.
-                 */
-                task->pending.signal.sig[0] & 0x7fffffffUL,
-                task->blocked.sig[0] & 0x7fffffffUL,
-                sigign      .sig[0] & 0x7fffffffUL,
-                sigcatch    .sig[0] & 0x7fffffffUL,
-                wchan,
-                0UL,
-                0UL,
-                task->exit_signal,
-                task_cpu(task),
-                task->rt_priority,
-                task->policy,
-                (unsigned long long)delayacct_blkio_ticks(task),
-                cputime_to_clock_t(gtime),
-                cputime_to_clock_t(cgtime),
-                (mm && permitted) ? mm->start_data : 0,
-                (mm && permitted) ? mm->end_data : 0,
-                (mm && permitted) ? mm->start_brk : 0);
+        seq_printf(m, "%d (%s) %c", pid_nr_ns(pid, ns), tcomm, state);
+        seq_put_decimal_ll(m, ' ', ppid);
+        seq_put_decimal_ll(m, ' ', pgid);
+        seq_put_decimal_ll(m, ' ', sid);
+        seq_put_decimal_ll(m, ' ', tty_nr);
+        seq_put_decimal_ll(m, ' ', tty_pgrp);
+        seq_put_decimal_ull(m, ' ', task->flags);
+        seq_put_decimal_ull(m, ' ', min_flt);
+        seq_put_decimal_ull(m, ' ', cmin_flt);
+        seq_put_decimal_ull(m, ' ', maj_flt);
+        seq_put_decimal_ull(m, ' ', cmaj_flt);
+        seq_put_decimal_ull(m, ' ', cputime_to_clock_t(utime));
+        seq_put_decimal_ull(m, ' ', cputime_to_clock_t(stime));
+        seq_put_decimal_ll(m, ' ', cputime_to_clock_t(cutime));
+        seq_put_decimal_ll(m, ' ', cputime_to_clock_t(cstime));
+        seq_put_decimal_ll(m, ' ', priority);
+        seq_put_decimal_ll(m, ' ', nice);
+        seq_put_decimal_ll(m, ' ', num_threads);
+        seq_put_decimal_ull(m, ' ', 0);
+        seq_put_decimal_ull(m, ' ', start_time);
+        seq_put_decimal_ull(m, ' ', vsize);
+        seq_put_decimal_ll(m, ' ', mm ? get_mm_rss(mm) : 0);
+        seq_put_decimal_ull(m, ' ', rsslim);
+        seq_put_decimal_ull(m, ' ', mm ? (permitted ? mm->start_code : 1) : 0);
+        seq_put_decimal_ull(m, ' ', mm ? (permitted ? mm->end_code : 1) : 0);
+        seq_put_decimal_ull(m, ' ', (permitted && mm) ? mm->start_stack : 0);
+        seq_put_decimal_ull(m, ' ', esp);
+        seq_put_decimal_ull(m, ' ', eip);
+        /* The signal information here is obsolete.
+         * It must be decimal for Linux 2.0 compatibility.
+         * Use /proc/#/status for real-time signals.
+         */
+        seq_put_decimal_ull(m, ' ', task->pending.signal.sig[0] & 0x7fffffffUL);
+        seq_put_decimal_ull(m, ' ', task->blocked.sig[0] & 0x7fffffffUL);
+        seq_put_decimal_ull(m, ' ', sigign.sig[0] & 0x7fffffffUL);
+        seq_put_decimal_ull(m, ' ', sigcatch.sig[0] & 0x7fffffffUL);
+        seq_put_decimal_ull(m, ' ', wchan);
+        seq_put_decimal_ull(m, ' ', 0);
+        seq_put_decimal_ull(m, ' ', 0);
+        seq_put_decimal_ll(m, ' ', task->exit_signal);
+        seq_put_decimal_ll(m, ' ', task_cpu(task));
+        seq_put_decimal_ull(m, ' ', task->rt_priority);
+        seq_put_decimal_ull(m, ' ', task->policy);
+        seq_put_decimal_ull(m, ' ', delayacct_blkio_ticks(task));
+        seq_put_decimal_ull(m, ' ', cputime_to_clock_t(gtime));
+        seq_put_decimal_ll(m, ' ', cputime_to_clock_t(cgtime));
+        seq_put_decimal_ull(m, ' ', (mm && permitted) ? mm->start_data : 0);
+        seq_put_decimal_ull(m, ' ', (mm && permitted) ? mm->end_data : 0);
+        seq_put_decimal_ull(m, ' ', (mm && permitted) ? mm->start_brk : 0);
+        seq_putc(m, '\n');
         if (mm)
                 mmput(mm);
         return 0;
@@ -542,8 +548,20 @@ int proc_pid_statm(struct seq_file *m, struct pid_namespace *ns,
                 size = task_statm(mm, &shared, &text, &data, &resident);
                 mmput(mm);
         }
-        seq_printf(m, "%lu %lu %lu %lu 0 %lu 0\n",
-                        size, resident, shared, text, data);
+        /*
+         * For quick read, open code by putting numbers directly
+         * expected format is
+         * seq_printf(m, "%lu %lu %lu %lu 0 %lu 0\n",
+         *               size, resident, shared, text, data);
+         */
+        seq_put_decimal_ull(m, 0, size);
+        seq_put_decimal_ull(m, ' ', resident);
+        seq_put_decimal_ull(m, ' ', shared);
+        seq_put_decimal_ull(m, ' ', text);
+        seq_put_decimal_ull(m, ' ', 0);
+        seq_put_decimal_ull(m, ' ', data);
+        seq_put_decimal_ull(m, ' ', 0);
+        seq_putc(m, '\n');
 
         return 0;
 }