linux/fs/proc/base.c
<<
>>
Prefs
   1/*
   2 *  linux/fs/proc/base.c
   3 *
   4 *  Copyright (C) 1991, 1992 Linus Torvalds
   5 *
   6 *  proc base directory handling functions
   7 *
   8 *  1999, Al Viro. Rewritten. Now it covers the whole per-process part.
   9 *  Instead of using magical inumbers to determine the kind of object
  10 *  we allocate and fill in-core inodes upon lookup. They don't even
  11 *  go into icache. We cache the reference to task_struct upon lookup too.
  12 *  Eventually it should become a filesystem in its own. We don't use the
  13 *  rest of procfs anymore.
  14 *
  15 *
  16 *  Changelog:
  17 *  17-Jan-2005
  18 *  Allan Bezerra
  19 *  Bruna Moreira <bruna.moreira@indt.org.br>
  20 *  Edjard Mota <edjard.mota@indt.org.br>
  21 *  Ilias Biris <ilias.biris@indt.org.br>
  22 *  Mauricio Lin <mauricio.lin@indt.org.br>
  23 *
  24 *  Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT
  25 *
  26 *  A new process specific entry (smaps) included in /proc. It shows the
  27 *  size of rss for each memory area. The maps entry lacks information
  28 *  about physical memory size (rss) for each mapped file, i.e.,
  29 *  rss information for executables and library files.
  30 *  This additional information is useful for any tools that need to know
  31 *  about physical memory consumption for a process specific library.
  32 *
  33 *  Changelog:
  34 *  21-Feb-2005
  35 *  Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT
  36 *  Pud inclusion in the page table walking.
  37 *
  38 *  ChangeLog:
  39 *  10-Mar-2005
  40 *  10LE Instituto Nokia de Tecnologia - INdT:
  41 *  A better way to walks through the page table as suggested by Hugh Dickins.
  42 *
  43 *  Simo Piiroinen <simo.piiroinen@nokia.com>:
  44 *  Smaps information related to shared, private, clean and dirty pages.
  45 *
  46 *  Paul Mundt <paul.mundt@nokia.com>:
  47 *  Overall revision about smaps.
  48 */
  49
  50#include <asm/uaccess.h>
  51
  52#include <linux/errno.h>
  53#include <linux/time.h>
  54#include <linux/proc_fs.h>
  55#include <linux/stat.h>
  56#include <linux/task_io_accounting_ops.h>
  57#include <linux/init.h>
  58#include <linux/capability.h>
  59#include <linux/file.h>
  60#include <linux/fdtable.h>
  61#include <linux/string.h>
  62#include <linux/seq_file.h>
  63#include <linux/namei.h>
  64#include <linux/mnt_namespace.h>
  65#include <linux/mm.h>
  66#include <linux/swap.h>
  67#include <linux/rcupdate.h>
  68#include <linux/kallsyms.h>
  69#include <linux/stacktrace.h>
  70#include <linux/resource.h>
  71#include <linux/module.h>
  72#include <linux/mount.h>
  73#include <linux/security.h>
  74#include <linux/ptrace.h>
  75#include <linux/tracehook.h>
  76#include <linux/printk.h>
  77#include <linux/cgroup.h>
  78#include <linux/cpuset.h>
  79#include <linux/audit.h>
  80#include <linux/poll.h>
  81#include <linux/nsproxy.h>
  82#include <linux/oom.h>
  83#include <linux/elf.h>
  84#include <linux/pid_namespace.h>
  85#include <linux/user_namespace.h>
  86#include <linux/fs_struct.h>
  87#include <linux/slab.h>
  88#include <linux/flex_array.h>
  89#include <linux/posix-timers.h>
  90#ifdef CONFIG_HARDWALL
  91#include <asm/hardwall.h>
  92#endif
  93#include <trace/events/oom.h>
  94#include "internal.h"
  95#include "fd.h"
  96
  97/* NOTE:
  98 *      Implementing inode permission operations in /proc is almost
  99 *      certainly an error.  Permission checks need to happen during
 100 *      each system call not at open time.  The reason is that most of
 101 *      what we wish to check for permissions in /proc varies at runtime.
 102 *
 103 *      The classic example of a problem is opening file descriptors
 104 *      in /proc for a task before it execs a suid executable.
 105 */
 106
 107struct pid_entry {
 108        char *name;
 109        int len;
 110        umode_t mode;
 111        const struct inode_operations *iop;
 112        const struct file_operations *fop;
 113        union proc_op op;
 114};
 115
 116#define NOD(NAME, MODE, IOP, FOP, OP) {                 \
 117        .name = (NAME),                                 \
 118        .len  = sizeof(NAME) - 1,                       \
 119        .mode = MODE,                                   \
 120        .iop  = IOP,                                    \
 121        .fop  = FOP,                                    \
 122        .op   = OP,                                     \
 123}
 124
 125#define DIR(NAME, MODE, iops, fops)     \
 126        NOD(NAME, (S_IFDIR|(MODE)), &iops, &fops, {} )
 127#define LNK(NAME, get_link)                                     \
 128        NOD(NAME, (S_IFLNK|S_IRWXUGO),                          \
 129                &proc_pid_link_inode_operations, NULL,          \
 130                { .proc_get_link = get_link } )
 131#define REG(NAME, MODE, fops)                           \
 132        NOD(NAME, (S_IFREG|(MODE)), NULL, &fops, {})
 133#define INF(NAME, MODE, read)                           \
 134        NOD(NAME, (S_IFREG|(MODE)),                     \
 135                NULL, &proc_info_file_operations,       \
 136                { .proc_read = read } )
 137#define ONE(NAME, MODE, show)                           \
 138        NOD(NAME, (S_IFREG|(MODE)),                     \
 139                NULL, &proc_single_file_operations,     \
 140                { .proc_show = show } )
 141
 142/*
 143 * Count the number of hardlinks for the pid_entry table, excluding the .
 144 * and .. links.
 145 */
 146static unsigned int pid_entry_count_dirs(const struct pid_entry *entries,
 147        unsigned int n)
 148{
 149        unsigned int i;
 150        unsigned int count;
 151
 152        count = 0;
 153        for (i = 0; i < n; ++i) {
 154                if (S_ISDIR(entries[i].mode))
 155                        ++count;
 156        }
 157
 158        return count;
 159}
 160
 161static int get_task_root(struct task_struct *task, struct path *root)
 162{
 163        int result = -ENOENT;
 164
 165        task_lock(task);
 166        if (task->fs) {
 167                get_fs_root(task->fs, root);
 168                result = 0;
 169        }
 170        task_unlock(task);
 171        return result;
 172}
 173
 174static int proc_cwd_link(struct dentry *dentry, struct path *path)
 175{
 176        struct task_struct *task = get_proc_task(dentry->d_inode);
 177        int result = -ENOENT;
 178
 179        if (task) {
 180                task_lock(task);
 181                if (task->fs) {
 182                        get_fs_pwd(task->fs, path);
 183                        result = 0;
 184                }
 185                task_unlock(task);
 186                put_task_struct(task);
 187        }
 188        return result;
 189}
 190
 191static int proc_root_link(struct dentry *dentry, struct path *path)
 192{
 193        struct task_struct *task = get_proc_task(dentry->d_inode);
 194        int result = -ENOENT;
 195
 196        if (task) {
 197                result = get_task_root(task, path);
 198                put_task_struct(task);
 199        }
 200        return result;
 201}
 202
 203static int proc_pid_cmdline(struct task_struct *task, char * buffer)
 204{
 205        int res = 0;
 206        unsigned int len;
 207        struct mm_struct *mm = get_task_mm(task);
 208        if (!mm)
 209                goto out;
 210        if (!mm->arg_end)
 211                goto out_mm;    /* Shh! No looking before we're done */
 212
 213        len = mm->arg_end - mm->arg_start;
 214 
 215        if (len > PAGE_SIZE)
 216                len = PAGE_SIZE;
 217 
 218        res = access_process_vm(task, mm->arg_start, buffer, len, 0);
 219
 220        // If the nul at the end of args has been overwritten, then
 221        // assume application is using setproctitle(3).
 222        if (res > 0 && buffer[res-1] != '\0' && len < PAGE_SIZE) {
 223                len = strnlen(buffer, res);
 224                if (len < res) {
 225                    res = len;
 226                } else {
 227                        len = mm->env_end - mm->env_start;
 228                        if (len > PAGE_SIZE - res)
 229                                len = PAGE_SIZE - res;
 230                        res += access_process_vm(task, mm->env_start, buffer+res, len, 0);
 231                        res = strnlen(buffer, res);
 232                }
 233        }
 234out_mm:
 235        mmput(mm);
 236out:
 237        return res;
 238}
 239
 240static int proc_pid_auxv(struct task_struct *task, char *buffer)
 241{
 242        struct mm_struct *mm = mm_access(task, PTRACE_MODE_READ);
 243        int res = PTR_ERR(mm);
 244        if (mm && !IS_ERR(mm)) {
 245                unsigned int nwords = 0;
 246                do {
 247                        nwords += 2;
 248                } while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */
 249                res = nwords * sizeof(mm->saved_auxv[0]);
 250                if (res > PAGE_SIZE)
 251                        res = PAGE_SIZE;
 252                memcpy(buffer, mm->saved_auxv, res);
 253                mmput(mm);
 254        }
 255        return res;
 256}
 257
 258
 259#ifdef CONFIG_KALLSYMS
 260/*
 261 * Provides a wchan file via kallsyms in a proper one-value-per-file format.
 262 * Returns the resolved symbol.  If that fails, simply return the address.
 263 */
 264static int proc_pid_wchan(struct task_struct *task, char *buffer)
 265{
 266        unsigned long wchan;
 267        char symname[KSYM_NAME_LEN];
 268
 269        wchan = get_wchan(task);
 270
 271        if (lookup_symbol_name(wchan, symname) < 0)
 272                if (!ptrace_may_access(task, PTRACE_MODE_READ))
 273                        return 0;
 274                else
 275                        return sprintf(buffer, "%lu", wchan);
 276        else
 277                return sprintf(buffer, "%s", symname);
 278}
 279#endif /* CONFIG_KALLSYMS */
 280
 281static int lock_trace(struct task_struct *task)
 282{
 283        int err = mutex_lock_killable(&task->signal->cred_guard_mutex);
 284        if (err)
 285                return err;
 286        if (!ptrace_may_access(task, PTRACE_MODE_ATTACH)) {
 287                mutex_unlock(&task->signal->cred_guard_mutex);
 288                return -EPERM;
 289        }
 290        return 0;
 291}
 292
 293static void unlock_trace(struct task_struct *task)
 294{
 295        mutex_unlock(&task->signal->cred_guard_mutex);
 296}
 297
 298#ifdef CONFIG_STACKTRACE
 299
 300#define MAX_STACK_TRACE_DEPTH   64
 301
 302static int proc_pid_stack(struct seq_file *m, struct pid_namespace *ns,
 303                          struct pid *pid, struct task_struct *task)
 304{
 305        struct stack_trace trace;
 306        unsigned long *entries;
 307        int err;
 308        int i;
 309
 310        entries = kmalloc(MAX_STACK_TRACE_DEPTH * sizeof(*entries), GFP_KERNEL);
 311        if (!entries)
 312                return -ENOMEM;
 313
 314        trace.nr_entries        = 0;
 315        trace.max_entries       = MAX_STACK_TRACE_DEPTH;
 316        trace.entries           = entries;
 317        trace.skip              = 0;
 318
 319        err = lock_trace(task);
 320        if (!err) {
 321                save_stack_trace_tsk(task, &trace);
 322
 323                for (i = 0; i < trace.nr_entries; i++) {
 324                        seq_printf(m, "[<%pK>] %pS\n",
 325                                   (void *)entries[i], (void *)entries[i]);
 326                }
 327                unlock_trace(task);
 328        }
 329        kfree(entries);
 330
 331        return err;
 332}
 333#endif
 334
 335#ifdef CONFIG_SCHEDSTATS
 336/*
 337 * Provides /proc/PID/schedstat
 338 */
 339static int proc_pid_schedstat(struct task_struct *task, char *buffer)
 340{
 341        return sprintf(buffer, "%llu %llu %lu\n",
 342                        (unsigned long long)task->se.sum_exec_runtime,
 343                        (unsigned long long)task->sched_info.run_delay,
 344                        task->sched_info.pcount);
 345}
 346#endif
 347
 348#ifdef CONFIG_LATENCYTOP
 349static int lstats_show_proc(struct seq_file *m, void *v)
 350{
 351        int i;
 352        struct inode *inode = m->private;
 353        struct task_struct *task = get_proc_task(inode);
 354
 355        if (!task)
 356                return -ESRCH;
 357        seq_puts(m, "Latency Top version : v0.1\n");
 358        for (i = 0; i < 32; i++) {
 359                struct latency_record *lr = &task->latency_record[i];
 360                if (lr->backtrace[0]) {
 361                        int q;
 362                        seq_printf(m, "%i %li %li",
 363                                   lr->count, lr->time, lr->max);
 364                        for (q = 0; q < LT_BACKTRACEDEPTH; q++) {
 365                                unsigned long bt = lr->backtrace[q];
 366                                if (!bt)
 367                                        break;
 368                                if (bt == ULONG_MAX)
 369                                        break;
 370                                seq_printf(m, " %ps", (void *)bt);
 371                        }
 372                        seq_putc(m, '\n');
 373                }
 374
 375        }
 376        put_task_struct(task);
 377        return 0;
 378}
 379
 380static int lstats_open(struct inode *inode, struct file *file)
 381{
 382        return single_open(file, lstats_show_proc, inode);
 383}
 384
 385static ssize_t lstats_write(struct file *file, const char __user *buf,
 386                            size_t count, loff_t *offs)
 387{
 388        struct task_struct *task = get_proc_task(file_inode(file));
 389
 390        if (!task)
 391                return -ESRCH;
 392        clear_all_latency_tracing(task);
 393        put_task_struct(task);
 394
 395        return count;
 396}
 397
 398static const struct file_operations proc_lstats_operations = {
 399        .open           = lstats_open,
 400        .read           = seq_read,
 401        .write          = lstats_write,
 402        .llseek         = seq_lseek,
 403        .release        = single_release,
 404};
 405
 406#endif
 407
 408#ifdef CONFIG_CGROUPS
 409static int cgroup_open(struct inode *inode, struct file *file)
 410{
 411        struct pid *pid = PROC_I(inode)->pid;
 412        return single_open(file, proc_cgroup_show, pid);
 413}
 414
 415static const struct file_operations proc_cgroup_operations = {
 416        .open           = cgroup_open,
 417        .read           = seq_read,
 418        .llseek         = seq_lseek,
 419        .release        = single_release,
 420};
 421#endif
 422
 423#ifdef CONFIG_PROC_PID_CPUSET
 424
 425static int cpuset_open(struct inode *inode, struct file *file)
 426{
 427        struct pid *pid = PROC_I(inode)->pid;
 428        return single_open(file, proc_cpuset_show, pid);
 429}
 430
 431static const struct file_operations proc_cpuset_operations = {
 432        .open           = cpuset_open,
 433        .read           = seq_read,
 434        .llseek         = seq_lseek,
 435        .release        = single_release,
 436};
 437#endif
 438
 439static int proc_oom_score(struct task_struct *task, char *buffer)
 440{
 441        unsigned long totalpages = totalram_pages + total_swap_pages;
 442        unsigned long points = 0;
 443
 444        read_lock(&tasklist_lock);
 445        if (pid_alive(task))
 446                points = oom_badness(task, NULL, NULL, totalpages) *
 447                                                1000 / totalpages;
 448        read_unlock(&tasklist_lock);
 449        return sprintf(buffer, "%lu\n", points);
 450}
 451
 452struct limit_names {
 453        char *name;
 454        char *unit;
 455};
 456
 457static const struct limit_names lnames[RLIM_NLIMITS] = {
 458        [RLIMIT_CPU] = {"Max cpu time", "seconds"},
 459        [RLIMIT_FSIZE] = {"Max file size", "bytes"},
 460        [RLIMIT_DATA] = {"Max data size", "bytes"},
 461        [RLIMIT_STACK] = {"Max stack size", "bytes"},
 462        [RLIMIT_CORE] = {"Max core file size", "bytes"},
 463        [RLIMIT_RSS] = {"Max resident set", "bytes"},
 464        [RLIMIT_NPROC] = {"Max processes", "processes"},
 465        [RLIMIT_NOFILE] = {"Max open files", "files"},
 466        [RLIMIT_MEMLOCK] = {"Max locked memory", "bytes"},
 467        [RLIMIT_AS] = {"Max address space", "bytes"},
 468        [RLIMIT_LOCKS] = {"Max file locks", "locks"},
 469        [RLIMIT_SIGPENDING] = {"Max pending signals", "signals"},
 470        [RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"},
 471        [RLIMIT_NICE] = {"Max nice priority", NULL},
 472        [RLIMIT_RTPRIO] = {"Max realtime priority", NULL},
 473        [RLIMIT_RTTIME] = {"Max realtime timeout", "us"},
 474};
 475
 476/* Display limits for a process */
 477static int proc_pid_limits(struct task_struct *task, char *buffer)
 478{
 479        unsigned int i;
 480        int count = 0;
 481        unsigned long flags;
 482        char *bufptr = buffer;
 483
 484        struct rlimit rlim[RLIM_NLIMITS];
 485
 486        if (!lock_task_sighand(task, &flags))
 487                return 0;
 488        memcpy(rlim, task->signal->rlim, sizeof(struct rlimit) * RLIM_NLIMITS);
 489        unlock_task_sighand(task, &flags);
 490
 491        /*
 492         * print the file header
 493         */
 494        count += sprintf(&bufptr[count], "%-25s %-20s %-20s %-10s\n",
 495                        "Limit", "Soft Limit", "Hard Limit", "Units");
 496
 497        for (i = 0; i < RLIM_NLIMITS; i++) {
 498                if (rlim[i].rlim_cur == RLIM_INFINITY)
 499                        count += sprintf(&bufptr[count], "%-25s %-20s ",
 500                                         lnames[i].name, "unlimited");
 501                else
 502                        count += sprintf(&bufptr[count], "%-25s %-20lu ",
 503                                         lnames[i].name, rlim[i].rlim_cur);
 504
 505                if (rlim[i].rlim_max == RLIM_INFINITY)
 506                        count += sprintf(&bufptr[count], "%-20s ", "unlimited");
 507                else
 508                        count += sprintf(&bufptr[count], "%-20lu ",
 509                                         rlim[i].rlim_max);
 510
 511                if (lnames[i].unit)
 512                        count += sprintf(&bufptr[count], "%-10s\n",
 513                                         lnames[i].unit);
 514                else
 515                        count += sprintf(&bufptr[count], "\n");
 516        }
 517
 518        return count;
 519}
 520
 521#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
 522static int proc_pid_syscall(struct task_struct *task, char *buffer)
 523{
 524        long nr;
 525        unsigned long args[6], sp, pc;
 526        int res = lock_trace(task);
 527        if (res)
 528                return res;
 529
 530        if (task_current_syscall(task, &nr, args, 6, &sp, &pc))
 531                res = sprintf(buffer, "running\n");
 532        else if (nr < 0)
 533                res = sprintf(buffer, "%ld 0x%lx 0x%lx\n", nr, sp, pc);
 534        else
 535                res = sprintf(buffer,
 536                       "%ld 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n",
 537                       nr,
 538                       args[0], args[1], args[2], args[3], args[4], args[5],
 539                       sp, pc);
 540        unlock_trace(task);
 541        return res;
 542}
 543#endif /* CONFIG_HAVE_ARCH_TRACEHOOK */
 544
 545/************************************************************************/
 546/*                       Here the fs part begins                        */
 547/************************************************************************/
 548
 549/* permission checks */
 550static int proc_fd_access_allowed(struct inode *inode)
 551{
 552        struct task_struct *task;
 553        int allowed = 0;
 554        /* Allow access to a task's file descriptors if it is us or we
 555         * may use ptrace attach to the process and find out that
 556         * information.
 557         */
 558        task = get_proc_task(inode);
 559        if (task) {
 560                allowed = ptrace_may_access(task, PTRACE_MODE_READ);
 561                put_task_struct(task);
 562        }
 563        return allowed;
 564}
 565
 566int proc_setattr(struct dentry *dentry, struct iattr *attr)
 567{
 568        int error;
 569        struct inode *inode = dentry->d_inode;
 570
 571        if (attr->ia_valid & ATTR_MODE)
 572                return -EPERM;
 573
 574        error = inode_change_ok(inode, attr);
 575        if (error)
 576                return error;
 577
 578        setattr_copy(inode, attr);
 579        mark_inode_dirty(inode);
 580        return 0;
 581}
 582
 583/*
 584 * May current process learn task's sched/cmdline info (for hide_pid_min=1)
 585 * or euid/egid (for hide_pid_min=2)?
 586 */
 587static bool has_pid_permissions(struct pid_namespace *pid,
 588                                 struct task_struct *task,
 589                                 int hide_pid_min)
 590{
 591        if (pid->hide_pid < hide_pid_min)
 592                return true;
 593        if (in_group_p(pid->pid_gid))
 594                return true;
 595        return ptrace_may_access(task, PTRACE_MODE_READ);
 596}
 597
 598
 599static int proc_pid_permission(struct inode *inode, int mask)
 600{
 601        struct pid_namespace *pid = inode->i_sb->s_fs_info;
 602        struct task_struct *task;
 603        bool has_perms;
 604
 605        task = get_proc_task(inode);
 606        if (!task)
 607                return -ESRCH;
 608        has_perms = has_pid_permissions(pid, task, 1);
 609        put_task_struct(task);
 610
 611        if (!has_perms) {
 612                if (pid->hide_pid == 2) {
 613                        /*
 614                         * Let's make getdents(), stat(), and open()
 615                         * consistent with each other.  If a process
 616                         * may not stat() a file, it shouldn't be seen
 617                         * in procfs at all.
 618                         */
 619                        return -ENOENT;
 620                }
 621
 622                return -EPERM;
 623        }
 624        return generic_permission(inode, mask);
 625}
 626
 627
 628
 629static const struct inode_operations proc_def_inode_operations = {
 630        .setattr        = proc_setattr,
 631};
 632
 633#define PROC_BLOCK_SIZE (3*1024)                /* 4K page size but our output routines use some slack for overruns */
 634
 635static ssize_t proc_info_read(struct file * file, char __user * buf,
 636                          size_t count, loff_t *ppos)
 637{
 638        struct inode * inode = file_inode(file);
 639        unsigned long page;
 640        ssize_t length;
 641        struct task_struct *task = get_proc_task(inode);
 642
 643        length = -ESRCH;
 644        if (!task)
 645                goto out_no_task;
 646
 647        if (count > PROC_BLOCK_SIZE)
 648                count = PROC_BLOCK_SIZE;
 649
 650        length = -ENOMEM;
 651        if (!(page = __get_free_page(GFP_TEMPORARY)))
 652                goto out;
 653
 654        length = PROC_I(inode)->op.proc_read(task, (char*)page);
 655
 656        if (length >= 0)
 657                length = simple_read_from_buffer(buf, count, ppos, (char *)page, length);
 658        free_page(page);
 659out:
 660        put_task_struct(task);
 661out_no_task:
 662        return length;
 663}
 664
 665static const struct file_operations proc_info_file_operations = {
 666        .read           = proc_info_read,
 667        .llseek         = generic_file_llseek,
 668};
 669
 670static int proc_single_show(struct seq_file *m, void *v)
 671{
 672        struct inode *inode = m->private;
 673        struct pid_namespace *ns;
 674        struct pid *pid;
 675        struct task_struct *task;
 676        int ret;
 677
 678        ns = inode->i_sb->s_fs_info;
 679        pid = proc_pid(inode);
 680        task = get_pid_task(pid, PIDTYPE_PID);
 681        if (!task)
 682                return -ESRCH;
 683
 684        ret = PROC_I(inode)->op.proc_show(m, ns, pid, task);
 685
 686        put_task_struct(task);
 687        return ret;
 688}
 689
 690static int proc_single_open(struct inode *inode, struct file *filp)
 691{
 692        return single_open(filp, proc_single_show, inode);
 693}
 694
 695static const struct file_operations proc_single_file_operations = {
 696        .open           = proc_single_open,
 697        .read           = seq_read,
 698        .llseek         = seq_lseek,
 699        .release        = single_release,
 700};
 701
 702static int __mem_open(struct inode *inode, struct file *file, unsigned int mode)
 703{
 704        struct task_struct *task = get_proc_task(file_inode(file));
 705        struct mm_struct *mm;
 706
 707        if (!task)
 708                return -ESRCH;
 709
 710        mm = mm_access(task, mode);
 711        put_task_struct(task);
 712
 713        if (IS_ERR(mm))
 714                return PTR_ERR(mm);
 715
 716        if (mm) {
 717                /* ensure this mm_struct can't be freed */
 718                atomic_inc(&mm->mm_count);
 719                /* but do not pin its memory */
 720                mmput(mm);
 721        }
 722
 723        file->private_data = mm;
 724
 725        return 0;
 726}
 727
 728static int mem_open(struct inode *inode, struct file *file)
 729{
 730        int ret = __mem_open(inode, file, PTRACE_MODE_ATTACH);
 731
 732        /* OK to pass negative loff_t, we can catch out-of-range */
 733        file->f_mode |= FMODE_UNSIGNED_OFFSET;
 734
 735        return ret;
 736}
 737
 738static ssize_t mem_rw(struct file *file, char __user *buf,
 739                        size_t count, loff_t *ppos, int write)
 740{
 741        struct mm_struct *mm = file->private_data;
 742        unsigned long addr = *ppos;
 743        ssize_t copied;
 744        char *page;
 745
 746        if (!mm)
 747                return 0;
 748
 749        page = (char *)__get_free_page(GFP_TEMPORARY);
 750        if (!page)
 751                return -ENOMEM;
 752
 753        copied = 0;
 754        if (!atomic_inc_not_zero(&mm->mm_users))
 755                goto free;
 756
 757        while (count > 0) {
 758                int this_len = min_t(int, count, PAGE_SIZE);
 759
 760                if (write && copy_from_user(page, buf, this_len)) {
 761                        copied = -EFAULT;
 762                        break;
 763                }
 764
 765                this_len = access_remote_vm(mm, addr, page, this_len, write);
 766                if (!this_len) {
 767                        if (!copied)
 768                                copied = -EIO;
 769                        break;
 770                }
 771
 772                if (!write && copy_to_user(buf, page, this_len)) {
 773                        copied = -EFAULT;
 774                        break;
 775                }
 776
 777                buf += this_len;
 778                addr += this_len;
 779                copied += this_len;
 780                count -= this_len;
 781        }
 782        *ppos = addr;
 783
 784        mmput(mm);
 785free:
 786        free_page((unsigned long) page);
 787        return copied;
 788}
 789
 790static ssize_t mem_read(struct file *file, char __user *buf,
 791                        size_t count, loff_t *ppos)
 792{
 793        return mem_rw(file, buf, count, ppos, 0);
 794}
 795
 796static ssize_t mem_write(struct file *file, const char __user *buf,
 797                         size_t count, loff_t *ppos)
 798{
 799        return mem_rw(file, (char __user*)buf, count, ppos, 1);
 800}
 801
 802loff_t mem_lseek(struct file *file, loff_t offset, int orig)
 803{
 804        switch (orig) {
 805        case 0:
 806                file->f_pos = offset;
 807                break;
 808        case 1:
 809                file->f_pos += offset;
 810                break;
 811        default:
 812                return -EINVAL;
 813        }
 814        force_successful_syscall_return();
 815        return file->f_pos;
 816}
 817
 818static int mem_release(struct inode *inode, struct file *file)
 819{
 820        struct mm_struct *mm = file->private_data;
 821        if (mm)
 822                mmdrop(mm);
 823        return 0;
 824}
 825
 826static const struct file_operations proc_mem_operations = {
 827        .llseek         = mem_lseek,
 828        .read           = mem_read,
 829        .write          = mem_write,
 830        .open           = mem_open,
 831        .release        = mem_release,
 832};
 833
 834static int environ_open(struct inode *inode, struct file *file)
 835{
 836        return __mem_open(inode, file, PTRACE_MODE_READ);
 837}
 838
 839static ssize_t environ_read(struct file *file, char __user *buf,
 840                        size_t count, loff_t *ppos)
 841{
 842        char *page;
 843        unsigned long src = *ppos;
 844        int ret = 0;
 845        struct mm_struct *mm = file->private_data;
 846
 847        if (!mm)
 848                return 0;
 849
 850        page = (char *)__get_free_page(GFP_TEMPORARY);
 851        if (!page)
 852                return -ENOMEM;
 853
 854        ret = 0;
 855        if (!atomic_inc_not_zero(&mm->mm_users))
 856                goto free;
 857        while (count > 0) {
 858                size_t this_len, max_len;
 859                int retval;
 860
 861                if (src >= (mm->env_end - mm->env_start))
 862                        break;
 863
 864                this_len = mm->env_end - (mm->env_start + src);
 865
 866                max_len = min_t(size_t, PAGE_SIZE, count);
 867                this_len = min(max_len, this_len);
 868
 869                retval = access_remote_vm(mm, (mm->env_start + src),
 870                        page, this_len, 0);
 871
 872                if (retval <= 0) {
 873                        ret = retval;
 874                        break;
 875                }
 876
 877                if (copy_to_user(buf, page, retval)) {
 878                        ret = -EFAULT;
 879                        break;
 880                }
 881
 882                ret += retval;
 883                src += retval;
 884                buf += retval;
 885                count -= retval;
 886        }
 887        *ppos = src;
 888        mmput(mm);
 889
 890free:
 891        free_page((unsigned long) page);
 892        return ret;
 893}
 894
 895static const struct file_operations proc_environ_operations = {
 896        .open           = environ_open,
 897        .read           = environ_read,
 898        .llseek         = generic_file_llseek,
 899        .release        = mem_release,
 900};
 901
 902static ssize_t oom_adj_read(struct file *file, char __user *buf, size_t count,
 903                            loff_t *ppos)
 904{
 905        struct task_struct *task = get_proc_task(file_inode(file));
 906        char buffer[PROC_NUMBUF];
 907        int oom_adj = OOM_ADJUST_MIN;
 908        size_t len;
 909        unsigned long flags;
 910
 911        if (!task)
 912                return -ESRCH;
 913        if (lock_task_sighand(task, &flags)) {
 914                if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MAX)
 915                        oom_adj = OOM_ADJUST_MAX;
 916                else
 917                        oom_adj = (task->signal->oom_score_adj * -OOM_DISABLE) /
 918                                  OOM_SCORE_ADJ_MAX;
 919                unlock_task_sighand(task, &flags);
 920        }
 921        put_task_struct(task);
 922        len = snprintf(buffer, sizeof(buffer), "%d\n", oom_adj);
 923        return simple_read_from_buffer(buf, count, ppos, buffer, len);
 924}
 925
 926static ssize_t oom_adj_write(struct file *file, const char __user *buf,
 927                             size_t count, loff_t *ppos)
 928{
 929        struct task_struct *task;
 930        char buffer[PROC_NUMBUF];
 931        int oom_adj;
 932        unsigned long flags;
 933        int err;
 934
 935        memset(buffer, 0, sizeof(buffer));
 936        if (count > sizeof(buffer) - 1)
 937                count = sizeof(buffer) - 1;
 938        if (copy_from_user(buffer, buf, count)) {
 939                err = -EFAULT;
 940                goto out;
 941        }
 942
 943        err = kstrtoint(strstrip(buffer), 0, &oom_adj);
 944        if (err)
 945                goto out;
 946        if ((oom_adj < OOM_ADJUST_MIN || oom_adj > OOM_ADJUST_MAX) &&
 947             oom_adj != OOM_DISABLE) {
 948                err = -EINVAL;
 949                goto out;
 950        }
 951
 952        task = get_proc_task(file_inode(file));
 953        if (!task) {
 954                err = -ESRCH;
 955                goto out;
 956        }
 957
 958        task_lock(task);
 959        if (!task->mm) {
 960                err = -EINVAL;
 961                goto err_task_lock;
 962        }
 963
 964        if (!lock_task_sighand(task, &flags)) {
 965                err = -ESRCH;
 966                goto err_task_lock;
 967        }
 968
 969        /*
 970         * Scale /proc/pid/oom_score_adj appropriately ensuring that a maximum
 971         * value is always attainable.
 972         */
 973        if (oom_adj == OOM_ADJUST_MAX)
 974                oom_adj = OOM_SCORE_ADJ_MAX;
 975        else
 976                oom_adj = (oom_adj * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE;
 977
 978        if (oom_adj < task->signal->oom_score_adj &&
 979            !capable(CAP_SYS_RESOURCE)) {
 980                err = -EACCES;
 981                goto err_sighand;
 982        }
 983
 984        /*
 985         * /proc/pid/oom_adj is provided for legacy purposes, ask users to use
 986         * /proc/pid/oom_score_adj instead.
 987         */
 988        pr_warn_once("%s (%d): /proc/%d/oom_adj is deprecated, please use /proc/%d/oom_score_adj instead.\n",
 989                  current->comm, task_pid_nr(current), task_pid_nr(task),
 990                  task_pid_nr(task));
 991
 992        task->signal->oom_score_adj = oom_adj;
 993        trace_oom_score_adj_update(task);
 994err_sighand:
 995        unlock_task_sighand(task, &flags);
 996err_task_lock:
 997        task_unlock(task);
 998        put_task_struct(task);
 999out:
1000        return err < 0 ? err : count;
1001}
1002
1003static const struct file_operations proc_oom_adj_operations = {
1004        .read           = oom_adj_read,
1005        .write          = oom_adj_write,
1006        .llseek         = generic_file_llseek,
1007};
1008
1009static ssize_t oom_score_adj_read(struct file *file, char __user *buf,
1010                                        size_t count, loff_t *ppos)
1011{
1012        struct task_struct *task = get_proc_task(file_inode(file));
1013        char buffer[PROC_NUMBUF];
1014        short oom_score_adj = OOM_SCORE_ADJ_MIN;
1015        unsigned long flags;
1016        size_t len;
1017
1018        if (!task)
1019                return -ESRCH;
1020        if (lock_task_sighand(task, &flags)) {
1021                oom_score_adj = task->signal->oom_score_adj;
1022                unlock_task_sighand(task, &flags);
1023        }
1024        put_task_struct(task);
1025        len = snprintf(buffer, sizeof(buffer), "%hd\n", oom_score_adj);
1026        return simple_read_from_buffer(buf, count, ppos, buffer, len);
1027}
1028
1029static ssize_t oom_score_adj_write(struct file *file, const char __user *buf,
1030                                        size_t count, loff_t *ppos)
1031{
1032        struct task_struct *task;
1033        char buffer[PROC_NUMBUF];
1034        unsigned long flags;
1035        int oom_score_adj;
1036        int err;
1037
1038        memset(buffer, 0, sizeof(buffer));
1039        if (count > sizeof(buffer) - 1)
1040                count = sizeof(buffer) - 1;
1041        if (copy_from_user(buffer, buf, count)) {
1042                err = -EFAULT;
1043                goto out;
1044        }
1045
1046        err = kstrtoint(strstrip(buffer), 0, &oom_score_adj);
1047        if (err)
1048                goto out;
1049        if (oom_score_adj < OOM_SCORE_ADJ_MIN ||
1050                        oom_score_adj > OOM_SCORE_ADJ_MAX) {
1051                err = -EINVAL;
1052                goto out;
1053        }
1054
1055        task = get_proc_task(file_inode(file));
1056        if (!task) {
1057                err = -ESRCH;
1058                goto out;
1059        }
1060
1061        task_lock(task);
1062        if (!task->mm) {
1063                err = -EINVAL;
1064                goto err_task_lock;
1065        }
1066
1067        if (!lock_task_sighand(task, &flags)) {
1068                err = -ESRCH;
1069                goto err_task_lock;
1070        }
1071
1072        if ((short)oom_score_adj < task->signal->oom_score_adj_min &&
1073                        !capable(CAP_SYS_RESOURCE)) {
1074                err = -EACCES;
1075                goto err_sighand;
1076        }
1077
1078        task->signal->oom_score_adj = (short)oom_score_adj;
1079        if (has_capability_noaudit(current, CAP_SYS_RESOURCE))
1080                task->signal->oom_score_adj_min = (short)oom_score_adj;
1081        trace_oom_score_adj_update(task);
1082
1083err_sighand:
1084        unlock_task_sighand(task, &flags);
1085err_task_lock:
1086        task_unlock(task);
1087        put_task_struct(task);
1088out:
1089        return err < 0 ? err : count;
1090}
1091
1092static const struct file_operations proc_oom_score_adj_operations = {
1093        .read           = oom_score_adj_read,
1094        .write          = oom_score_adj_write,
1095        .llseek         = default_llseek,
1096};
1097
1098#ifdef CONFIG_AUDITSYSCALL
1099#define TMPBUFLEN 21
1100static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
1101                                  size_t count, loff_t *ppos)
1102{
1103        struct inode * inode = file_inode(file);
1104        struct task_struct *task = get_proc_task(inode);
1105        ssize_t length;
1106        char tmpbuf[TMPBUFLEN];
1107
1108        if (!task)
1109                return -ESRCH;
1110        length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
1111                           from_kuid(file->f_cred->user_ns,
1112                                     audit_get_loginuid(task)));
1113        put_task_struct(task);
1114        return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
1115}
1116
1117static ssize_t proc_loginuid_write(struct file * file, const char __user * buf,
1118                                   size_t count, loff_t *ppos)
1119{
1120        struct inode * inode = file_inode(file);
1121        char *page, *tmp;
1122        ssize_t length;
1123        uid_t loginuid;
1124        kuid_t kloginuid;
1125
1126        rcu_read_lock();
1127        if (current != pid_task(proc_pid(inode), PIDTYPE_PID)) {
1128                rcu_read_unlock();
1129                return -EPERM;
1130        }
1131        rcu_read_unlock();
1132
1133        if (count >= PAGE_SIZE)
1134                count = PAGE_SIZE - 1;
1135
1136        if (*ppos != 0) {
1137                /* No partial writes. */
1138                return -EINVAL;
1139        }
1140        page = (char*)__get_free_page(GFP_TEMPORARY);
1141        if (!page)
1142                return -ENOMEM;
1143        length = -EFAULT;
1144        if (copy_from_user(page, buf, count))
1145                goto out_free_page;
1146
1147        page[count] = '\0';
1148        loginuid = simple_strtoul(page, &tmp, 10);
1149        if (tmp == page) {
1150                length = -EINVAL;
1151                goto out_free_page;
1152
1153        }
1154
1155        /* is userspace tring to explicitly UNSET the loginuid? */
1156        if (loginuid == AUDIT_UID_UNSET) {
1157                kloginuid = INVALID_UID;
1158        } else {
1159                kloginuid = make_kuid(file->f_cred->user_ns, loginuid);
1160                if (!uid_valid(kloginuid)) {
1161                        length = -EINVAL;
1162                        goto out_free_page;
1163                }
1164        }
1165
1166        length = audit_set_loginuid(kloginuid);
1167        if (likely(length == 0))
1168                length = count;
1169
1170out_free_page:
1171        free_page((unsigned long) page);
1172        return length;
1173}
1174
1175static const struct file_operations proc_loginuid_operations = {
1176        .read           = proc_loginuid_read,
1177        .write          = proc_loginuid_write,
1178        .llseek         = generic_file_llseek,
1179};
1180
1181static ssize_t proc_sessionid_read(struct file * file, char __user * buf,
1182                                  size_t count, loff_t *ppos)
1183{
1184        struct inode * inode = file_inode(file);
1185        struct task_struct *task = get_proc_task(inode);
1186        ssize_t length;
1187        char tmpbuf[TMPBUFLEN];
1188
1189        if (!task)
1190                return -ESRCH;
1191        length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
1192                                audit_get_sessionid(task));
1193        put_task_struct(task);
1194        return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
1195}
1196
1197static const struct file_operations proc_sessionid_operations = {
1198        .read           = proc_sessionid_read,
1199        .llseek         = generic_file_llseek,
1200};
1201#endif
1202
1203#ifdef CONFIG_FAULT_INJECTION
1204static ssize_t proc_fault_inject_read(struct file * file, char __user * buf,
1205                                      size_t count, loff_t *ppos)
1206{
1207        struct task_struct *task = get_proc_task(file_inode(file));
1208        char buffer[PROC_NUMBUF];
1209        size_t len;
1210        int make_it_fail;
1211
1212        if (!task)
1213                return -ESRCH;
1214        make_it_fail = task->make_it_fail;
1215        put_task_struct(task);
1216
1217        len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail);
1218
1219        return simple_read_from_buffer(buf, count, ppos, buffer, len);
1220}
1221
1222static ssize_t proc_fault_inject_write(struct file * file,
1223                        const char __user * buf, size_t count, loff_t *ppos)
1224{
1225        struct task_struct *task;
1226        char buffer[PROC_NUMBUF], *end;
1227        int make_it_fail;
1228
1229        if (!capable(CAP_SYS_RESOURCE))
1230                return -EPERM;
1231        memset(buffer, 0, sizeof(buffer));
1232        if (count > sizeof(buffer) - 1)
1233                count = sizeof(buffer) - 1;
1234        if (copy_from_user(buffer, buf, count))
1235                return -EFAULT;
1236        make_it_fail = simple_strtol(strstrip(buffer), &end, 0);
1237        if (*end)
1238                return -EINVAL;
1239        task = get_proc_task(file_inode(file));
1240        if (!task)
1241                return -ESRCH;
1242        task->make_it_fail = make_it_fail;
1243        put_task_struct(task);
1244
1245        return count;
1246}
1247
1248static const struct file_operations proc_fault_inject_operations = {
1249        .read           = proc_fault_inject_read,
1250        .write          = proc_fault_inject_write,
1251        .llseek         = generic_file_llseek,
1252};
1253#endif
1254
1255
1256#ifdef CONFIG_SCHED_DEBUG
1257/*
1258 * Print out various scheduling related per-task fields:
1259 */
1260static int sched_show(struct seq_file *m, void *v)
1261{
1262        struct inode *inode = m->private;
1263        struct task_struct *p;
1264
1265        p = get_proc_task(inode);
1266        if (!p)
1267                return -ESRCH;
1268        proc_sched_show_task(p, m);
1269
1270        put_task_struct(p);
1271
1272        return 0;
1273}
1274
1275static ssize_t
1276sched_write(struct file *file, const char __user *buf,
1277            size_t count, loff_t *offset)
1278{
1279        struct inode *inode = file_inode(file);
1280        struct task_struct *p;
1281
1282        p = get_proc_task(inode);
1283        if (!p)
1284                return -ESRCH;
1285        proc_sched_set_task(p);
1286
1287        put_task_struct(p);
1288
1289        return count;
1290}
1291
1292static int sched_open(struct inode *inode, struct file *filp)
1293{
1294        return single_open(filp, sched_show, inode);
1295}
1296
1297static const struct file_operations proc_pid_sched_operations = {
1298        .open           = sched_open,
1299        .read           = seq_read,
1300        .write          = sched_write,
1301        .llseek         = seq_lseek,
1302        .release        = single_release,
1303};
1304
1305#endif
1306
1307#ifdef CONFIG_SCHED_AUTOGROUP
1308/*
1309 * Print out autogroup related information:
1310 */
1311static int sched_autogroup_show(struct seq_file *m, void *v)
1312{
1313        struct inode *inode = m->private;
1314        struct task_struct *p;
1315
1316        p = get_proc_task(inode);
1317        if (!p)
1318                return -ESRCH;
1319        proc_sched_autogroup_show_task(p, m);
1320
1321        put_task_struct(p);
1322
1323        return 0;
1324}
1325
1326static ssize_t
1327sched_autogroup_write(struct file *file, const char __user *buf,
1328            size_t count, loff_t *offset)
1329{
1330        struct inode *inode = file_inode(file);
1331        struct task_struct *p;
1332        char buffer[PROC_NUMBUF];
1333        int nice;
1334        int err;
1335
1336        memset(buffer, 0, sizeof(buffer));
1337        if (count > sizeof(buffer) - 1)
1338                count = sizeof(buffer) - 1;
1339        if (copy_from_user(buffer, buf, count))
1340                return -EFAULT;
1341
1342        err = kstrtoint(strstrip(buffer), 0, &nice);
1343        if (err < 0)
1344                return err;
1345
1346        p = get_proc_task(inode);
1347        if (!p)
1348                return -ESRCH;
1349
1350        err = proc_sched_autogroup_set_nice(p, nice);
1351        if (err)
1352                count = err;
1353
1354        put_task_struct(p);
1355
1356        return count;
1357}
1358
1359static int sched_autogroup_open(struct inode *inode, struct file *filp)
1360{
1361        int ret;
1362
1363        ret = single_open(filp, sched_autogroup_show, NULL);
1364        if (!ret) {
1365                struct seq_file *m = filp->private_data;
1366
1367                m->private = inode;
1368        }
1369        return ret;
1370}
1371
1372static const struct file_operations proc_pid_sched_autogroup_operations = {
1373        .open           = sched_autogroup_open,
1374        .read           = seq_read,
1375        .write          = sched_autogroup_write,
1376        .llseek         = seq_lseek,
1377        .release        = single_release,
1378};
1379
1380#endif /* CONFIG_SCHED_AUTOGROUP */
1381
1382static ssize_t comm_write(struct file *file, const char __user *buf,
1383                                size_t count, loff_t *offset)
1384{
1385        struct inode *inode = file_inode(file);
1386        struct task_struct *p;
1387        char buffer[TASK_COMM_LEN];
1388        const size_t maxlen = sizeof(buffer) - 1;
1389
1390        memset(buffer, 0, sizeof(buffer));
1391        if (copy_from_user(buffer, buf, count > maxlen ? maxlen : count))
1392                return -EFAULT;
1393
1394        p = get_proc_task(inode);
1395        if (!p)
1396                return -ESRCH;
1397
1398        if (same_thread_group(current, p))
1399                set_task_comm(p, buffer);
1400        else
1401                count = -EINVAL;
1402
1403        put_task_struct(p);
1404
1405        return count;
1406}
1407
1408static int comm_show(struct seq_file *m, void *v)
1409{
1410        struct inode *inode = m->private;
1411        struct task_struct *p;
1412
1413        p = get_proc_task(inode);
1414        if (!p)
1415                return -ESRCH;
1416
1417        task_lock(p);
1418        seq_printf(m, "%s\n", p->comm);
1419        task_unlock(p);
1420
1421        put_task_struct(p);
1422
1423        return 0;
1424}
1425
1426static int comm_open(struct inode *inode, struct file *filp)
1427{
1428        return single_open(filp, comm_show, inode);
1429}
1430
1431static const struct file_operations proc_pid_set_comm_operations = {
1432        .open           = comm_open,
1433        .read           = seq_read,
1434        .write          = comm_write,
1435        .llseek         = seq_lseek,
1436        .release        = single_release,
1437};
1438
1439static int proc_exe_link(struct dentry *dentry, struct path *exe_path)
1440{
1441        struct task_struct *task;
1442        struct mm_struct *mm;
1443        struct file *exe_file;
1444
1445        task = get_proc_task(dentry->d_inode);
1446        if (!task)
1447                return -ENOENT;
1448        mm = get_task_mm(task);
1449        put_task_struct(task);
1450        if (!mm)
1451                return -ENOENT;
1452        exe_file = get_mm_exe_file(mm);
1453        mmput(mm);
1454        if (exe_file) {
1455                *exe_path = exe_file->f_path;
1456                path_get(&exe_file->f_path);
1457                fput(exe_file);
1458                return 0;
1459        } else
1460                return -ENOENT;
1461}
1462
1463static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd)
1464{
1465        struct inode *inode = dentry->d_inode;
1466        struct path path;
1467        int error = -EACCES;
1468
1469        /* Are we allowed to snoop on the tasks file descriptors? */
1470        if (!proc_fd_access_allowed(inode))
1471                goto out;
1472
1473        error = PROC_I(inode)->op.proc_get_link(dentry, &path);
1474        if (error)
1475                goto out;
1476
1477        nd_jump_link(nd, &path);
1478        return NULL;
1479out:
1480        return ERR_PTR(error);
1481}
1482
1483static int do_proc_readlink(struct path *path, char __user *buffer, int buflen)
1484{
1485        char *tmp = (char*)__get_free_page(GFP_TEMPORARY);
1486        char *pathname;
1487        int len;
1488
1489        if (!tmp)
1490                return -ENOMEM;
1491
1492        pathname = d_path(path, tmp, PAGE_SIZE);
1493        len = PTR_ERR(pathname);
1494        if (IS_ERR(pathname))
1495                goto out;
1496        len = tmp + PAGE_SIZE - 1 - pathname;
1497
1498        if (len > buflen)
1499                len = buflen;
1500        if (copy_to_user(buffer, pathname, len))
1501                len = -EFAULT;
1502 out:
1503        free_page((unsigned long)tmp);
1504        return len;
1505}
1506
1507static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen)
1508{
1509        int error = -EACCES;
1510        struct inode *inode = dentry->d_inode;
1511        struct path path;
1512
1513        /* Are we allowed to snoop on the tasks file descriptors? */
1514        if (!proc_fd_access_allowed(inode))
1515                goto out;
1516
1517        error = PROC_I(inode)->op.proc_get_link(dentry, &path);
1518        if (error)
1519                goto out;
1520
1521        error = do_proc_readlink(&path, buffer, buflen);
1522        path_put(&path);
1523out:
1524        return error;
1525}
1526
1527const struct inode_operations proc_pid_link_inode_operations = {
1528        .readlink       = proc_pid_readlink,
1529        .follow_link    = proc_pid_follow_link,
1530        .setattr        = proc_setattr,
1531};
1532
1533
1534/* building an inode */
1535
1536struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task)
1537{
1538        struct inode * inode;
1539        struct proc_inode *ei;
1540        const struct cred *cred;
1541
1542        /* We need a new inode */
1543
1544        inode = new_inode(sb);
1545        if (!inode)
1546                goto out;
1547
1548        /* Common stuff */
1549        ei = PROC_I(inode);
1550        inode->i_ino = get_next_ino();
1551        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
1552        inode->i_op = &proc_def_inode_operations;
1553
1554        /*
1555         * grab the reference to task.
1556         */
1557        ei->pid = get_task_pid(task, PIDTYPE_PID);
1558        if (!ei->pid)
1559                goto out_unlock;
1560
1561        if (task_dumpable(task)) {
1562                rcu_read_lock();
1563                cred = __task_cred(task);
1564                inode->i_uid = cred->euid;
1565                inode->i_gid = cred->egid;
1566                rcu_read_unlock();
1567        }
1568        security_task_to_inode(task, inode);
1569
1570out:
1571        return inode;
1572
1573out_unlock:
1574        iput(inode);
1575        return NULL;
1576}
1577
1578int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
1579{
1580        struct inode *inode = dentry->d_inode;
1581        struct task_struct *task;
1582        const struct cred *cred;
1583        struct pid_namespace *pid = dentry->d_sb->s_fs_info;
1584
1585        generic_fillattr(inode, stat);
1586
1587        rcu_read_lock();
1588        stat->uid = GLOBAL_ROOT_UID;
1589        stat->gid = GLOBAL_ROOT_GID;
1590        task = pid_task(proc_pid(inode), PIDTYPE_PID);
1591        if (task) {
1592                if (!has_pid_permissions(pid, task, 2)) {
1593                        rcu_read_unlock();
1594                        /*
1595                         * This doesn't prevent learning whether PID exists,
1596                         * it only makes getattr() consistent with readdir().
1597                         */
1598                        return -ENOENT;
1599                }
1600                if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
1601                    task_dumpable(task)) {
1602                        cred = __task_cred(task);
1603                        stat->uid = cred->euid;
1604                        stat->gid = cred->egid;
1605                }
1606        }
1607        rcu_read_unlock();
1608        return 0;
1609}
1610
1611/* dentry stuff */
1612
1613/*
1614 *      Exceptional case: normally we are not allowed to unhash a busy
1615 * directory. In this case, however, we can do it - no aliasing problems
1616 * due to the way we treat inodes.
1617 *
1618 * Rewrite the inode's ownerships here because the owning task may have
1619 * performed a setuid(), etc.
1620 *
1621 * Before the /proc/pid/status file was created the only way to read
1622 * the effective uid of a /process was to stat /proc/pid.  Reading
1623 * /proc/pid/status is slow enough that procps and other packages
1624 * kept stating /proc/pid.  To keep the rules in /proc simple I have
1625 * made this apply to all per process world readable and executable
1626 * directories.
1627 */
1628int pid_revalidate(struct dentry *dentry, unsigned int flags)
1629{
1630        struct inode *inode;
1631        struct task_struct *task;
1632        const struct cred *cred;
1633
1634        if (flags & LOOKUP_RCU)
1635                return -ECHILD;
1636
1637        inode = dentry->d_inode;
1638        task = get_proc_task(inode);
1639
1640        if (task) {
1641                if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
1642                    task_dumpable(task)) {
1643                        rcu_read_lock();
1644                        cred = __task_cred(task);
1645                        inode->i_uid = cred->euid;
1646                        inode->i_gid = cred->egid;
1647                        rcu_read_unlock();
1648                } else {
1649                        inode->i_uid = GLOBAL_ROOT_UID;
1650                        inode->i_gid = GLOBAL_ROOT_GID;
1651                }
1652                inode->i_mode &= ~(S_ISUID | S_ISGID);
1653                security_task_to_inode(task, inode);
1654                put_task_struct(task);
1655                return 1;
1656        }
1657        d_drop(dentry);
1658        return 0;
1659}
1660
1661int pid_delete_dentry(const struct dentry *dentry)
1662{
1663        /* Is the task we represent dead?
1664         * If so, then don't put the dentry on the lru list,
1665         * kill it immediately.
1666         */
1667        return !proc_pid(dentry->d_inode)->tasks[PIDTYPE_PID].first;
1668}
1669
1670const struct dentry_operations pid_dentry_operations =
1671{
1672        .d_revalidate   = pid_revalidate,
1673        .d_delete       = pid_delete_dentry,
1674};
1675
1676/* Lookups */
1677
1678/*
1679 * Fill a directory entry.
1680 *
1681 * If possible create the dcache entry and derive our inode number and
1682 * file type from dcache entry.
1683 *
1684 * Since all of the proc inode numbers are dynamically generated, the inode
1685 * numbers do not exist until the inode is cache.  This means creating the
1686 * the dcache entry in readdir is necessary to keep the inode numbers
1687 * reported by readdir in sync with the inode numbers reported
1688 * by stat.
1689 */
1690bool proc_fill_cache(struct file *file, struct dir_context *ctx,
1691        const char *name, int len,
1692        instantiate_t instantiate, struct task_struct *task, const void *ptr)
1693{
1694        struct dentry *child, *dir = file->f_path.dentry;
1695        struct qstr qname = QSTR_INIT(name, len);
1696        struct inode *inode;
1697        unsigned type;
1698        ino_t ino;
1699
1700        child = d_hash_and_lookup(dir, &qname);
1701        if (!child) {
1702                child = d_alloc(dir, &qname);
1703                if (!child)
1704                        goto end_instantiate;
1705                if (instantiate(dir->d_inode, child, task, ptr) < 0) {
1706                        dput(child);
1707                        goto end_instantiate;
1708                }
1709        }
1710        inode = child->d_inode;
1711        ino = inode->i_ino;
1712        type = inode->i_mode >> 12;
1713        dput(child);
1714        return dir_emit(ctx, name, len, ino, type);
1715
1716end_instantiate:
1717        return dir_emit(ctx, name, len, 1, DT_UNKNOWN);
1718}
1719
1720#ifdef CONFIG_CHECKPOINT_RESTORE
1721
1722/*
1723 * dname_to_vma_addr - maps a dentry name into two unsigned longs
1724 * which represent vma start and end addresses.
1725 */
1726static int dname_to_vma_addr(struct dentry *dentry,
1727                             unsigned long *start, unsigned long *end)
1728{
1729        if (sscanf(dentry->d_name.name, "%lx-%lx", start, end) != 2)
1730                return -EINVAL;
1731
1732        return 0;
1733}
1734
1735static int map_files_d_revalidate(struct dentry *dentry, unsigned int flags)
1736{
1737        unsigned long vm_start, vm_end;
1738        bool exact_vma_exists = false;
1739        struct mm_struct *mm = NULL;
1740        struct task_struct *task;
1741        const struct cred *cred;
1742        struct inode *inode;
1743        int status = 0;
1744
1745        if (flags & LOOKUP_RCU)
1746                return -ECHILD;
1747
1748        if (!capable(CAP_SYS_ADMIN)) {
1749                status = -EPERM;
1750                goto out_notask;
1751        }
1752
1753        inode = dentry->d_inode;
1754        task = get_proc_task(inode);
1755        if (!task)
1756                goto out_notask;
1757
1758        mm = mm_access(task, PTRACE_MODE_READ);
1759        if (IS_ERR_OR_NULL(mm))
1760                goto out;
1761
1762        if (!dname_to_vma_addr(dentry, &vm_start, &vm_end)) {
1763                down_read(&mm->mmap_sem);
1764                exact_vma_exists = !!find_exact_vma(mm, vm_start, vm_end);
1765                up_read(&mm->mmap_sem);
1766        }
1767
1768        mmput(mm);
1769
1770        if (exact_vma_exists) {
1771                if (task_dumpable(task)) {
1772                        rcu_read_lock();
1773                        cred = __task_cred(task);
1774                        inode->i_uid = cred->euid;
1775                        inode->i_gid = cred->egid;
1776                        rcu_read_unlock();
1777                } else {
1778                        inode->i_uid = GLOBAL_ROOT_UID;
1779                        inode->i_gid = GLOBAL_ROOT_GID;
1780                }
1781                security_task_to_inode(task, inode);
1782                status = 1;
1783        }
1784
1785out:
1786        put_task_struct(task);
1787
1788out_notask:
1789        if (status <= 0)
1790                d_drop(dentry);
1791
1792        return status;
1793}
1794
1795static const struct dentry_operations tid_map_files_dentry_operations = {
1796        .d_revalidate   = map_files_d_revalidate,
1797        .d_delete       = pid_delete_dentry,
1798};
1799
1800static int proc_map_files_get_link(struct dentry *dentry, struct path *path)
1801{
1802        unsigned long vm_start, vm_end;
1803        struct vm_area_struct *vma;
1804        struct task_struct *task;
1805        struct mm_struct *mm;
1806        int rc;
1807
1808        rc = -ENOENT;
1809        task = get_proc_task(dentry->d_inode);
1810        if (!task)
1811                goto out;
1812
1813        mm = get_task_mm(task);
1814        put_task_struct(task);
1815        if (!mm)
1816                goto out;
1817
1818        rc = dname_to_vma_addr(dentry, &vm_start, &vm_end);
1819        if (rc)
1820                goto out_mmput;
1821
1822        down_read(&mm->mmap_sem);
1823        vma = find_exact_vma(mm, vm_start, vm_end);
1824        if (vma && vma->vm_file) {
1825                *path = vma->vm_file->f_path;
1826                path_get(path);
1827                rc = 0;
1828        }
1829        up_read(&mm->mmap_sem);
1830
1831out_mmput:
1832        mmput(mm);
1833out:
1834        return rc;
1835}
1836
1837struct map_files_info {
1838        fmode_t         mode;
1839        unsigned long   len;
1840        unsigned char   name[4*sizeof(long)+2]; /* max: %lx-%lx\0 */
1841};
1842
1843static int
1844proc_map_files_instantiate(struct inode *dir, struct dentry *dentry,
1845                           struct task_struct *task, const void *ptr)
1846{
1847        fmode_t mode = (fmode_t)(unsigned long)ptr;
1848        struct proc_inode *ei;
1849        struct inode *inode;
1850
1851        inode = proc_pid_make_inode(dir->i_sb, task);
1852        if (!inode)
1853                return -ENOENT;
1854
1855        ei = PROC_I(inode);
1856        ei->op.proc_get_link = proc_map_files_get_link;
1857
1858        inode->i_op = &proc_pid_link_inode_operations;
1859        inode->i_size = 64;
1860        inode->i_mode = S_IFLNK;
1861
1862        if (mode & FMODE_READ)
1863                inode->i_mode |= S_IRUSR;
1864        if (mode & FMODE_WRITE)
1865                inode->i_mode |= S_IWUSR;
1866
1867        d_set_d_op(dentry, &tid_map_files_dentry_operations);
1868        d_add(dentry, inode);
1869
1870        return 0;
1871}
1872
1873static struct dentry *proc_map_files_lookup(struct inode *dir,
1874                struct dentry *dentry, unsigned int flags)
1875{
1876        unsigned long vm_start, vm_end;
1877        struct vm_area_struct *vma;
1878        struct task_struct *task;
1879        int result;
1880        struct mm_struct *mm;
1881
1882        result = -EPERM;
1883        if (!capable(CAP_SYS_ADMIN))
1884                goto out;
1885
1886        result = -ENOENT;
1887        task = get_proc_task(dir);
1888        if (!task)
1889                goto out;
1890
1891        result = -EACCES;
1892        if (!ptrace_may_access(task, PTRACE_MODE_READ))
1893                goto out_put_task;
1894
1895        result = -ENOENT;
1896        if (dname_to_vma_addr(dentry, &vm_start, &vm_end))
1897                goto out_put_task;
1898
1899        mm = get_task_mm(task);
1900        if (!mm)
1901                goto out_put_task;
1902
1903        down_read(&mm->mmap_sem);
1904        vma = find_exact_vma(mm, vm_start, vm_end);
1905        if (!vma)
1906                goto out_no_vma;
1907
1908        if (vma->vm_file)
1909                result = proc_map_files_instantiate(dir, dentry, task,
1910                                (void *)(unsigned long)vma->vm_file->f_mode);
1911
1912out_no_vma:
1913        up_read(&mm->mmap_sem);
1914        mmput(mm);
1915out_put_task:
1916        put_task_struct(task);
1917out:
1918        return ERR_PTR(result);
1919}
1920
1921static const struct inode_operations proc_map_files_inode_operations = {
1922        .lookup         = proc_map_files_lookup,
1923        .permission     = proc_fd_permission,
1924        .setattr        = proc_setattr,
1925};
1926
1927static int
1928proc_map_files_readdir(struct file *file, struct dir_context *ctx)
1929{
1930        struct vm_area_struct *vma;
1931        struct task_struct *task;
1932        struct mm_struct *mm;
1933        unsigned long nr_files, pos, i;
1934        struct flex_array *fa = NULL;
1935        struct map_files_info info;
1936        struct map_files_info *p;
1937        int ret;
1938
1939        ret = -EPERM;
1940        if (!capable(CAP_SYS_ADMIN))
1941                goto out;
1942
1943        ret = -ENOENT;
1944        task = get_proc_task(file_inode(file));
1945        if (!task)
1946                goto out;
1947
1948        ret = -EACCES;
1949        if (!ptrace_may_access(task, PTRACE_MODE_READ))
1950                goto out_put_task;
1951
1952        ret = 0;
1953        if (!dir_emit_dots(file, ctx))
1954                goto out_put_task;
1955
1956        mm = get_task_mm(task);
1957        if (!mm)
1958                goto out_put_task;
1959        down_read(&mm->mmap_sem);
1960
1961        nr_files = 0;
1962
1963        /*
1964         * We need two passes here:
1965         *
1966         *  1) Collect vmas of mapped files with mmap_sem taken
1967         *  2) Release mmap_sem and instantiate entries
1968         *
1969         * otherwise we get lockdep complained, since filldir()
1970         * routine might require mmap_sem taken in might_fault().
1971         */
1972
1973        for (vma = mm->mmap, pos = 2; vma; vma = vma->vm_next) {
1974                if (vma->vm_file && ++pos > ctx->pos)
1975                        nr_files++;
1976        }
1977
1978        if (nr_files) {
1979                fa = flex_array_alloc(sizeof(info), nr_files,
1980                                        GFP_KERNEL);
1981                if (!fa || flex_array_prealloc(fa, 0, nr_files,
1982                                                GFP_KERNEL)) {
1983                        ret = -ENOMEM;
1984                        if (fa)
1985                                flex_array_free(fa);
1986                        up_read(&mm->mmap_sem);
1987                        mmput(mm);
1988                        goto out_put_task;
1989                }
1990                for (i = 0, vma = mm->mmap, pos = 2; vma;
1991                                vma = vma->vm_next) {
1992                        if (!vma->vm_file)
1993                                continue;
1994                        if (++pos <= ctx->pos)
1995                                continue;
1996
1997                        info.mode = vma->vm_file->f_mode;
1998                        info.len = snprintf(info.name,
1999                                        sizeof(info.name), "%lx-%lx",
2000                                        vma->vm_start, vma->vm_end);
2001                        if (flex_array_put(fa, i++, &info, GFP_KERNEL))
2002                                BUG();
2003                }
2004        }
2005        up_read(&mm->mmap_sem);
2006
2007        for (i = 0; i < nr_files; i++) {
2008                p = flex_array_get(fa, i);
2009                if (!proc_fill_cache(file, ctx,
2010                                      p->name, p->len,
2011                                      proc_map_files_instantiate,
2012                                      task,
2013                                      (void *)(unsigned long)p->mode))
2014                        break;
2015                ctx->pos++;
2016        }
2017        if (fa)
2018                flex_array_free(fa);
2019        mmput(mm);
2020
2021out_put_task:
2022        put_task_struct(task);
2023out:
2024        return ret;
2025}
2026
2027static const struct file_operations proc_map_files_operations = {
2028        .read           = generic_read_dir,
2029        .iterate        = proc_map_files_readdir,
2030        .llseek         = default_llseek,
2031};
2032
2033struct timers_private {
2034        struct pid *pid;
2035        struct task_struct *task;
2036        struct sighand_struct *sighand;
2037        struct pid_namespace *ns;
2038        unsigned long flags;
2039};
2040
2041static void *timers_start(struct seq_file *m, loff_t *pos)
2042{
2043        struct timers_private *tp = m->private;
2044
2045        tp->task = get_pid_task(tp->pid, PIDTYPE_PID);
2046        if (!tp->task)
2047                return ERR_PTR(-ESRCH);
2048
2049        tp->sighand = lock_task_sighand(tp->task, &tp->flags);
2050        if (!tp->sighand)
2051                return ERR_PTR(-ESRCH);
2052
2053        return seq_list_start(&tp->task->signal->posix_timers, *pos);
2054}
2055
2056static void *timers_next(struct seq_file *m, void *v, loff_t *pos)
2057{
2058        struct timers_private *tp = m->private;
2059        return seq_list_next(v, &tp->task->signal->posix_timers, pos);
2060}
2061
2062static void timers_stop(struct seq_file *m, void *v)
2063{
2064        struct timers_private *tp = m->private;
2065
2066        if (tp->sighand) {
2067                unlock_task_sighand(tp->task, &tp->flags);
2068                tp->sighand = NULL;
2069        }
2070
2071        if (tp->task) {
2072                put_task_struct(tp->task);
2073                tp->task = NULL;
2074        }
2075}
2076
2077static int show_timer(struct seq_file *m, void *v)
2078{
2079        struct k_itimer *timer;
2080        struct timers_private *tp = m->private;
2081        int notify;
2082        static char *nstr[] = {
2083                [SIGEV_SIGNAL] = "signal",
2084                [SIGEV_NONE] = "none",
2085                [SIGEV_THREAD] = "thread",
2086        };
2087
2088        timer = list_entry((struct list_head *)v, struct k_itimer, list);
2089        notify = timer->it_sigev_notify;
2090
2091        seq_printf(m, "ID: %d\n", timer->it_id);
2092        seq_printf(m, "signal: %d/%p\n", timer->sigq->info.si_signo,
2093                        timer->sigq->info.si_value.sival_ptr);
2094        seq_printf(m, "notify: %s/%s.%d\n",
2095                nstr[notify & ~SIGEV_THREAD_ID],
2096                (notify & SIGEV_THREAD_ID) ? "tid" : "pid",
2097                pid_nr_ns(timer->it_pid, tp->ns));
2098        seq_printf(m, "ClockID: %d\n", timer->it_clock);
2099
2100        return 0;
2101}
2102
2103static const struct seq_operations proc_timers_seq_ops = {
2104        .start  = timers_start,
2105        .next   = timers_next,
2106        .stop   = timers_stop,
2107        .show   = show_timer,
2108};
2109
2110static int proc_timers_open(struct inode *inode, struct file *file)
2111{
2112        struct timers_private *tp;
2113
2114        tp = __seq_open_private(file, &proc_timers_seq_ops,
2115                        sizeof(struct timers_private));
2116        if (!tp)
2117                return -ENOMEM;
2118
2119        tp->pid = proc_pid(inode);
2120        tp->ns = inode->i_sb->s_fs_info;
2121        return 0;
2122}
2123
2124static const struct file_operations proc_timers_operations = {
2125        .open           = proc_timers_open,
2126        .read           = seq_read,
2127        .llseek         = seq_lseek,
2128        .release        = seq_release_private,
2129};
2130#endif /* CONFIG_CHECKPOINT_RESTORE */
2131
2132static int proc_pident_instantiate(struct inode *dir,
2133        struct dentry *dentry, struct task_struct *task, const void *ptr)
2134{
2135        const struct pid_entry *p = ptr;
2136        struct inode *inode;
2137        struct proc_inode *ei;
2138
2139        inode = proc_pid_make_inode(dir->i_sb, task);
2140        if (!inode)
2141                goto out;
2142
2143        ei = PROC_I(inode);
2144        inode->i_mode = p->mode;
2145        if (S_ISDIR(inode->i_mode))
2146                set_nlink(inode, 2);    /* Use getattr to fix if necessary */
2147        if (p->iop)
2148                inode->i_op = p->iop;
2149        if (p->fop)
2150                inode->i_fop = p->fop;
2151        ei->op = p->op;
2152        d_set_d_op(dentry, &pid_dentry_operations);
2153        d_add(dentry, inode);
2154        /* Close the race of the process dying before we return the dentry */
2155        if (pid_revalidate(dentry, 0))
2156                return 0;
2157out:
2158        return -ENOENT;
2159}
2160
2161static struct dentry *proc_pident_lookup(struct inode *dir, 
2162                                         struct dentry *dentry,
2163                                         const struct pid_entry *ents,
2164                                         unsigned int nents)
2165{
2166        int error;
2167        struct task_struct *task = get_proc_task(dir);
2168        const struct pid_entry *p, *last;
2169
2170        error = -ENOENT;
2171
2172        if (!task)
2173                goto out_no_task;
2174
2175        /*
2176         * Yes, it does not scale. And it should not. Don't add
2177         * new entries into /proc/<tgid>/ without very good reasons.
2178         */
2179        last = &ents[nents - 1];
2180        for (p = ents; p <= last; p++) {
2181                if (p->len != dentry->d_name.len)
2182                        continue;
2183                if (!memcmp(dentry->d_name.name, p->name, p->len))
2184                        break;
2185        }
2186        if (p > last)
2187                goto out;
2188
2189        error = proc_pident_instantiate(dir, dentry, task, p);
2190out:
2191        put_task_struct(task);
2192out_no_task:
2193        return ERR_PTR(error);
2194}
2195
2196static int proc_pident_readdir(struct file *file, struct dir_context *ctx,
2197                const struct pid_entry *ents, unsigned int nents)
2198{
2199        struct task_struct *task = get_proc_task(file_inode(file));
2200        const struct pid_entry *p;
2201
2202        if (!task)
2203                return -ENOENT;
2204
2205        if (!dir_emit_dots(file, ctx))
2206                goto out;
2207
2208        if (ctx->pos >= nents + 2)
2209                goto out;
2210
2211        for (p = ents + (ctx->pos - 2); p <= ents + nents - 1; p++) {
2212                if (!proc_fill_cache(file, ctx, p->name, p->len,
2213                                proc_pident_instantiate, task, p))
2214                        break;
2215                ctx->pos++;
2216        }
2217out:
2218        put_task_struct(task);
2219        return 0;
2220}
2221
2222#ifdef CONFIG_SECURITY
2223static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,
2224                                  size_t count, loff_t *ppos)
2225{
2226        struct inode * inode = file_inode(file);
2227        char *p = NULL;
2228        ssize_t length;
2229        struct task_struct *task = get_proc_task(inode);
2230
2231        if (!task)
2232                return -ESRCH;
2233
2234        length = security_getprocattr(task,
2235                                      (char*)file->f_path.dentry->d_name.name,
2236                                      &p);
2237        put_task_struct(task);
2238        if (length > 0)
2239                length = simple_read_from_buffer(buf, count, ppos, p, length);
2240        kfree(p);
2241        return length;
2242}
2243
2244static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,
2245                                   size_t count, loff_t *ppos)
2246{
2247        struct inode * inode = file_inode(file);
2248        char *page;
2249        ssize_t length;
2250        struct task_struct *task = get_proc_task(inode);
2251
2252        length = -ESRCH;
2253        if (!task)
2254                goto out_no_task;
2255        if (count > PAGE_SIZE)
2256                count = PAGE_SIZE;
2257
2258        /* No partial writes. */
2259        length = -EINVAL;
2260        if (*ppos != 0)
2261                goto out;
2262
2263        length = -ENOMEM;
2264        page = (char*)__get_free_page(GFP_TEMPORARY);
2265        if (!page)
2266                goto out;
2267
2268        length = -EFAULT;
2269        if (copy_from_user(page, buf, count))
2270                goto out_free;
2271
2272        /* Guard against adverse ptrace interaction */
2273        length = mutex_lock_interruptible(&task->signal->cred_guard_mutex);
2274        if (length < 0)
2275                goto out_free;
2276
2277        length = security_setprocattr(task,
2278                                      (char*)file->f_path.dentry->d_name.name,
2279                                      (void*)page, count);
2280        mutex_unlock(&task->signal->cred_guard_mutex);
2281out_free:
2282        free_page((unsigned long) page);
2283out:
2284        put_task_struct(task);
2285out_no_task:
2286        return length;
2287}
2288
2289static const struct file_operations proc_pid_attr_operations = {
2290        .read           = proc_pid_attr_read,
2291        .write          = proc_pid_attr_write,
2292        .llseek         = generic_file_llseek,
2293};
2294
2295static const struct pid_entry attr_dir_stuff[] = {
2296        REG("current",    S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2297        REG("prev",       S_IRUGO,         proc_pid_attr_operations),
2298        REG("exec",       S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2299        REG("fscreate",   S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2300        REG("keycreate",  S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2301        REG("sockcreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2302};
2303
2304static int proc_attr_dir_readdir(struct file *file, struct dir_context *ctx)
2305{
2306        return proc_pident_readdir(file, ctx, 
2307                                   attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
2308}
2309
2310static const struct file_operations proc_attr_dir_operations = {
2311        .read           = generic_read_dir,
2312        .iterate        = proc_attr_dir_readdir,
2313        .llseek         = default_llseek,
2314};
2315
2316static struct dentry *proc_attr_dir_lookup(struct inode *dir,
2317                                struct dentry *dentry, unsigned int flags)
2318{
2319        return proc_pident_lookup(dir, dentry,
2320                                  attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
2321}
2322
2323static const struct inode_operations proc_attr_dir_inode_operations = {
2324        .lookup         = proc_attr_dir_lookup,
2325        .getattr        = pid_getattr,
2326        .setattr        = proc_setattr,
2327};
2328
2329#endif
2330
2331#ifdef CONFIG_ELF_CORE
2332static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf,
2333                                         size_t count, loff_t *ppos)
2334{
2335        struct task_struct *task = get_proc_task(file_inode(file));
2336        struct mm_struct *mm;
2337        char buffer[PROC_NUMBUF];
2338        size_t len;
2339        int ret;
2340
2341        if (!task)
2342                return -ESRCH;
2343
2344        ret = 0;
2345        mm = get_task_mm(task);
2346        if (mm) {
2347                len = snprintf(buffer, sizeof(buffer), "%08lx\n",
2348                               ((mm->flags & MMF_DUMP_FILTER_MASK) >>
2349                                MMF_DUMP_FILTER_SHIFT));
2350                mmput(mm);
2351                ret = simple_read_from_buffer(buf, count, ppos, buffer, len);
2352        }
2353
2354        put_task_struct(task);
2355
2356        return ret;
2357}
2358
2359static ssize_t proc_coredump_filter_write(struct file *file,
2360                                          const char __user *buf,
2361                                          size_t count,
2362                                          loff_t *ppos)
2363{
2364        struct task_struct *task;
2365        struct mm_struct *mm;
2366        char buffer[PROC_NUMBUF], *end;
2367        unsigned int val;
2368        int ret;
2369        int i;
2370        unsigned long mask;
2371
2372        ret = -EFAULT;
2373        memset(buffer, 0, sizeof(buffer));
2374        if (count > sizeof(buffer) - 1)
2375                count = sizeof(buffer) - 1;
2376        if (copy_from_user(buffer, buf, count))
2377                goto out_no_task;
2378
2379        ret = -EINVAL;
2380        val = (unsigned int)simple_strtoul(buffer, &end, 0);
2381        if (*end == '\n')
2382                end++;
2383        if (end - buffer == 0)
2384                goto out_no_task;
2385
2386        ret = -ESRCH;
2387        task = get_proc_task(file_inode(file));
2388        if (!task)
2389                goto out_no_task;
2390
2391        ret = end - buffer;
2392        mm = get_task_mm(task);
2393        if (!mm)
2394                goto out_no_mm;
2395
2396        for (i = 0, mask = 1; i < MMF_DUMP_FILTER_BITS; i++, mask <<= 1) {
2397                if (val & mask)
2398                        set_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
2399                else
2400                        clear_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
2401        }
2402
2403        mmput(mm);
2404 out_no_mm:
2405        put_task_struct(task);
2406 out_no_task:
2407        return ret;
2408}
2409
2410static const struct file_operations proc_coredump_filter_operations = {
2411        .read           = proc_coredump_filter_read,
2412        .write          = proc_coredump_filter_write,
2413        .llseek         = generic_file_llseek,
2414};
2415#endif
2416
2417#ifdef CONFIG_TASK_IO_ACCOUNTING
2418static int do_io_accounting(struct task_struct *task, char *buffer, int whole)
2419{
2420        struct task_io_accounting acct = task->ioac;
2421        unsigned long flags;
2422        int result;
2423
2424        result = mutex_lock_killable(&task->signal->cred_guard_mutex);
2425        if (result)
2426                return result;
2427
2428        if (!ptrace_may_access(task, PTRACE_MODE_READ)) {
2429                result = -EACCES;
2430                goto out_unlock;
2431        }
2432
2433        if (whole && lock_task_sighand(task, &flags)) {
2434                struct task_struct *t = task;
2435
2436                task_io_accounting_add(&acct, &task->signal->ioac);
2437                while_each_thread(task, t)
2438                        task_io_accounting_add(&acct, &t->ioac);
2439
2440                unlock_task_sighand(task, &flags);
2441        }
2442        result = sprintf(buffer,
2443                        "rchar: %llu\n"
2444                        "wchar: %llu\n"
2445                        "syscr: %llu\n"
2446                        "syscw: %llu\n"
2447                        "read_bytes: %llu\n"
2448                        "write_bytes: %llu\n"
2449                        "cancelled_write_bytes: %llu\n",
2450                        (unsigned long long)acct.rchar,
2451                        (unsigned long long)acct.wchar,
2452                        (unsigned long long)acct.syscr,
2453                        (unsigned long long)acct.syscw,
2454                        (unsigned long long)acct.read_bytes,
2455                        (unsigned long long)acct.write_bytes,
2456                        (unsigned long long)acct.cancelled_write_bytes);
2457out_unlock:
2458        mutex_unlock(&task->signal->cred_guard_mutex);
2459        return result;
2460}
2461
2462static int proc_tid_io_accounting(struct task_struct *task, char *buffer)
2463{
2464        return do_io_accounting(task, buffer, 0);
2465}
2466
2467static int proc_tgid_io_accounting(struct task_struct *task, char *buffer)
2468{
2469        return do_io_accounting(task, buffer, 1);
2470}
2471#endif /* CONFIG_TASK_IO_ACCOUNTING */
2472
2473#ifdef CONFIG_USER_NS
2474static int proc_id_map_open(struct inode *inode, struct file *file,
2475        struct seq_operations *seq_ops)
2476{
2477        struct user_namespace *ns = NULL;
2478        struct task_struct *task;
2479        struct seq_file *seq;
2480        int ret = -EINVAL;
2481
2482        task = get_proc_task(inode);
2483        if (task) {
2484                rcu_read_lock();
2485                ns = get_user_ns(task_cred_xxx(task, user_ns));
2486                rcu_read_unlock();
2487                put_task_struct(task);
2488        }
2489        if (!ns)
2490                goto err;
2491
2492        ret = seq_open(file, seq_ops);
2493        if (ret)
2494                goto err_put_ns;
2495
2496        seq = file->private_data;
2497        seq->private = ns;
2498
2499        return 0;
2500err_put_ns:
2501        put_user_ns(ns);
2502err:
2503        return ret;
2504}
2505
2506static int proc_id_map_release(struct inode *inode, struct file *file)
2507{
2508        struct seq_file *seq = file->private_data;
2509        struct user_namespace *ns = seq->private;
2510        put_user_ns(ns);
2511        return seq_release(inode, file);
2512}
2513
2514static int proc_uid_map_open(struct inode *inode, struct file *file)
2515{
2516        return proc_id_map_open(inode, file, &proc_uid_seq_operations);
2517}
2518
2519static int proc_gid_map_open(struct inode *inode, struct file *file)
2520{
2521        return proc_id_map_open(inode, file, &proc_gid_seq_operations);
2522}
2523
2524static int proc_projid_map_open(struct inode *inode, struct file *file)
2525{
2526        return proc_id_map_open(inode, file, &proc_projid_seq_operations);
2527}
2528
2529static const struct file_operations proc_uid_map_operations = {
2530        .open           = proc_uid_map_open,
2531        .write          = proc_uid_map_write,
2532        .read           = seq_read,
2533        .llseek         = seq_lseek,
2534        .release        = proc_id_map_release,
2535};
2536
2537static const struct file_operations proc_gid_map_operations = {
2538        .open           = proc_gid_map_open,
2539        .write          = proc_gid_map_write,
2540        .read           = seq_read,
2541        .llseek         = seq_lseek,
2542        .release        = proc_id_map_release,
2543};
2544
2545static const struct file_operations proc_projid_map_operations = {
2546        .open           = proc_projid_map_open,
2547        .write          = proc_projid_map_write,
2548        .read           = seq_read,
2549        .llseek         = seq_lseek,
2550        .release        = proc_id_map_release,
2551};
2552#endif /* CONFIG_USER_NS */
2553
2554static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns,
2555                                struct pid *pid, struct task_struct *task)
2556{
2557        int err = lock_trace(task);
2558        if (!err) {
2559                seq_printf(m, "%08x\n", task->personality);
2560                unlock_trace(task);
2561        }
2562        return err;
2563}
2564
2565/*
2566 * Thread groups
2567 */
2568static const struct file_operations proc_task_operations;
2569static const struct inode_operations proc_task_inode_operations;
2570
2571static const struct pid_entry tgid_base_stuff[] = {
2572        DIR("task",       S_IRUGO|S_IXUGO, proc_task_inode_operations, proc_task_operations),
2573        DIR("fd",         S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
2574#ifdef CONFIG_CHECKPOINT_RESTORE
2575        DIR("map_files",  S_IRUSR|S_IXUSR, proc_map_files_inode_operations, proc_map_files_operations),
2576#endif
2577        DIR("fdinfo",     S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
2578        DIR("ns",         S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
2579#ifdef CONFIG_NET
2580        DIR("net",        S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations),
2581#endif
2582        REG("environ",    S_IRUSR, proc_environ_operations),
2583        INF("auxv",       S_IRUSR, proc_pid_auxv),
2584        ONE("status",     S_IRUGO, proc_pid_status),
2585        ONE("personality", S_IRUGO, proc_pid_personality),
2586        INF("limits",     S_IRUGO, proc_pid_limits),
2587#ifdef CONFIG_SCHED_DEBUG
2588        REG("sched",      S_IRUGO|S_IWUSR, proc_pid_sched_operations),
2589#endif
2590#ifdef CONFIG_SCHED_AUTOGROUP
2591        REG("autogroup",  S_IRUGO|S_IWUSR, proc_pid_sched_autogroup_operations),
2592#endif
2593        REG("comm",      S_IRUGO|S_IWUSR, proc_pid_set_comm_operations),
2594#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
2595        INF("syscall",    S_IRUGO, proc_pid_syscall),
2596#endif
2597        INF("cmdline",    S_IRUGO, proc_pid_cmdline),
2598        ONE("stat",       S_IRUGO, proc_tgid_stat),
2599        ONE("statm",      S_IRUGO, proc_pid_statm),
2600        REG("maps",       S_IRUGO, proc_pid_maps_operations),
2601#ifdef CONFIG_NUMA
2602        REG("numa_maps",  S_IRUGO, proc_pid_numa_maps_operations),
2603#endif
2604        REG("mem",        S_IRUSR|S_IWUSR, proc_mem_operations),
2605        LNK("cwd",        proc_cwd_link),
2606        LNK("root",       proc_root_link),
2607        LNK("exe",        proc_exe_link),
2608        REG("mounts",     S_IRUGO, proc_mounts_operations),
2609        REG("mountinfo",  S_IRUGO, proc_mountinfo_operations),
2610        REG("mountstats", S_IRUSR, proc_mountstats_operations),
2611#ifdef CONFIG_PROC_PAGE_MONITOR
2612        REG("clear_refs", S_IWUSR, proc_clear_refs_operations),
2613        REG("smaps",      S_IRUGO, proc_pid_smaps_operations),
2614        REG("pagemap",    S_IRUGO, proc_pagemap_operations),
2615#endif
2616#ifdef CONFIG_SECURITY
2617        DIR("attr",       S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations),
2618#endif
2619#ifdef CONFIG_KALLSYMS
2620        INF("wchan",      S_IRUGO, proc_pid_wchan),
2621#endif
2622#ifdef CONFIG_STACKTRACE
2623        ONE("stack",      S_IRUGO, proc_pid_stack),
2624#endif
2625#ifdef CONFIG_SCHEDSTATS
2626        INF("schedstat",  S_IRUGO, proc_pid_schedstat),
2627#endif
2628#ifdef CONFIG_LATENCYTOP
2629        REG("latency",  S_IRUGO, proc_lstats_operations),
2630#endif
2631#ifdef CONFIG_PROC_PID_CPUSET
2632        REG("cpuset",     S_IRUGO, proc_cpuset_operations),
2633#endif
2634#ifdef CONFIG_CGROUPS
2635        REG("cgroup",  S_IRUGO, proc_cgroup_operations),
2636#endif
2637        INF("oom_score",  S_IRUGO, proc_oom_score),
2638        REG("oom_adj",    S_IRUGO|S_IWUSR, proc_oom_adj_operations),
2639        REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
2640#ifdef CONFIG_AUDITSYSCALL
2641        REG("loginuid",   S_IWUSR|S_IRUGO, proc_loginuid_operations),
2642        REG("sessionid",  S_IRUGO, proc_sessionid_operations),
2643#endif
2644#ifdef CONFIG_FAULT_INJECTION
2645        REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),
2646#endif
2647#ifdef CONFIG_ELF_CORE
2648        REG("coredump_filter", S_IRUGO|S_IWUSR, proc_coredump_filter_operations),
2649#endif
2650#ifdef CONFIG_TASK_IO_ACCOUNTING
2651        INF("io",       S_IRUSR, proc_tgid_io_accounting),
2652#endif
2653#ifdef CONFIG_HARDWALL
2654        INF("hardwall",   S_IRUGO, proc_pid_hardwall),
2655#endif
2656#ifdef CONFIG_USER_NS
2657        REG("uid_map",    S_IRUGO|S_IWUSR, proc_uid_map_operations),
2658        REG("gid_map",    S_IRUGO|S_IWUSR, proc_gid_map_operations),
2659        REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations),
2660#endif
2661#ifdef CONFIG_CHECKPOINT_RESTORE
2662        REG("timers",     S_IRUGO, proc_timers_operations),
2663#endif
2664};
2665
2666static int proc_tgid_base_readdir(struct file *file, struct dir_context *ctx)
2667{
2668        return proc_pident_readdir(file, ctx,
2669                                   tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
2670}
2671
2672static const struct file_operations proc_tgid_base_operations = {
2673        .read           = generic_read_dir,
2674        .iterate        = proc_tgid_base_readdir,
2675        .llseek         = default_llseek,
2676};
2677
2678static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
2679{
2680        return proc_pident_lookup(dir, dentry,
2681                                  tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
2682}
2683
2684static const struct inode_operations proc_tgid_base_inode_operations = {
2685        .lookup         = proc_tgid_base_lookup,
2686        .getattr        = pid_getattr,
2687        .setattr        = proc_setattr,
2688        .permission     = proc_pid_permission,
2689};
2690
2691static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
2692{
2693        struct dentry *dentry, *leader, *dir;
2694        char buf[PROC_NUMBUF];
2695        struct qstr name;
2696
2697        name.name = buf;
2698        name.len = snprintf(buf, sizeof(buf), "%d", pid);
2699        /* no ->d_hash() rejects on procfs */
2700        dentry = d_hash_and_lookup(mnt->mnt_root, &name);
2701        if (dentry) {
2702                shrink_dcache_parent(dentry);
2703                d_drop(dentry);
2704                dput(dentry);
2705        }
2706
2707        name.name = buf;
2708        name.len = snprintf(buf, sizeof(buf), "%d", tgid);
2709        leader = d_hash_and_lookup(mnt->mnt_root, &name);
2710        if (!leader)
2711                goto out;
2712
2713        name.name = "task";
2714        name.len = strlen(name.name);
2715        dir = d_hash_and_lookup(leader, &name);
2716        if (!dir)
2717                goto out_put_leader;
2718
2719        name.name = buf;
2720        name.len = snprintf(buf, sizeof(buf), "%d", pid);
2721        dentry = d_hash_and_lookup(dir, &name);
2722        if (dentry) {
2723                shrink_dcache_parent(dentry);
2724                d_drop(dentry);
2725                dput(dentry);
2726        }
2727
2728        dput(dir);
2729out_put_leader:
2730        dput(leader);
2731out:
2732        return;
2733}
2734
2735/**
2736 * proc_flush_task -  Remove dcache entries for @task from the /proc dcache.
2737 * @task: task that should be flushed.
2738 *
2739 * When flushing dentries from proc, one needs to flush them from global
2740 * proc (proc_mnt) and from all the namespaces' procs this task was seen
2741 * in. This call is supposed to do all of this job.
2742 *
2743 * Looks in the dcache for
2744 * /proc/@pid
2745 * /proc/@tgid/task/@pid
2746 * if either directory is present flushes it and all of it'ts children
2747 * from the dcache.
2748 *
2749 * It is safe and reasonable to cache /proc entries for a task until
2750 * that task exits.  After that they just clog up the dcache with
2751 * useless entries, possibly causing useful dcache entries to be
2752 * flushed instead.  This routine is proved to flush those useless
2753 * dcache entries at process exit time.
2754 *
2755 * NOTE: This routine is just an optimization so it does not guarantee
2756 *       that no dcache entries will exist at process exit time it
2757 *       just makes it very unlikely that any will persist.
2758 */
2759
2760void proc_flush_task(struct task_struct *task)
2761{
2762        int i;
2763        struct pid *pid, *tgid;
2764        struct upid *upid;
2765
2766        pid = task_pid(task);
2767        tgid = task_tgid(task);
2768
2769        for (i = 0; i <= pid->level; i++) {
2770                upid = &pid->numbers[i];
2771                proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr,
2772                                        tgid->numbers[i].nr);
2773        }
2774}
2775
2776static int proc_pid_instantiate(struct inode *dir,
2777                                   struct dentry * dentry,
2778                                   struct task_struct *task, const void *ptr)
2779{
2780        struct inode *inode;
2781
2782        inode = proc_pid_make_inode(dir->i_sb, task);
2783        if (!inode)
2784                goto out;
2785
2786        inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
2787        inode->i_op = &proc_tgid_base_inode_operations;
2788        inode->i_fop = &proc_tgid_base_operations;
2789        inode->i_flags|=S_IMMUTABLE;
2790
2791        set_nlink(inode, 2 + pid_entry_count_dirs(tgid_base_stuff,
2792                                                  ARRAY_SIZE(tgid_base_stuff)));
2793
2794        d_set_d_op(dentry, &pid_dentry_operations);
2795
2796        d_add(dentry, inode);
2797        /* Close the race of the process dying before we return the dentry */
2798        if (pid_revalidate(dentry, 0))
2799                return 0;
2800out:
2801        return -ENOENT;
2802}
2803
2804struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
2805{
2806        int result = 0;
2807        struct task_struct *task;
2808        unsigned tgid;
2809        struct pid_namespace *ns;
2810
2811        tgid = name_to_int(dentry);
2812        if (tgid == ~0U)
2813                goto out;
2814
2815        ns = dentry->d_sb->s_fs_info;
2816        rcu_read_lock();
2817        task = find_task_by_pid_ns(tgid, ns);
2818        if (task)
2819                get_task_struct(task);
2820        rcu_read_unlock();
2821        if (!task)
2822                goto out;
2823
2824        result = proc_pid_instantiate(dir, dentry, task, NULL);
2825        put_task_struct(task);
2826out:
2827        return ERR_PTR(result);
2828}
2829
2830/*
2831 * Find the first task with tgid >= tgid
2832 *
2833 */
2834struct tgid_iter {
2835        unsigned int tgid;
2836        struct task_struct *task;
2837};
2838static struct tgid_iter next_tgid(struct pid_namespace *ns, struct tgid_iter iter)
2839{
2840        struct pid *pid;
2841
2842        if (iter.task)
2843                put_task_struct(iter.task);
2844        rcu_read_lock();
2845retry:
2846        iter.task = NULL;
2847        pid = find_ge_pid(iter.tgid, ns);
2848        if (pid) {
2849                iter.tgid = pid_nr_ns(pid, ns);
2850                iter.task = pid_task(pid, PIDTYPE_PID);
2851                /* What we to know is if the pid we have find is the
2852                 * pid of a thread_group_leader.  Testing for task
2853                 * being a thread_group_leader is the obvious thing
2854                 * todo but there is a window when it fails, due to
2855                 * the pid transfer logic in de_thread.
2856                 *
2857                 * So we perform the straight forward test of seeing
2858                 * if the pid we have found is the pid of a thread
2859                 * group leader, and don't worry if the task we have
2860                 * found doesn't happen to be a thread group leader.
2861                 * As we don't care in the case of readdir.
2862                 */
2863                if (!iter.task || !has_group_leader_pid(iter.task)) {
2864                        iter.tgid += 1;
2865                        goto retry;
2866                }
2867                get_task_struct(iter.task);
2868        }
2869        rcu_read_unlock();
2870        return iter;
2871}
2872
2873#define TGID_OFFSET (FIRST_PROCESS_ENTRY + 1)
2874
2875/* for the /proc/ directory itself, after non-process stuff has been done */
2876int proc_pid_readdir(struct file *file, struct dir_context *ctx)
2877{
2878        struct tgid_iter iter;
2879        struct pid_namespace *ns = file->f_dentry->d_sb->s_fs_info;
2880        loff_t pos = ctx->pos;
2881
2882        if (pos >= PID_MAX_LIMIT + TGID_OFFSET)
2883                return 0;
2884
2885        if (pos == TGID_OFFSET - 1) {
2886                struct inode *inode = ns->proc_self->d_inode;
2887                if (!dir_emit(ctx, "self", 4, inode->i_ino, DT_LNK))
2888                        return 0;
2889                iter.tgid = 0;
2890        } else {
2891                iter.tgid = pos - TGID_OFFSET;
2892        }
2893        iter.task = NULL;
2894        for (iter = next_tgid(ns, iter);
2895             iter.task;
2896             iter.tgid += 1, iter = next_tgid(ns, iter)) {
2897                char name[PROC_NUMBUF];
2898                int len;
2899                if (!has_pid_permissions(ns, iter.task, 2))
2900                        continue;
2901
2902                len = snprintf(name, sizeof(name), "%d", iter.tgid);
2903                ctx->pos = iter.tgid + TGID_OFFSET;
2904                if (!proc_fill_cache(file, ctx, name, len,
2905                                     proc_pid_instantiate, iter.task, NULL)) {
2906                        put_task_struct(iter.task);
2907                        return 0;
2908                }
2909        }
2910        ctx->pos = PID_MAX_LIMIT + TGID_OFFSET;
2911        return 0;
2912}
2913
2914/*
2915 * Tasks
2916 */
2917static const struct pid_entry tid_base_stuff[] = {
2918        DIR("fd",        S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
2919        DIR("fdinfo",    S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
2920        DIR("ns",        S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
2921        REG("environ",   S_IRUSR, proc_environ_operations),
2922        INF("auxv",      S_IRUSR, proc_pid_auxv),
2923        ONE("status",    S_IRUGO, proc_pid_status),
2924        ONE("personality", S_IRUGO, proc_pid_personality),
2925        INF("limits",    S_IRUGO, proc_pid_limits),
2926#ifdef CONFIG_SCHED_DEBUG
2927        REG("sched",     S_IRUGO|S_IWUSR, proc_pid_sched_operations),
2928#endif
2929        REG("comm",      S_IRUGO|S_IWUSR, proc_pid_set_comm_operations),
2930#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
2931        INF("syscall",   S_IRUGO, proc_pid_syscall),
2932#endif
2933        INF("cmdline",   S_IRUGO, proc_pid_cmdline),
2934        ONE("stat",      S_IRUGO, proc_tid_stat),
2935        ONE("statm",     S_IRUGO, proc_pid_statm),
2936        REG("maps",      S_IRUGO, proc_tid_maps_operations),
2937#ifdef CONFIG_CHECKPOINT_RESTORE
2938        REG("children",  S_IRUGO, proc_tid_children_operations),
2939#endif
2940#ifdef CONFIG_NUMA
2941        REG("numa_maps", S_IRUGO, proc_tid_numa_maps_operations),
2942#endif
2943        REG("mem",       S_IRUSR|S_IWUSR, proc_mem_operations),
2944        LNK("cwd",       proc_cwd_link),
2945        LNK("root",      proc_root_link),
2946        LNK("exe",       proc_exe_link),
2947        REG("mounts",    S_IRUGO, proc_mounts_operations),
2948        REG("mountinfo",  S_IRUGO, proc_mountinfo_operations),
2949#ifdef CONFIG_PROC_PAGE_MONITOR
2950        REG("clear_refs", S_IWUSR, proc_clear_refs_operations),
2951        REG("smaps",     S_IRUGO, proc_tid_smaps_operations),
2952        REG("pagemap",    S_IRUGO, proc_pagemap_operations),
2953#endif
2954#ifdef CONFIG_SECURITY
2955        DIR("attr",      S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations),
2956#endif
2957#ifdef CONFIG_KALLSYMS
2958        INF("wchan",     S_IRUGO, proc_pid_wchan),
2959#endif
2960#ifdef CONFIG_STACKTRACE
2961        ONE("stack",      S_IRUGO, proc_pid_stack),
2962#endif
2963#ifdef CONFIG_SCHEDSTATS
2964        INF("schedstat", S_IRUGO, proc_pid_schedstat),
2965#endif
2966#ifdef CONFIG_LATENCYTOP
2967        REG("latency",  S_IRUGO, proc_lstats_operations),
2968#endif
2969#ifdef CONFIG_PROC_PID_CPUSET
2970        REG("cpuset",    S_IRUGO, proc_cpuset_operations),
2971#endif
2972#ifdef CONFIG_CGROUPS
2973        REG("cgroup",  S_IRUGO, proc_cgroup_operations),
2974#endif
2975        INF("oom_score", S_IRUGO, proc_oom_score),
2976        REG("oom_adj",   S_IRUGO|S_IWUSR, proc_oom_adj_operations),
2977        REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
2978#ifdef CONFIG_AUDITSYSCALL
2979        REG("loginuid",  S_IWUSR|S_IRUGO, proc_loginuid_operations),
2980        REG("sessionid",  S_IRUGO, proc_sessionid_operations),
2981#endif
2982#ifdef CONFIG_FAULT_INJECTION
2983        REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),
2984#endif
2985#ifdef CONFIG_TASK_IO_ACCOUNTING
2986        INF("io",       S_IRUSR, proc_tid_io_accounting),
2987#endif
2988#ifdef CONFIG_HARDWALL
2989        INF("hardwall",   S_IRUGO, proc_pid_hardwall),
2990#endif
2991#ifdef CONFIG_USER_NS
2992        REG("uid_map",    S_IRUGO|S_IWUSR, proc_uid_map_operations),
2993        REG("gid_map",    S_IRUGO|S_IWUSR, proc_gid_map_operations),
2994        REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations),
2995#endif
2996};
2997
2998static int proc_tid_base_readdir(struct file *file, struct dir_context *ctx)
2999{
3000        return proc_pident_readdir(file, ctx,
3001                                   tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
3002}
3003
3004static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
3005{
3006        return proc_pident_lookup(dir, dentry,
3007                                  tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
3008}
3009
3010static const struct file_operations proc_tid_base_operations = {
3011        .read           = generic_read_dir,
3012        .iterate        = proc_tid_base_readdir,
3013        .llseek         = default_llseek,
3014};
3015
3016static const struct inode_operations proc_tid_base_inode_operations = {
3017        .lookup         = proc_tid_base_lookup,
3018        .getattr        = pid_getattr,
3019        .setattr        = proc_setattr,
3020};
3021
3022static int proc_task_instantiate(struct inode *dir,
3023        struct dentry *dentry, struct task_struct *task, const void *ptr)
3024{
3025        struct inode *inode;
3026        inode = proc_pid_make_inode(dir->i_sb, task);
3027
3028        if (!inode)
3029                goto out;
3030        inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
3031        inode->i_op = &proc_tid_base_inode_operations;
3032        inode->i_fop = &proc_tid_base_operations;
3033        inode->i_flags|=S_IMMUTABLE;
3034
3035        set_nlink(inode, 2 + pid_entry_count_dirs(tid_base_stuff,
3036                                                  ARRAY_SIZE(tid_base_stuff)));
3037
3038        d_set_d_op(dentry, &pid_dentry_operations);
3039
3040        d_add(dentry, inode);
3041        /* Close the race of the process dying before we return the dentry */
3042        if (pid_revalidate(dentry, 0))
3043                return 0;
3044out:
3045        return -ENOENT;
3046}
3047
3048static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
3049{
3050        int result = -ENOENT;
3051        struct task_struct *task;
3052        struct task_struct *leader = get_proc_task(dir);
3053        unsigned tid;
3054        struct pid_namespace *ns;
3055
3056        if (!leader)
3057                goto out_no_task;
3058
3059        tid = name_to_int(dentry);
3060        if (tid == ~0U)
3061                goto out;
3062
3063        ns = dentry->d_sb->s_fs_info;
3064        rcu_read_lock();
3065        task = find_task_by_pid_ns(tid, ns);
3066        if (task)
3067                get_task_struct(task);
3068        rcu_read_unlock();
3069        if (!task)
3070                goto out;
3071        if (!same_thread_group(leader, task))
3072                goto out_drop_task;
3073
3074        result = proc_task_instantiate(dir, dentry, task, NULL);
3075out_drop_task:
3076        put_task_struct(task);
3077out:
3078        put_task_struct(leader);
3079out_no_task:
3080        return ERR_PTR(result);
3081}
3082
3083/*
3084 * Find the first tid of a thread group to return to user space.
3085 *
3086 * Usually this is just the thread group leader, but if the users
3087 * buffer was too small or there was a seek into the middle of the
3088 * directory we have more work todo.
3089 *
3090 * In the case of a short read we start with find_task_by_pid.
3091 *
3092 * In the case of a seek we start with the leader and walk nr
3093 * threads past it.
3094 */
3095static struct task_struct *first_tid(struct task_struct *leader,
3096                int tid, int nr, struct pid_namespace *ns)
3097{
3098        struct task_struct *pos;
3099
3100        rcu_read_lock();
3101        /* Attempt to start with the pid of a thread */
3102        if (tid && (nr > 0)) {
3103                pos = find_task_by_pid_ns(tid, ns);
3104                if (pos && (pos->group_leader == leader))
3105                        goto found;
3106        }
3107
3108        /* If nr exceeds the number of threads there is nothing todo */
3109        pos = NULL;
3110        if (nr && nr >= get_nr_threads(leader))
3111                goto out;
3112
3113        /* If we haven't found our starting place yet start
3114         * with the leader and walk nr threads forward.
3115         */
3116        for (pos = leader; nr > 0; --nr) {
3117                pos = next_thread(pos);
3118                if (pos == leader) {
3119                        pos = NULL;
3120                        goto out;
3121                }
3122        }
3123found:
3124        get_task_struct(pos);
3125out:
3126        rcu_read_unlock();
3127        return pos;
3128}
3129
3130/*
3131 * Find the next thread in the thread list.
3132 * Return NULL if there is an error or no next thread.
3133 *
3134 * The reference to the input task_struct is released.
3135 */
3136static struct task_struct *next_tid(struct task_struct *start)
3137{
3138        struct task_struct *pos = NULL;
3139        rcu_read_lock();
3140        if (pid_alive(start)) {
3141                pos = next_thread(start);
3142                if (thread_group_leader(pos))
3143                        pos = NULL;
3144                else
3145                        get_task_struct(pos);
3146        }
3147        rcu_read_unlock();
3148        put_task_struct(start);
3149        return pos;
3150}
3151
3152/* for the /proc/TGID/task/ directories */
3153static int proc_task_readdir(struct file *file, struct dir_context *ctx)
3154{
3155        struct task_struct *leader = NULL;
3156        struct task_struct *task = get_proc_task(file_inode(file));
3157        struct pid_namespace *ns;
3158        int tid;
3159
3160        if (!task)
3161                return -ENOENT;
3162        rcu_read_lock();
3163        if (pid_alive(task)) {
3164                leader = task->group_leader;
3165                get_task_struct(leader);
3166        }
3167        rcu_read_unlock();
3168        put_task_struct(task);
3169        if (!leader)
3170                return -ENOENT;
3171
3172        if (!dir_emit_dots(file, ctx))
3173                goto out;
3174
3175        /* f_version caches the tgid value that the last readdir call couldn't
3176         * return. lseek aka telldir automagically resets f_version to 0.
3177         */
3178        ns = file->f_dentry->d_sb->s_fs_info;
3179        tid = (int)file->f_version;
3180        file->f_version = 0;
3181        for (task = first_tid(leader, tid, ctx->pos - 2, ns);
3182             task;
3183             task = next_tid(task), ctx->pos++) {
3184                char name[PROC_NUMBUF];
3185                int len;
3186                tid = task_pid_nr_ns(task, ns);
3187                len = snprintf(name, sizeof(name), "%d", tid);
3188                if (!proc_fill_cache(file, ctx, name, len,
3189                                proc_task_instantiate, task, NULL)) {
3190                        /* returning this tgid failed, save it as the first
3191                         * pid for the next readir call */
3192                        file->f_version = (u64)tid;
3193                        put_task_struct(task);
3194                        break;
3195                }
3196        }
3197out:
3198        put_task_struct(leader);
3199        return 0;
3200}
3201
3202static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
3203{
3204        struct inode *inode = dentry->d_inode;
3205        struct task_struct *p = get_proc_task(inode);
3206        generic_fillattr(inode, stat);
3207
3208        if (p) {
3209                stat->nlink += get_nr_threads(p);
3210                put_task_struct(p);
3211        }
3212
3213        return 0;
3214}
3215
3216static const struct inode_operations proc_task_inode_operations = {
3217        .lookup         = proc_task_lookup,
3218        .getattr        = proc_task_getattr,
3219        .setattr        = proc_setattr,
3220        .permission     = proc_pid_permission,
3221};
3222
3223static const struct file_operations proc_task_operations = {
3224        .read           = generic_read_dir,
3225        .iterate        = proc_task_readdir,
3226        .llseek         = default_llseek,
3227};
3228
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.