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
1661static inline bool proc_inode_is_dead(struct inode *inode)
1662{
1663        return !proc_pid(inode)->tasks[PIDTYPE_PID].first;
1664}
1665
1666int pid_delete_dentry(const struct dentry *dentry)
1667{
1668        /* Is the task we represent dead?
1669         * If so, then don't put the dentry on the lru list,
1670         * kill it immediately.
1671         */
1672        return proc_inode_is_dead(dentry->d_inode);
1673}
1674
1675const struct dentry_operations pid_dentry_operations =
1676{
1677        .d_revalidate   = pid_revalidate,
1678        .d_delete       = pid_delete_dentry,
1679};
1680
1681/* Lookups */
1682
1683/*
1684 * Fill a directory entry.
1685 *
1686 * If possible create the dcache entry and derive our inode number and
1687 * file type from dcache entry.
1688 *
1689 * Since all of the proc inode numbers are dynamically generated, the inode
1690 * numbers do not exist until the inode is cache.  This means creating the
1691 * the dcache entry in readdir is necessary to keep the inode numbers
1692 * reported by readdir in sync with the inode numbers reported
1693 * by stat.
1694 */
1695bool proc_fill_cache(struct file *file, struct dir_context *ctx,
1696        const char *name, int len,
1697        instantiate_t instantiate, struct task_struct *task, const void *ptr)
1698{
1699        struct dentry *child, *dir = file->f_path.dentry;
1700        struct qstr qname = QSTR_INIT(name, len);
1701        struct inode *inode;
1702        unsigned type;
1703        ino_t ino;
1704
1705        child = d_hash_and_lookup(dir, &qname);
1706        if (!child) {
1707                child = d_alloc(dir, &qname);
1708                if (!child)
1709                        goto end_instantiate;
1710                if (instantiate(dir->d_inode, child, task, ptr) < 0) {
1711                        dput(child);
1712                        goto end_instantiate;
1713                }
1714        }
1715        inode = child->d_inode;
1716        ino = inode->i_ino;
1717        type = inode->i_mode >> 12;
1718        dput(child);
1719        return dir_emit(ctx, name, len, ino, type);
1720
1721end_instantiate:
1722        return dir_emit(ctx, name, len, 1, DT_UNKNOWN);
1723}
1724
1725#ifdef CONFIG_CHECKPOINT_RESTORE
1726
1727/*
1728 * dname_to_vma_addr - maps a dentry name into two unsigned longs
1729 * which represent vma start and end addresses.
1730 */
1731static int dname_to_vma_addr(struct dentry *dentry,
1732                             unsigned long *start, unsigned long *end)
1733{
1734        if (sscanf(dentry->d_name.name, "%lx-%lx", start, end) != 2)
1735                return -EINVAL;
1736
1737        return 0;
1738}
1739
1740static int map_files_d_revalidate(struct dentry *dentry, unsigned int flags)
1741{
1742        unsigned long vm_start, vm_end;
1743        bool exact_vma_exists = false;
1744        struct mm_struct *mm = NULL;
1745        struct task_struct *task;
1746        const struct cred *cred;
1747        struct inode *inode;
1748        int status = 0;
1749
1750        if (flags & LOOKUP_RCU)
1751                return -ECHILD;
1752
1753        if (!capable(CAP_SYS_ADMIN)) {
1754                status = -EPERM;
1755                goto out_notask;
1756        }
1757
1758        inode = dentry->d_inode;
1759        task = get_proc_task(inode);
1760        if (!task)
1761                goto out_notask;
1762
1763        mm = mm_access(task, PTRACE_MODE_READ);
1764        if (IS_ERR_OR_NULL(mm))
1765                goto out;
1766
1767        if (!dname_to_vma_addr(dentry, &vm_start, &vm_end)) {
1768                down_read(&mm->mmap_sem);
1769                exact_vma_exists = !!find_exact_vma(mm, vm_start, vm_end);
1770                up_read(&mm->mmap_sem);
1771        }
1772
1773        mmput(mm);
1774
1775        if (exact_vma_exists) {
1776                if (task_dumpable(task)) {
1777                        rcu_read_lock();
1778                        cred = __task_cred(task);
1779                        inode->i_uid = cred->euid;
1780                        inode->i_gid = cred->egid;
1781                        rcu_read_unlock();
1782                } else {
1783                        inode->i_uid = GLOBAL_ROOT_UID;
1784                        inode->i_gid = GLOBAL_ROOT_GID;
1785                }
1786                security_task_to_inode(task, inode);
1787                status = 1;
1788        }
1789
1790out:
1791        put_task_struct(task);
1792
1793out_notask:
1794        if (status <= 0)
1795                d_drop(dentry);
1796
1797        return status;
1798}
1799
1800static const struct dentry_operations tid_map_files_dentry_operations = {
1801        .d_revalidate   = map_files_d_revalidate,
1802        .d_delete       = pid_delete_dentry,
1803};
1804
1805static int proc_map_files_get_link(struct dentry *dentry, struct path *path)
1806{
1807        unsigned long vm_start, vm_end;
1808        struct vm_area_struct *vma;
1809        struct task_struct *task;
1810        struct mm_struct *mm;
1811        int rc;
1812
1813        rc = -ENOENT;
1814        task = get_proc_task(dentry->d_inode);
1815        if (!task)
1816                goto out;
1817
1818        mm = get_task_mm(task);
1819        put_task_struct(task);
1820        if (!mm)
1821                goto out;
1822
1823        rc = dname_to_vma_addr(dentry, &vm_start, &vm_end);
1824        if (rc)
1825                goto out_mmput;
1826
1827        rc = -ENOENT;
1828        down_read(&mm->mmap_sem);
1829        vma = find_exact_vma(mm, vm_start, vm_end);
1830        if (vma && vma->vm_file) {
1831                *path = vma->vm_file->f_path;
1832                path_get(path);
1833                rc = 0;
1834        }
1835        up_read(&mm->mmap_sem);
1836
1837out_mmput:
1838        mmput(mm);
1839out:
1840        return rc;
1841}
1842
1843struct map_files_info {
1844        fmode_t         mode;
1845        unsigned long   len;
1846        unsigned char   name[4*sizeof(long)+2]; /* max: %lx-%lx\0 */
1847};
1848
1849static int
1850proc_map_files_instantiate(struct inode *dir, struct dentry *dentry,
1851                           struct task_struct *task, const void *ptr)
1852{
1853        fmode_t mode = (fmode_t)(unsigned long)ptr;
1854        struct proc_inode *ei;
1855        struct inode *inode;
1856
1857        inode = proc_pid_make_inode(dir->i_sb, task);
1858        if (!inode)
1859                return -ENOENT;
1860
1861        ei = PROC_I(inode);
1862        ei->op.proc_get_link = proc_map_files_get_link;
1863
1864        inode->i_op = &proc_pid_link_inode_operations;
1865        inode->i_size = 64;
1866        inode->i_mode = S_IFLNK;
1867
1868        if (mode & FMODE_READ)
1869                inode->i_mode |= S_IRUSR;
1870        if (mode & FMODE_WRITE)
1871                inode->i_mode |= S_IWUSR;
1872
1873        d_set_d_op(dentry, &tid_map_files_dentry_operations);
1874        d_add(dentry, inode);
1875
1876        return 0;
1877}
1878
1879static struct dentry *proc_map_files_lookup(struct inode *dir,
1880                struct dentry *dentry, unsigned int flags)
1881{
1882        unsigned long vm_start, vm_end;
1883        struct vm_area_struct *vma;
1884        struct task_struct *task;
1885        int result;
1886        struct mm_struct *mm;
1887
1888        result = -EPERM;
1889        if (!capable(CAP_SYS_ADMIN))
1890                goto out;
1891
1892        result = -ENOENT;
1893        task = get_proc_task(dir);
1894        if (!task)
1895                goto out;
1896
1897        result = -EACCES;
1898        if (!ptrace_may_access(task, PTRACE_MODE_READ))
1899                goto out_put_task;
1900
1901        result = -ENOENT;
1902        if (dname_to_vma_addr(dentry, &vm_start, &vm_end))
1903                goto out_put_task;
1904
1905        mm = get_task_mm(task);
1906        if (!mm)
1907                goto out_put_task;
1908
1909        down_read(&mm->mmap_sem);
1910        vma = find_exact_vma(mm, vm_start, vm_end);
1911        if (!vma)
1912                goto out_no_vma;
1913
1914        if (vma->vm_file)
1915                result = proc_map_files_instantiate(dir, dentry, task,
1916                                (void *)(unsigned long)vma->vm_file->f_mode);
1917
1918out_no_vma:
1919        up_read(&mm->mmap_sem);
1920        mmput(mm);
1921out_put_task:
1922        put_task_struct(task);
1923out:
1924        return ERR_PTR(result);
1925}
1926
1927static const struct inode_operations proc_map_files_inode_operations = {
1928        .lookup         = proc_map_files_lookup,
1929        .permission     = proc_fd_permission,
1930        .setattr        = proc_setattr,
1931};
1932
1933static int
1934proc_map_files_readdir(struct file *file, struct dir_context *ctx)
1935{
1936        struct vm_area_struct *vma;
1937        struct task_struct *task;
1938        struct mm_struct *mm;
1939        unsigned long nr_files, pos, i;
1940        struct flex_array *fa = NULL;
1941        struct map_files_info info;
1942        struct map_files_info *p;
1943        int ret;
1944
1945        ret = -EPERM;
1946        if (!capable(CAP_SYS_ADMIN))
1947                goto out;
1948
1949        ret = -ENOENT;
1950        task = get_proc_task(file_inode(file));
1951        if (!task)
1952                goto out;
1953
1954        ret = -EACCES;
1955        if (!ptrace_may_access(task, PTRACE_MODE_READ))
1956                goto out_put_task;
1957
1958        ret = 0;
1959        if (!dir_emit_dots(file, ctx))
1960                goto out_put_task;
1961
1962        mm = get_task_mm(task);
1963        if (!mm)
1964                goto out_put_task;
1965        down_read(&mm->mmap_sem);
1966
1967        nr_files = 0;
1968
1969        /*
1970         * We need two passes here:
1971         *
1972         *  1) Collect vmas of mapped files with mmap_sem taken
1973         *  2) Release mmap_sem and instantiate entries
1974         *
1975         * otherwise we get lockdep complained, since filldir()
1976         * routine might require mmap_sem taken in might_fault().
1977         */
1978
1979        for (vma = mm->mmap, pos = 2; vma; vma = vma->vm_next) {
1980                if (vma->vm_file && ++pos > ctx->pos)
1981                        nr_files++;
1982        }
1983
1984        if (nr_files) {
1985                fa = flex_array_alloc(sizeof(info), nr_files,
1986                                        GFP_KERNEL);
1987                if (!fa || flex_array_prealloc(fa, 0, nr_files,
1988                                                GFP_KERNEL)) {
1989                        ret = -ENOMEM;
1990                        if (fa)
1991                                flex_array_free(fa);
1992                        up_read(&mm->mmap_sem);
1993                        mmput(mm);
1994                        goto out_put_task;
1995                }
1996                for (i = 0, vma = mm->mmap, pos = 2; vma;
1997                                vma = vma->vm_next) {
1998                        if (!vma->vm_file)
1999                                continue;
2000                        if (++pos <= ctx->pos)
2001                                continue;
2002
2003                        info.mode = vma->vm_file->f_mode;
2004                        info.len = snprintf(info.name,
2005                                        sizeof(info.name), "%lx-%lx",
2006                                        vma->vm_start, vma->vm_end);
2007                        if (flex_array_put(fa, i++, &info, GFP_KERNEL))
2008                                BUG();
2009                }
2010        }
2011        up_read(&mm->mmap_sem);
2012
2013        for (i = 0; i < nr_files; i++) {
2014                p = flex_array_get(fa, i);
2015                if (!proc_fill_cache(file, ctx,
2016                                      p->name, p->len,
2017                                      proc_map_files_instantiate,
2018                                      task,
2019                                      (void *)(unsigned long)p->mode))
2020                        break;
2021                ctx->pos++;
2022        }
2023        if (fa)
2024                flex_array_free(fa);
2025        mmput(mm);
2026
2027out_put_task:
2028        put_task_struct(task);
2029out:
2030        return ret;
2031}
2032
2033static const struct file_operations proc_map_files_operations = {
2034        .read           = generic_read_dir,
2035        .iterate        = proc_map_files_readdir,
2036        .llseek         = default_llseek,
2037};
2038
2039struct timers_private {
2040        struct pid *pid;
2041        struct task_struct *task;
2042        struct sighand_struct *sighand;
2043        struct pid_namespace *ns;
2044        unsigned long flags;
2045};
2046
2047static void *timers_start(struct seq_file *m, loff_t *pos)
2048{
2049        struct timers_private *tp = m->private;
2050
2051        tp->task = get_pid_task(tp->pid, PIDTYPE_PID);
2052        if (!tp->task)
2053                return ERR_PTR(-ESRCH);
2054
2055        tp->sighand = lock_task_sighand(tp->task, &tp->flags);
2056        if (!tp->sighand)
2057                return ERR_PTR(-ESRCH);
2058
2059        return seq_list_start(&tp->task->signal->posix_timers, *pos);
2060}
2061
2062static void *timers_next(struct seq_file *m, void *v, loff_t *pos)
2063{
2064        struct timers_private *tp = m->private;
2065        return seq_list_next(v, &tp->task->signal->posix_timers, pos);
2066}
2067
2068static void timers_stop(struct seq_file *m, void *v)
2069{
2070        struct timers_private *tp = m->private;
2071
2072        if (tp->sighand) {
2073                unlock_task_sighand(tp->task, &tp->flags);
2074                tp->sighand = NULL;
2075        }
2076
2077        if (tp->task) {
2078                put_task_struct(tp->task);
2079                tp->task = NULL;
2080        }
2081}
2082
2083static int show_timer(struct seq_file *m, void *v)
2084{
2085        struct k_itimer *timer;
2086        struct timers_private *tp = m->private;
2087        int notify;
2088        static char *nstr[] = {
2089                [SIGEV_SIGNAL] = "signal",
2090                [SIGEV_NONE] = "none",
2091                [SIGEV_THREAD] = "thread",
2092        };
2093
2094        timer = list_entry((struct list_head *)v, struct k_itimer, list);
2095        notify = timer->it_sigev_notify;
2096
2097        seq_printf(m, "ID: %d\n", timer->it_id);
2098        seq_printf(m, "signal: %d/%p\n", timer->sigq->info.si_signo,
2099                        timer->sigq->info.si_value.sival_ptr);
2100        seq_printf(m, "notify: %s/%s.%d\n",
2101                nstr[notify & ~SIGEV_THREAD_ID],
2102                (notify & SIGEV_THREAD_ID) ? "tid" : "pid",
2103                pid_nr_ns(timer->it_pid, tp->ns));
2104        seq_printf(m, "ClockID: %d\n", timer->it_clock);
2105
2106        return 0;
2107}
2108
2109static const struct seq_operations proc_timers_seq_ops = {
2110        .start  = timers_start,
2111        .next   = timers_next,
2112        .stop   = timers_stop,
2113        .show   = show_timer,
2114};
2115
2116static int proc_timers_open(struct inode *inode, struct file *file)
2117{
2118        struct timers_private *tp;
2119
2120        tp = __seq_open_private(file, &proc_timers_seq_ops,
2121                        sizeof(struct timers_private));
2122        if (!tp)
2123                return -ENOMEM;
2124
2125        tp->pid = proc_pid(inode);
2126        tp->ns = inode->i_sb->s_fs_info;
2127        return 0;
2128}
2129
2130static const struct file_operations proc_timers_operations = {
2131        .open           = proc_timers_open,
2132        .read           = seq_read,
2133        .llseek         = seq_lseek,
2134        .release        = seq_release_private,
2135};
2136#endif /* CONFIG_CHECKPOINT_RESTORE */
2137
2138static int proc_pident_instantiate(struct inode *dir,
2139        struct dentry *dentry, struct task_struct *task, const void *ptr)
2140{
2141        const struct pid_entry *p = ptr;
2142        struct inode *inode;
2143        struct proc_inode *ei;
2144
2145        inode = proc_pid_make_inode(dir->i_sb, task);
2146        if (!inode)
2147                goto out;
2148
2149        ei = PROC_I(inode);
2150        inode->i_mode = p->mode;
2151        if (S_ISDIR(inode->i_mode))
2152                set_nlink(inode, 2);    /* Use getattr to fix if necessary */
2153        if (p->iop)
2154                inode->i_op = p->iop;
2155        if (p->fop)
2156                inode->i_fop = p->fop;
2157        ei->op = p->op;
2158        d_set_d_op(dentry, &pid_dentry_operations);
2159        d_add(dentry, inode);
2160        /* Close the race of the process dying before we return the dentry */
2161        if (pid_revalidate(dentry, 0))
2162                return 0;
2163out:
2164        return -ENOENT;
2165}
2166
2167static struct dentry *proc_pident_lookup(struct inode *dir, 
2168                                         struct dentry *dentry,
2169                                         const struct pid_entry *ents,
2170                                         unsigned int nents)
2171{
2172        int error;
2173        struct task_struct *task = get_proc_task(dir);
2174        const struct pid_entry *p, *last;
2175
2176        error = -ENOENT;
2177
2178        if (!task)
2179                goto out_no_task;
2180
2181        /*
2182         * Yes, it does not scale. And it should not. Don't add
2183         * new entries into /proc/<tgid>/ without very good reasons.
2184         */
2185        last = &ents[nents - 1];
2186        for (p = ents; p <= last; p++) {
2187                if (p->len != dentry->d_name.len)
2188                        continue;
2189                if (!memcmp(dentry->d_name.name, p->name, p->len))
2190                        break;
2191        }
2192        if (p > last)
2193                goto out;
2194
2195        error = proc_pident_instantiate(dir, dentry, task, p);
2196out:
2197        put_task_struct(task);
2198out_no_task:
2199        return ERR_PTR(error);
2200}
2201
2202static int proc_pident_readdir(struct file *file, struct dir_context *ctx,
2203                const struct pid_entry *ents, unsigned int nents)
2204{
2205        struct task_struct *task = get_proc_task(file_inode(file));
2206        const struct pid_entry *p;
2207
2208        if (!task)
2209                return -ENOENT;
2210
2211        if (!dir_emit_dots(file, ctx))
2212                goto out;
2213
2214        if (ctx->pos >= nents + 2)
2215                goto out;
2216
2217        for (p = ents + (ctx->pos - 2); p <= ents + nents - 1; p++) {
2218                if (!proc_fill_cache(file, ctx, p->name, p->len,
2219                                proc_pident_instantiate, task, p))
2220                        break;
2221                ctx->pos++;
2222        }
2223out:
2224        put_task_struct(task);
2225        return 0;
2226}
2227
2228#ifdef CONFIG_SECURITY
2229static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,
2230                                  size_t count, loff_t *ppos)
2231{
2232        struct inode * inode = file_inode(file);
2233        char *p = NULL;
2234        ssize_t length;
2235        struct task_struct *task = get_proc_task(inode);
2236
2237        if (!task)
2238                return -ESRCH;
2239
2240        length = security_getprocattr(task,
2241                                      (char*)file->f_path.dentry->d_name.name,
2242                                      &p);
2243        put_task_struct(task);
2244        if (length > 0)
2245                length = simple_read_from_buffer(buf, count, ppos, p, length);
2246        kfree(p);
2247        return length;
2248}
2249
2250static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,
2251                                   size_t count, loff_t *ppos)
2252{
2253        struct inode * inode = file_inode(file);
2254        char *page;
2255        ssize_t length;
2256        struct task_struct *task = get_proc_task(inode);
2257
2258        length = -ESRCH;
2259        if (!task)
2260                goto out_no_task;
2261        if (count > PAGE_SIZE)
2262                count = PAGE_SIZE;
2263
2264        /* No partial writes. */
2265        length = -EINVAL;
2266        if (*ppos != 0)
2267                goto out;
2268
2269        length = -ENOMEM;
2270        page = (char*)__get_free_page(GFP_TEMPORARY);
2271        if (!page)
2272                goto out;
2273
2274        length = -EFAULT;
2275        if (copy_from_user(page, buf, count))
2276                goto out_free;
2277
2278        /* Guard against adverse ptrace interaction */
2279        length = mutex_lock_interruptible(&task->signal->cred_guard_mutex);
2280        if (length < 0)
2281                goto out_free;
2282
2283        length = security_setprocattr(task,
2284                                      (char*)file->f_path.dentry->d_name.name,
2285                                      (void*)page, count);
2286        mutex_unlock(&task->signal->cred_guard_mutex);
2287out_free:
2288        free_page((unsigned long) page);
2289out:
2290        put_task_struct(task);
2291out_no_task:
2292        return length;
2293}
2294
2295static const struct file_operations proc_pid_attr_operations = {
2296        .read           = proc_pid_attr_read,
2297        .write          = proc_pid_attr_write,
2298        .llseek         = generic_file_llseek,
2299};
2300
2301static const struct pid_entry attr_dir_stuff[] = {
2302        REG("current",    S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2303        REG("prev",       S_IRUGO,         proc_pid_attr_operations),
2304        REG("exec",       S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2305        REG("fscreate",   S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2306        REG("keycreate",  S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2307        REG("sockcreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2308};
2309
2310static int proc_attr_dir_readdir(struct file *file, struct dir_context *ctx)
2311{
2312        return proc_pident_readdir(file, ctx, 
2313                                   attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
2314}
2315
2316static const struct file_operations proc_attr_dir_operations = {
2317        .read           = generic_read_dir,
2318        .iterate        = proc_attr_dir_readdir,
2319        .llseek         = default_llseek,
2320};
2321
2322static struct dentry *proc_attr_dir_lookup(struct inode *dir,
2323                                struct dentry *dentry, unsigned int flags)
2324{
2325        return proc_pident_lookup(dir, dentry,
2326                                  attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
2327}
2328
2329static const struct inode_operations proc_attr_dir_inode_operations = {
2330        .lookup         = proc_attr_dir_lookup,
2331        .getattr        = pid_getattr,
2332        .setattr        = proc_setattr,
2333};
2334
2335#endif
2336
2337#ifdef CONFIG_ELF_CORE
2338static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf,
2339                                         size_t count, loff_t *ppos)
2340{
2341        struct task_struct *task = get_proc_task(file_inode(file));
2342        struct mm_struct *mm;
2343        char buffer[PROC_NUMBUF];
2344        size_t len;
2345        int ret;
2346
2347        if (!task)
2348                return -ESRCH;
2349
2350        ret = 0;
2351        mm = get_task_mm(task);
2352        if (mm) {
2353                len = snprintf(buffer, sizeof(buffer), "%08lx\n",
2354                               ((mm->flags & MMF_DUMP_FILTER_MASK) >>
2355                                MMF_DUMP_FILTER_SHIFT));
2356                mmput(mm);
2357                ret = simple_read_from_buffer(buf, count, ppos, buffer, len);
2358        }
2359
2360        put_task_struct(task);
2361
2362        return ret;
2363}
2364
2365static ssize_t proc_coredump_filter_write(struct file *file,
2366                                          const char __user *buf,
2367                                          size_t count,
2368                                          loff_t *ppos)
2369{
2370        struct task_struct *task;
2371        struct mm_struct *mm;
2372        char buffer[PROC_NUMBUF], *end;
2373        unsigned int val;
2374        int ret;
2375        int i;
2376        unsigned long mask;
2377
2378        ret = -EFAULT;
2379        memset(buffer, 0, sizeof(buffer));
2380        if (count > sizeof(buffer) - 1)
2381                count = sizeof(buffer) - 1;
2382        if (copy_from_user(buffer, buf, count))
2383                goto out_no_task;
2384
2385        ret = -EINVAL;
2386        val = (unsigned int)simple_strtoul(buffer, &end, 0);
2387        if (*end == '\n')
2388                end++;
2389        if (end - buffer == 0)
2390                goto out_no_task;
2391
2392        ret = -ESRCH;
2393        task = get_proc_task(file_inode(file));
2394        if (!task)
2395                goto out_no_task;
2396
2397        ret = end - buffer;
2398        mm = get_task_mm(task);
2399        if (!mm)
2400                goto out_no_mm;
2401
2402        for (i = 0, mask = 1; i < MMF_DUMP_FILTER_BITS; i++, mask <<= 1) {
2403                if (val & mask)
2404                        set_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
2405                else
2406                        clear_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
2407        }
2408
2409        mmput(mm);
2410 out_no_mm:
2411        put_task_struct(task);
2412 out_no_task:
2413        return ret;
2414}
2415
2416static const struct file_operations proc_coredump_filter_operations = {
2417        .read           = proc_coredump_filter_read,
2418        .write          = proc_coredump_filter_write,
2419        .llseek         = generic_file_llseek,
2420};
2421#endif
2422
2423#ifdef CONFIG_TASK_IO_ACCOUNTING
2424static int do_io_accounting(struct task_struct *task, char *buffer, int whole)
2425{
2426        struct task_io_accounting acct = task->ioac;
2427        unsigned long flags;
2428        int result;
2429
2430        result = mutex_lock_killable(&task->signal->cred_guard_mutex);
2431        if (result)
2432                return result;
2433
2434        if (!ptrace_may_access(task, PTRACE_MODE_READ)) {
2435                result = -EACCES;
2436                goto out_unlock;
2437        }
2438
2439        if (whole && lock_task_sighand(task, &flags)) {
2440                struct task_struct *t = task;
2441
2442                task_io_accounting_add(&acct, &task->signal->ioac);
2443                while_each_thread(task, t)
2444                        task_io_accounting_add(&acct, &t->ioac);
2445
2446                unlock_task_sighand(task, &flags);
2447        }
2448        result = sprintf(buffer,
2449                        "rchar: %llu\n"
2450                        "wchar: %llu\n"
2451                        "syscr: %llu\n"
2452                        "syscw: %llu\n"
2453                        "read_bytes: %llu\n"
2454                        "write_bytes: %llu\n"
2455                        "cancelled_write_bytes: %llu\n",
2456                        (unsigned long long)acct.rchar,
2457                        (unsigned long long)acct.wchar,
2458                        (unsigned long long)acct.syscr,
2459                        (unsigned long long)acct.syscw,
2460                        (unsigned long long)acct.read_bytes,
2461                        (unsigned long long)acct.write_bytes,
2462                        (unsigned long long)acct.cancelled_write_bytes);
2463out_unlock:
2464        mutex_unlock(&task->signal->cred_guard_mutex);
2465        return result;
2466}
2467
2468static int proc_tid_io_accounting(struct task_struct *task, char *buffer)
2469{
2470        return do_io_accounting(task, buffer, 0);
2471}
2472
2473static int proc_tgid_io_accounting(struct task_struct *task, char *buffer)
2474{
2475        return do_io_accounting(task, buffer, 1);
2476}
2477#endif /* CONFIG_TASK_IO_ACCOUNTING */
2478
2479#ifdef CONFIG_USER_NS
2480static int proc_id_map_open(struct inode *inode, struct file *file,
2481        struct seq_operations *seq_ops)
2482{
2483        struct user_namespace *ns = NULL;
2484        struct task_struct *task;
2485        struct seq_file *seq;
2486        int ret = -EINVAL;
2487
2488        task = get_proc_task(inode);
2489        if (task) {
2490                rcu_read_lock();
2491                ns = get_user_ns(task_cred_xxx(task, user_ns));
2492                rcu_read_unlock();
2493                put_task_struct(task);
2494        }
2495        if (!ns)
2496                goto err;
2497
2498        ret = seq_open(file, seq_ops);
2499        if (ret)
2500                goto err_put_ns;
2501
2502        seq = file->private_data;
2503        seq->private = ns;
2504
2505        return 0;
2506err_put_ns:
2507        put_user_ns(ns);
2508err:
2509        return ret;
2510}
2511
2512static int proc_id_map_release(struct inode *inode, struct file *file)
2513{
2514        struct seq_file *seq = file->private_data;
2515        struct user_namespace *ns = seq->private;
2516        put_user_ns(ns);
2517        return seq_release(inode, file);
2518}
2519
2520static int proc_uid_map_open(struct inode *inode, struct file *file)
2521{
2522        return proc_id_map_open(inode, file, &proc_uid_seq_operations);
2523}
2524
2525static int proc_gid_map_open(struct inode *inode, struct file *file)
2526{
2527        return proc_id_map_open(inode, file, &proc_gid_seq_operations);
2528}
2529
2530static int proc_projid_map_open(struct inode *inode, struct file *file)
2531{
2532        return proc_id_map_open(inode, file, &proc_projid_seq_operations);
2533}
2534
2535static const struct file_operations proc_uid_map_operations = {
2536        .open           = proc_uid_map_open,
2537        .write          = proc_uid_map_write,
2538        .read           = seq_read,
2539        .llseek         = seq_lseek,
2540        .release        = proc_id_map_release,
2541};
2542
2543static const struct file_operations proc_gid_map_operations = {
2544        .open           = proc_gid_map_open,
2545        .write          = proc_gid_map_write,
2546        .read           = seq_read,
2547        .llseek         = seq_lseek,
2548        .release        = proc_id_map_release,
2549};
2550
2551static const struct file_operations proc_projid_map_operations = {
2552        .open           = proc_projid_map_open,
2553        .write          = proc_projid_map_write,
2554        .read           = seq_read,
2555        .llseek         = seq_lseek,
2556        .release        = proc_id_map_release,
2557};
2558#endif /* CONFIG_USER_NS */
2559
2560static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns,
2561                                struct pid *pid, struct task_struct *task)
2562{
2563        int err = lock_trace(task);
2564        if (!err) {
2565                seq_printf(m, "%08x\n", task->personality);
2566                unlock_trace(task);
2567        }
2568        return err;
2569}
2570
2571/*
2572 * Thread groups
2573 */
2574static const struct file_operations proc_task_operations;
2575static const struct inode_operations proc_task_inode_operations;
2576
2577static const struct pid_entry tgid_base_stuff[] = {
2578        DIR("task",       S_IRUGO|S_IXUGO, proc_task_inode_operations, proc_task_operations),
2579        DIR("fd",         S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
2580#ifdef CONFIG_CHECKPOINT_RESTORE
2581        DIR("map_files",  S_IRUSR|S_IXUSR, proc_map_files_inode_operations, proc_map_files_operations),
2582#endif
2583        DIR("fdinfo",     S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
2584        DIR("ns",         S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
2585#ifdef CONFIG_NET
2586        DIR("net",        S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations),
2587#endif
2588        REG("environ",    S_IRUSR, proc_environ_operations),
2589        INF("auxv",       S_IRUSR, proc_pid_auxv),
2590        ONE("status",     S_IRUGO, proc_pid_status),
2591        ONE("personality", S_IRUGO, proc_pid_personality),
2592        INF("limits",     S_IRUGO, proc_pid_limits),
2593#ifdef CONFIG_SCHED_DEBUG
2594        REG("sched",      S_IRUGO|S_IWUSR, proc_pid_sched_operations),
2595#endif
2596#ifdef CONFIG_SCHED_AUTOGROUP
2597        REG("autogroup",  S_IRUGO|S_IWUSR, proc_pid_sched_autogroup_operations),
2598#endif
2599        REG("comm",      S_IRUGO|S_IWUSR, proc_pid_set_comm_operations),
2600#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
2601        INF("syscall",    S_IRUGO, proc_pid_syscall),
2602#endif
2603        INF("cmdline",    S_IRUGO, proc_pid_cmdline),
2604        ONE("stat",       S_IRUGO, proc_tgid_stat),
2605        ONE("statm",      S_IRUGO, proc_pid_statm),
2606        REG("maps",       S_IRUGO, proc_pid_maps_operations),
2607#ifdef CONFIG_NUMA
2608        REG("numa_maps",  S_IRUGO, proc_pid_numa_maps_operations),
2609#endif
2610        REG("mem",        S_IRUSR|S_IWUSR, proc_mem_operations),
2611        LNK("cwd",        proc_cwd_link),
2612        LNK("root",       proc_root_link),
2613        LNK("exe",        proc_exe_link),
2614        REG("mounts",     S_IRUGO, proc_mounts_operations),
2615        REG("mountinfo",  S_IRUGO, proc_mountinfo_operations),
2616        REG("mountstats", S_IRUSR, proc_mountstats_operations),
2617#ifdef CONFIG_PROC_PAGE_MONITOR
2618        REG("clear_refs", S_IWUSR, proc_clear_refs_operations),
2619        REG("smaps",      S_IRUGO, proc_pid_smaps_operations),
2620        REG("pagemap",    S_IRUGO, proc_pagemap_operations),
2621#endif
2622#ifdef CONFIG_SECURITY
2623        DIR("attr",       S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations),
2624#endif
2625#ifdef CONFIG_KALLSYMS
2626        INF("wchan",      S_IRUGO, proc_pid_wchan),
2627#endif
2628#ifdef CONFIG_STACKTRACE
2629        ONE("stack",      S_IRUGO, proc_pid_stack),
2630#endif
2631#ifdef CONFIG_SCHEDSTATS
2632        INF("schedstat",  S_IRUGO, proc_pid_schedstat),
2633#endif
2634#ifdef CONFIG_LATENCYTOP
2635        REG("latency",  S_IRUGO, proc_lstats_operations),
2636#endif
2637#ifdef CONFIG_PROC_PID_CPUSET
2638        REG("cpuset",     S_IRUGO, proc_cpuset_operations),
2639#endif
2640#ifdef CONFIG_CGROUPS
2641        REG("cgroup",  S_IRUGO, proc_cgroup_operations),
2642#endif
2643        INF("oom_score",  S_IRUGO, proc_oom_score),
2644        REG("oom_adj",    S_IRUGO|S_IWUSR, proc_oom_adj_operations),
2645        REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
2646#ifdef CONFIG_AUDITSYSCALL
2647        REG("loginuid",   S_IWUSR|S_IRUGO, proc_loginuid_operations),
2648        REG("sessionid",  S_IRUGO, proc_sessionid_operations),
2649#endif
2650#ifdef CONFIG_FAULT_INJECTION
2651        REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),
2652#endif
2653#ifdef CONFIG_ELF_CORE
2654        REG("coredump_filter", S_IRUGO|S_IWUSR, proc_coredump_filter_operations),
2655#endif
2656#ifdef CONFIG_TASK_IO_ACCOUNTING
2657        INF("io",       S_IRUSR, proc_tgid_io_accounting),
2658#endif
2659#ifdef CONFIG_HARDWALL
2660        INF("hardwall",   S_IRUGO, proc_pid_hardwall),
2661#endif
2662#ifdef CONFIG_USER_NS
2663        REG("uid_map",    S_IRUGO|S_IWUSR, proc_uid_map_operations),
2664        REG("gid_map",    S_IRUGO|S_IWUSR, proc_gid_map_operations),
2665        REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations),
2666#endif
2667#ifdef CONFIG_CHECKPOINT_RESTORE
2668        REG("timers",     S_IRUGO, proc_timers_operations),
2669#endif
2670};
2671
2672static int proc_tgid_base_readdir(struct file *file, struct dir_context *ctx)
2673{
2674        return proc_pident_readdir(file, ctx,
2675                                   tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
2676}
2677
2678static const struct file_operations proc_tgid_base_operations = {
2679        .read           = generic_read_dir,
2680        .iterate        = proc_tgid_base_readdir,
2681        .llseek         = default_llseek,
2682};
2683
2684static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
2685{
2686        return proc_pident_lookup(dir, dentry,
2687                                  tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
2688}
2689
2690static const struct inode_operations proc_tgid_base_inode_operations = {
2691        .lookup         = proc_tgid_base_lookup,
2692        .getattr        = pid_getattr,
2693        .setattr        = proc_setattr,
2694        .permission     = proc_pid_permission,
2695};
2696
2697static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
2698{
2699        struct dentry *dentry, *leader, *dir;
2700        char buf[PROC_NUMBUF];
2701        struct qstr name;
2702
2703        name.name = buf;
2704        name.len = snprintf(buf, sizeof(buf), "%d", pid);
2705        /* no ->d_hash() rejects on procfs */
2706        dentry = d_hash_and_lookup(mnt->mnt_root, &name);
2707        if (dentry) {
2708                shrink_dcache_parent(dentry);
2709                d_drop(dentry);
2710                dput(dentry);
2711        }
2712
2713        name.name = buf;
2714        name.len = snprintf(buf, sizeof(buf), "%d", tgid);
2715        leader = d_hash_and_lookup(mnt->mnt_root, &name);
2716        if (!leader)
2717                goto out;
2718
2719        name.name = "task";
2720        name.len = strlen(name.name);
2721        dir = d_hash_and_lookup(leader, &name);
2722        if (!dir)
2723                goto out_put_leader;
2724
2725        name.name = buf;
2726        name.len = snprintf(buf, sizeof(buf), "%d", pid);
2727        dentry = d_hash_and_lookup(dir, &name);
2728        if (dentry) {
2729                shrink_dcache_parent(dentry);
2730                d_drop(dentry);
2731                dput(dentry);
2732        }
2733
2734        dput(dir);
2735out_put_leader:
2736        dput(leader);
2737out:
2738        return;
2739}
2740
2741/**
2742 * proc_flush_task -  Remove dcache entries for @task from the /proc dcache.
2743 * @task: task that should be flushed.
2744 *
2745 * When flushing dentries from proc, one needs to flush them from global
2746 * proc (proc_mnt) and from all the namespaces' procs this task was seen
2747 * in. This call is supposed to do all of this job.
2748 *
2749 * Looks in the dcache for
2750 * /proc/@pid
2751 * /proc/@tgid/task/@pid
2752 * if either directory is present flushes it and all of it'ts children
2753 * from the dcache.
2754 *
2755 * It is safe and reasonable to cache /proc entries for a task until
2756 * that task exits.  After that they just clog up the dcache with
2757 * useless entries, possibly causing useful dcache entries to be
2758 * flushed instead.  This routine is proved to flush those useless
2759 * dcache entries at process exit time.
2760 *
2761 * NOTE: This routine is just an optimization so it does not guarantee
2762 *       that no dcache entries will exist at process exit time it
2763 *       just makes it very unlikely that any will persist.
2764 */
2765
2766void proc_flush_task(struct task_struct *task)
2767{
2768        int i;
2769        struct pid *pid, *tgid;
2770        struct upid *upid;
2771
2772        pid = task_pid(task);
2773        tgid = task_tgid(task);
2774
2775        for (i = 0; i <= pid->level; i++) {
2776                upid = &pid->numbers[i];
2777                proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr,
2778                                        tgid->numbers[i].nr);
2779        }
2780}
2781
2782static int proc_pid_instantiate(struct inode *dir,
2783                                   struct dentry * dentry,
2784                                   struct task_struct *task, const void *ptr)
2785{
2786        struct inode *inode;
2787
2788        inode = proc_pid_make_inode(dir->i_sb, task);
2789        if (!inode)
2790                goto out;
2791
2792        inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
2793        inode->i_op = &proc_tgid_base_inode_operations;
2794        inode->i_fop = &proc_tgid_base_operations;
2795        inode->i_flags|=S_IMMUTABLE;
2796
2797        set_nlink(inode, 2 + pid_entry_count_dirs(tgid_base_stuff,
2798                                                  ARRAY_SIZE(tgid_base_stuff)));
2799
2800        d_set_d_op(dentry, &pid_dentry_operations);
2801
2802        d_add(dentry, inode);
2803        /* Close the race of the process dying before we return the dentry */
2804        if (pid_revalidate(dentry, 0))
2805                return 0;
2806out:
2807        return -ENOENT;
2808}
2809
2810struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
2811{
2812        int result = 0;
2813        struct task_struct *task;
2814        unsigned tgid;
2815        struct pid_namespace *ns;
2816
2817        tgid = name_to_int(dentry);
2818        if (tgid == ~0U)
2819                goto out;
2820
2821        ns = dentry->d_sb->s_fs_info;
2822        rcu_read_lock();
2823        task = find_task_by_pid_ns(tgid, ns);
2824        if (task)
2825                get_task_struct(task);
2826        rcu_read_unlock();
2827        if (!task)
2828                goto out;
2829
2830        result = proc_pid_instantiate(dir, dentry, task, NULL);
2831        put_task_struct(task);
2832out:
2833        return ERR_PTR(result);
2834}
2835
2836/*
2837 * Find the first task with tgid >= tgid
2838 *
2839 */
2840struct tgid_iter {
2841        unsigned int tgid;
2842        struct task_struct *task;
2843};
2844static struct tgid_iter next_tgid(struct pid_namespace *ns, struct tgid_iter iter)
2845{
2846        struct pid *pid;
2847
2848        if (iter.task)
2849                put_task_struct(iter.task);
2850        rcu_read_lock();
2851retry:
2852        iter.task = NULL;
2853        pid = find_ge_pid(iter.tgid, ns);
2854        if (pid) {
2855                iter.tgid = pid_nr_ns(pid, ns);
2856                iter.task = pid_task(pid, PIDTYPE_PID);
2857                /* What we to know is if the pid we have find is the
2858                 * pid of a thread_group_leader.  Testing for task
2859                 * being a thread_group_leader is the obvious thing
2860                 * todo but there is a window when it fails, due to
2861                 * the pid transfer logic in de_thread.
2862                 *
2863                 * So we perform the straight forward test of seeing
2864                 * if the pid we have found is the pid of a thread
2865                 * group leader, and don't worry if the task we have
2866                 * found doesn't happen to be a thread group leader.
2867                 * As we don't care in the case of readdir.
2868                 */
2869                if (!iter.task || !has_group_leader_pid(iter.task)) {
2870                        iter.tgid += 1;
2871                        goto retry;
2872                }
2873                get_task_struct(iter.task);
2874        }
2875        rcu_read_unlock();
2876        return iter;
2877}
2878
2879#define TGID_OFFSET (FIRST_PROCESS_ENTRY + 1)
2880
2881/* for the /proc/ directory itself, after non-process stuff has been done */
2882int proc_pid_readdir(struct file *file, struct dir_context *ctx)
2883{
2884        struct tgid_iter iter;
2885        struct pid_namespace *ns = file->f_dentry->d_sb->s_fs_info;
2886        loff_t pos = ctx->pos;
2887
2888        if (pos >= PID_MAX_LIMIT + TGID_OFFSET)
2889                return 0;
2890
2891        if (pos == TGID_OFFSET - 1) {
2892                struct inode *inode = ns->proc_self->d_inode;
2893                if (!dir_emit(ctx, "self", 4, inode->i_ino, DT_LNK))
2894                        return 0;
2895                iter.tgid = 0;
2896        } else {
2897                iter.tgid = pos - TGID_OFFSET;
2898        }
2899        iter.task = NULL;
2900        for (iter = next_tgid(ns, iter);
2901             iter.task;
2902             iter.tgid += 1, iter = next_tgid(ns, iter)) {
2903                char name[PROC_NUMBUF];
2904                int len;
2905                if (!has_pid_permissions(ns, iter.task, 2))
2906                        continue;
2907
2908                len = snprintf(name, sizeof(name), "%d", iter.tgid);
2909                ctx->pos = iter.tgid + TGID_OFFSET;
2910                if (!proc_fill_cache(file, ctx, name, len,
2911                                     proc_pid_instantiate, iter.task, NULL)) {
2912                        put_task_struct(iter.task);
2913                        return 0;
2914                }
2915        }
2916        ctx->pos = PID_MAX_LIMIT + TGID_OFFSET;
2917        return 0;
2918}
2919
2920/*
2921 * Tasks
2922 */
2923static const struct pid_entry tid_base_stuff[] = {
2924        DIR("fd",        S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
2925        DIR("fdinfo",    S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
2926        DIR("ns",        S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
2927        REG("environ",   S_IRUSR, proc_environ_operations),
2928        INF("auxv",      S_IRUSR, proc_pid_auxv),
2929        ONE("status",    S_IRUGO, proc_pid_status),
2930        ONE("personality", S_IRUGO, proc_pid_personality),
2931        INF("limits",    S_IRUGO, proc_pid_limits),
2932#ifdef CONFIG_SCHED_DEBUG
2933        REG("sched",     S_IRUGO|S_IWUSR, proc_pid_sched_operations),
2934#endif
2935        REG("comm",      S_IRUGO|S_IWUSR, proc_pid_set_comm_operations),
2936#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
2937        INF("syscall",   S_IRUGO, proc_pid_syscall),
2938#endif
2939        INF("cmdline",   S_IRUGO, proc_pid_cmdline),
2940        ONE("stat",      S_IRUGO, proc_tid_stat),
2941        ONE("statm",     S_IRUGO, proc_pid_statm),
2942        REG("maps",      S_IRUGO, proc_tid_maps_operations),
2943#ifdef CONFIG_CHECKPOINT_RESTORE
2944        REG("children",  S_IRUGO, proc_tid_children_operations),
2945#endif
2946#ifdef CONFIG_NUMA
2947        REG("numa_maps", S_IRUGO, proc_tid_numa_maps_operations),
2948#endif
2949        REG("mem",       S_IRUSR|S_IWUSR, proc_mem_operations),
2950        LNK("cwd",       proc_cwd_link),
2951        LNK("root",      proc_root_link),
2952        LNK("exe",       proc_exe_link),
2953        REG("mounts",    S_IRUGO, proc_mounts_operations),
2954        REG("mountinfo",  S_IRUGO, proc_mountinfo_operations),
2955#ifdef CONFIG_PROC_PAGE_MONITOR
2956        REG("clear_refs", S_IWUSR, proc_clear_refs_operations),
2957        REG("smaps",     S_IRUGO, proc_tid_smaps_operations),
2958        REG("pagemap",    S_IRUGO, proc_pagemap_operations),
2959#endif
2960#ifdef CONFIG_SECURITY
2961        DIR("attr",      S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations),
2962#endif
2963#ifdef CONFIG_KALLSYMS
2964        INF("wchan",     S_IRUGO, proc_pid_wchan),
2965#endif
2966#ifdef CONFIG_STACKTRACE
2967        ONE("stack",      S_IRUGO, proc_pid_stack),
2968#endif
2969#ifdef CONFIG_SCHEDSTATS
2970        INF("schedstat", S_IRUGO, proc_pid_schedstat),
2971#endif
2972#ifdef CONFIG_LATENCYTOP
2973        REG("latency",  S_IRUGO, proc_lstats_operations),
2974#endif
2975#ifdef CONFIG_PROC_PID_CPUSET
2976        REG("cpuset",    S_IRUGO, proc_cpuset_operations),
2977#endif
2978#ifdef CONFIG_CGROUPS
2979        REG("cgroup",  S_IRUGO, proc_cgroup_operations),
2980#endif
2981        INF("oom_score", S_IRUGO, proc_oom_score),
2982        REG("oom_adj",   S_IRUGO|S_IWUSR, proc_oom_adj_operations),
2983        REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
2984#ifdef CONFIG_AUDITSYSCALL
2985        REG("loginuid",  S_IWUSR|S_IRUGO, proc_loginuid_operations),
2986        REG("sessionid",  S_IRUGO, proc_sessionid_operations),
2987#endif
2988#ifdef CONFIG_FAULT_INJECTION
2989        REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),
2990#endif
2991#ifdef CONFIG_TASK_IO_ACCOUNTING
2992        INF("io",       S_IRUSR, proc_tid_io_accounting),
2993#endif
2994#ifdef CONFIG_HARDWALL
2995        INF("hardwall",   S_IRUGO, proc_pid_hardwall),
2996#endif
2997#ifdef CONFIG_USER_NS
2998        REG("uid_map",    S_IRUGO|S_IWUSR, proc_uid_map_operations),
2999        REG("gid_map",    S_IRUGO|S_IWUSR, proc_gid_map_operations),
3000        REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations),
3001#endif
3002};
3003
3004static int proc_tid_base_readdir(struct file *file, struct dir_context *ctx)
3005{
3006        return proc_pident_readdir(file, ctx,
3007                                   tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
3008}
3009
3010static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
3011{
3012        return proc_pident_lookup(dir, dentry,
3013                                  tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
3014}
3015
3016static const struct file_operations proc_tid_base_operations = {
3017        .read           = generic_read_dir,
3018        .iterate        = proc_tid_base_readdir,
3019        .llseek         = default_llseek,
3020};
3021
3022static const struct inode_operations proc_tid_base_inode_operations = {
3023        .lookup         = proc_tid_base_lookup,
3024        .getattr        = pid_getattr,
3025        .setattr        = proc_setattr,
3026};
3027
3028static int proc_task_instantiate(struct inode *dir,
3029        struct dentry *dentry, struct task_struct *task, const void *ptr)
3030{
3031        struct inode *inode;
3032        inode = proc_pid_make_inode(dir->i_sb, task);
3033
3034        if (!inode)
3035                goto out;
3036        inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
3037        inode->i_op = &proc_tid_base_inode_operations;
3038        inode->i_fop = &proc_tid_base_operations;
3039        inode->i_flags|=S_IMMUTABLE;
3040
3041        set_nlink(inode, 2 + pid_entry_count_dirs(tid_base_stuff,
3042                                                  ARRAY_SIZE(tid_base_stuff)));
3043
3044        d_set_d_op(dentry, &pid_dentry_operations);
3045
3046        d_add(dentry, inode);
3047        /* Close the race of the process dying before we return the dentry */
3048        if (pid_revalidate(dentry, 0))
3049                return 0;
3050out:
3051        return -ENOENT;
3052}
3053
3054static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
3055{
3056        int result = -ENOENT;
3057        struct task_struct *task;
3058        struct task_struct *leader = get_proc_task(dir);
3059        unsigned tid;
3060        struct pid_namespace *ns;
3061
3062        if (!leader)
3063                goto out_no_task;
3064
3065        tid = name_to_int(dentry);
3066        if (tid == ~0U)
3067                goto out;
3068
3069        ns = dentry->d_sb->s_fs_info;
3070        rcu_read_lock();
3071        task = find_task_by_pid_ns(tid, ns);
3072        if (task)
3073                get_task_struct(task);
3074        rcu_read_unlock();
3075        if (!task)
3076                goto out;
3077        if (!same_thread_group(leader, task))
3078                goto out_drop_task;
3079
3080        result = proc_task_instantiate(dir, dentry, task, NULL);
3081out_drop_task:
3082        put_task_struct(task);
3083out:
3084        put_task_struct(leader);
3085out_no_task:
3086        return ERR_PTR(result);
3087}
3088
3089/*
3090 * Find the first tid of a thread group to return to user space.
3091 *
3092 * Usually this is just the thread group leader, but if the users
3093 * buffer was too small or there was a seek into the middle of the
3094 * directory we have more work todo.
3095 *
3096 * In the case of a short read we start with find_task_by_pid.
3097 *
3098 * In the case of a seek we start with the leader and walk nr
3099 * threads past it.
3100 */
3101static struct task_struct *first_tid(struct pid *pid, int tid, loff_t f_pos,
3102                                        struct pid_namespace *ns)
3103{
3104        struct task_struct *pos, *task;
3105        unsigned long nr = f_pos;
3106
3107        if (nr != f_pos)        /* 32bit overflow? */
3108                return NULL;
3109
3110        rcu_read_lock();
3111        task = pid_task(pid, PIDTYPE_PID);
3112        if (!task)
3113                goto fail;
3114
3115        /* Attempt to start with the tid of a thread */
3116        if (tid && nr) {
3117                pos = find_task_by_pid_ns(tid, ns);
3118                if (pos && same_thread_group(pos, task))
3119                        goto found;
3120        }
3121
3122        /* If nr exceeds the number of threads there is nothing todo */
3123        if (nr >= get_nr_threads(task))
3124                goto fail;
3125
3126        /* If we haven't found our starting place yet start
3127         * with the leader and walk nr threads forward.
3128         */
3129        pos = task = task->group_leader;
3130        do {
3131                if (!nr--)
3132                        goto found;
3133        } while_each_thread(task, pos);
3134fail:
3135        pos = NULL;
3136        goto out;
3137found:
3138        get_task_struct(pos);
3139out:
3140        rcu_read_unlock();
3141        return pos;
3142}
3143
3144/*
3145 * Find the next thread in the thread list.
3146 * Return NULL if there is an error or no next thread.
3147 *
3148 * The reference to the input task_struct is released.
3149 */
3150static struct task_struct *next_tid(struct task_struct *start)
3151{
3152        struct task_struct *pos = NULL;
3153        rcu_read_lock();
3154        if (pid_alive(start)) {
3155                pos = next_thread(start);
3156                if (thread_group_leader(pos))
3157                        pos = NULL;
3158                else
3159                        get_task_struct(pos);
3160        }
3161        rcu_read_unlock();
3162        put_task_struct(start);
3163        return pos;
3164}
3165
3166/* for the /proc/TGID/task/ directories */
3167static int proc_task_readdir(struct file *file, struct dir_context *ctx)
3168{
3169        struct inode *inode = file_inode(file);
3170        struct task_struct *task;
3171        struct pid_namespace *ns;
3172        int tid;
3173
3174        if (proc_inode_is_dead(inode))
3175                return -ENOENT;
3176
3177        if (!dir_emit_dots(file, ctx))
3178                return 0;
3179
3180        /* f_version caches the tgid value that the last readdir call couldn't
3181         * return. lseek aka telldir automagically resets f_version to 0.
3182         */
3183        ns = file->f_dentry->d_sb->s_fs_info;
3184        tid = (int)file->f_version;
3185        file->f_version = 0;
3186        for (task = first_tid(proc_pid(inode), tid, ctx->pos - 2, ns);
3187             task;
3188             task = next_tid(task), ctx->pos++) {
3189                char name[PROC_NUMBUF];
3190                int len;
3191                tid = task_pid_nr_ns(task, ns);
3192                len = snprintf(name, sizeof(name), "%d", tid);
3193                if (!proc_fill_cache(file, ctx, name, len,
3194                                proc_task_instantiate, task, NULL)) {
3195                        /* returning this tgid failed, save it as the first
3196                         * pid for the next readir call */
3197                        file->f_version = (u64)tid;
3198                        put_task_struct(task);
3199                        break;
3200                }
3201        }
3202
3203        return 0;
3204}
3205
3206static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
3207{
3208        struct inode *inode = dentry->d_inode;
3209        struct task_struct *p = get_proc_task(inode);
3210        generic_fillattr(inode, stat);
3211
3212        if (p) {
3213                stat->nlink += get_nr_threads(p);
3214                put_task_struct(p);
3215        }
3216
3217        return 0;
3218}
3219
3220static const struct inode_operations proc_task_inode_operations = {
3221        .lookup         = proc_task_lookup,
3222        .getattr        = proc_task_getattr,
3223        .setattr        = proc_setattr,
3224        .permission     = proc_pid_permission,
3225};
3226
3227static const struct file_operations proc_task_operations = {
3228        .read           = generic_read_dir,
3229        .iterate        = proc_task_readdir,
3230        .llseek         = default_llseek,
3231};
3232
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.