SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/proc/base.c

   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/config.h>
  53 #include <linux/errno.h>
  54 #include <linux/time.h>
  55 #include <linux/proc_fs.h>
  56 #include <linux/stat.h>
  57 #include <linux/init.h>
  58 #include <linux/file.h>
  59 #include <linux/string.h>
  60 #include <linux/seq_file.h>
  61 #include <linux/namei.h>
  62 #include <linux/namespace.h>
  63 #include <linux/mm.h>
  64 #include <linux/smp_lock.h>
  65 #include <linux/rcupdate.h>
  66 #include <linux/kallsyms.h>
  67 #include <linux/mount.h>
  68 #include <linux/security.h>
  69 #include <linux/ptrace.h>
  70 #include <linux/seccomp.h>
  71 #include <linux/cpuset.h>
  72 #include <linux/audit.h>
  73 #include <linux/poll.h>
  74 #include "internal.h"
  75
  76 /*
  77  * For hysterical raisins we keep the same inumbers as in the old procfs.
  78  * Feel free to change the macro below - just keep the range distinct from
  79  * inumbers of the rest of procfs (currently those are in 0x0000--0xffff).
  80  * As soon as we'll get a separate superblock we will be able to forget
  81  * about magical ranges too.
  82  */
  83
  84 #define fake_ino(pid,ino) (((pid)<<16)|(ino))
  85
  86 enum pid_directory_inos {
  87         PROC_TGID_INO = 2,
  88         PROC_TGID_TASK,
  89         PROC_TGID_STATUS,
  90         PROC_TGID_MEM,
  91 #ifdef CONFIG_SECCOMP
  92         PROC_TGID_SECCOMP,
  93 #endif
  94         PROC_TGID_CWD,
  95         PROC_TGID_ROOT,
  96         PROC_TGID_EXE,
  97         PROC_TGID_FD,
  98         PROC_TGID_ENVIRON,
  99         PROC_TGID_AUXV,
 100         PROC_TGID_CMDLINE,
 101         PROC_TGID_STAT,
 102         PROC_TGID_STATM,
 103         PROC_TGID_MAPS,
 104         PROC_TGID_NUMA_MAPS,
 105         PROC_TGID_MOUNTS,
 106         PROC_TGID_WCHAN,
 107 #ifdef CONFIG_MMU
 108         PROC_TGID_SMAPS,
 109 #endif
 110 #ifdef CONFIG_SCHEDSTATS
 111         PROC_TGID_SCHEDSTAT,
 112 #endif
 113 #ifdef CONFIG_CPUSETS
 114         PROC_TGID_CPUSET,
 115 #endif
 116 #ifdef CONFIG_SECURITY
 117         PROC_TGID_ATTR,
 118         PROC_TGID_ATTR_CURRENT,
 119         PROC_TGID_ATTR_PREV,
 120         PROC_TGID_ATTR_EXEC,
 121         PROC_TGID_ATTR_FSCREATE,
 122 #endif
 123 #ifdef CONFIG_AUDITSYSCALL
 124         PROC_TGID_LOGINUID,
 125 #endif
 126         PROC_TGID_OOM_SCORE,
 127         PROC_TGID_OOM_ADJUST,
 128         PROC_TID_INO,
 129         PROC_TID_STATUS,
 130         PROC_TID_MEM,
 131 #ifdef CONFIG_SECCOMP
 132         PROC_TID_SECCOMP,
 133 #endif
 134         PROC_TID_CWD,
 135         PROC_TID_ROOT,
 136         PROC_TID_EXE,
 137         PROC_TID_FD,
 138         PROC_TID_ENVIRON,
 139         PROC_TID_AUXV,
 140         PROC_TID_CMDLINE,
 141         PROC_TID_STAT,
 142         PROC_TID_STATM,
 143         PROC_TID_MAPS,
 144         PROC_TID_NUMA_MAPS,
 145         PROC_TID_MOUNTS,
 146         PROC_TID_WCHAN,
 147 #ifdef CONFIG_MMU
 148         PROC_TID_SMAPS,
 149 #endif
 150 #ifdef CONFIG_SCHEDSTATS
 151         PROC_TID_SCHEDSTAT,
 152 #endif
 153 #ifdef CONFIG_CPUSETS
 154         PROC_TID_CPUSET,
 155 #endif
 156 #ifdef CONFIG_SECURITY
 157         PROC_TID_ATTR,
 158         PROC_TID_ATTR_CURRENT,
 159         PROC_TID_ATTR_PREV,
 160         PROC_TID_ATTR_EXEC,
 161         PROC_TID_ATTR_FSCREATE,
 162 #endif
 163 #ifdef CONFIG_AUDITSYSCALL
 164         PROC_TID_LOGINUID,
 165 #endif
 166         PROC_TID_OOM_SCORE,
 167         PROC_TID_OOM_ADJUST,
 168
 169         /* Add new entries before this */
 170         PROC_TID_FD_DIR = 0x8000,       /* 0x8000-0xffff */
 171 };
 172
 173 struct pid_entry {
 174         int type;
 175         int len;
 176         char *name;
 177         mode_t mode;
 178 };
 179
 180 #define E(type,name,mode) {(type),sizeof(name)-1,(name),(mode)}
 181
 182 static struct pid_entry tgid_base_stuff[] = {
 183         E(PROC_TGID_TASK,      "task",    S_IFDIR|S_IRUGO|S_IXUGO),
 184         E(PROC_TGID_FD,        "fd",      S_IFDIR|S_IRUSR|S_IXUSR),
 185         E(PROC_TGID_ENVIRON,   "environ", S_IFREG|S_IRUSR),
 186         E(PROC_TGID_AUXV,      "auxv",    S_IFREG|S_IRUSR),
 187         E(PROC_TGID_STATUS,    "status",  S_IFREG|S_IRUGO),
 188         E(PROC_TGID_CMDLINE,   "cmdline", S_IFREG|S_IRUGO),
 189         E(PROC_TGID_STAT,      "stat",    S_IFREG|S_IRUGO),
 190         E(PROC_TGID_STATM,     "statm",   S_IFREG|S_IRUGO),
 191         E(PROC_TGID_MAPS,      "maps",    S_IFREG|S_IRUGO),
 192 #ifdef CONFIG_NUMA
 193         E(PROC_TGID_NUMA_MAPS, "numa_maps", S_IFREG|S_IRUGO),
 194 #endif
 195         E(PROC_TGID_MEM,       "mem",     S_IFREG|S_IRUSR|S_IWUSR),
 196 #ifdef CONFIG_SECCOMP
 197         E(PROC_TGID_SECCOMP,   "seccomp", S_IFREG|S_IRUSR|S_IWUSR),
 198 #endif
 199         E(PROC_TGID_CWD,       "cwd",     S_IFLNK|S_IRWXUGO),
 200         E(PROC_TGID_ROOT,      "root",    S_IFLNK|S_IRWXUGO),
 201         E(PROC_TGID_EXE,       "exe",     S_IFLNK|S_IRWXUGO),
 202         E(PROC_TGID_MOUNTS,    "mounts",  S_IFREG|S_IRUGO),
 203 #ifdef CONFIG_MMU
 204         E(PROC_TGID_SMAPS,     "smaps",   S_IFREG|S_IRUGO),
 205 #endif
 206 #ifdef CONFIG_SECURITY
 207         E(PROC_TGID_ATTR,      "attr",    S_IFDIR|S_IRUGO|S_IXUGO),
 208 #endif
 209 #ifdef CONFIG_KALLSYMS
 210         E(PROC_TGID_WCHAN,     "wchan",   S_IFREG|S_IRUGO),
 211 #endif
 212 #ifdef CONFIG_SCHEDSTATS
 213         E(PROC_TGID_SCHEDSTAT, "schedstat", S_IFREG|S_IRUGO),
 214 #endif
 215 #ifdef CONFIG_CPUSETS
 216         E(PROC_TGID_CPUSET,    "cpuset",  S_IFREG|S_IRUGO),
 217 #endif
 218         E(PROC_TGID_OOM_SCORE, "oom_score",S_IFREG|S_IRUGO),
 219         E(PROC_TGID_OOM_ADJUST,"oom_adj", S_IFREG|S_IRUGO|S_IWUSR),
 220 #ifdef CONFIG_AUDITSYSCALL
 221         E(PROC_TGID_LOGINUID, "loginuid", S_IFREG|S_IWUSR|S_IRUGO),
 222 #endif
 223         {0,0,NULL,0}
 224 };
 225 static struct pid_entry tid_base_stuff[] = {
 226         E(PROC_TID_FD,         "fd",      S_IFDIR|S_IRUSR|S_IXUSR),
 227         E(PROC_TID_ENVIRON,    "environ", S_IFREG|S_IRUSR),
 228         E(PROC_TID_AUXV,       "auxv",    S_IFREG|S_IRUSR),
 229         E(PROC_TID_STATUS,     "status",  S_IFREG|S_IRUGO),
 230         E(PROC_TID_CMDLINE,    "cmdline", S_IFREG|S_IRUGO),
 231         E(PROC_TID_STAT,       "stat",    S_IFREG|S_IRUGO),
 232         E(PROC_TID_STATM,      "statm",   S_IFREG|S_IRUGO),
 233         E(PROC_TID_MAPS,       "maps",    S_IFREG|S_IRUGO),
 234 #ifdef CONFIG_NUMA
 235         E(PROC_TID_NUMA_MAPS,  "numa_maps",    S_IFREG|S_IRUGO),
 236 #endif
 237         E(PROC_TID_MEM,        "mem",     S_IFREG|S_IRUSR|S_IWUSR),
 238 #ifdef CONFIG_SECCOMP
 239         E(PROC_TID_SECCOMP,    "seccomp", S_IFREG|S_IRUSR|S_IWUSR),
 240 #endif
 241         E(PROC_TID_CWD,        "cwd",     S_IFLNK|S_IRWXUGO),
 242         E(PROC_TID_ROOT,       "root",    S_IFLNK|S_IRWXUGO),
 243         E(PROC_TID_EXE,        "exe",     S_IFLNK|S_IRWXUGO),
 244         E(PROC_TID_MOUNTS,     "mounts",  S_IFREG|S_IRUGO),
 245 #ifdef CONFIG_MMU
 246         E(PROC_TID_SMAPS,      "smaps",   S_IFREG|S_IRUGO),
 247 #endif
 248 #ifdef CONFIG_SECURITY
 249         E(PROC_TID_ATTR,       "attr",    S_IFDIR|S_IRUGO|S_IXUGO),
 250 #endif
 251 #ifdef CONFIG_KALLSYMS
 252         E(PROC_TID_WCHAN,      "wchan",   S_IFREG|S_IRUGO),
 253 #endif
 254 #ifdef CONFIG_SCHEDSTATS
 255         E(PROC_TID_SCHEDSTAT, "schedstat",S_IFREG|S_IRUGO),
 256 #endif
 257 #ifdef CONFIG_CPUSETS
 258         E(PROC_TID_CPUSET,     "cpuset",  S_IFREG|S_IRUGO),
 259 #endif
 260         E(PROC_TID_OOM_SCORE,  "oom_score",S_IFREG|S_IRUGO),
 261         E(PROC_TID_OOM_ADJUST, "oom_adj", S_IFREG|S_IRUGO|S_IWUSR),
 262 #ifdef CONFIG_AUDITSYSCALL
 263         E(PROC_TID_LOGINUID, "loginuid", S_IFREG|S_IWUSR|S_IRUGO),
 264 #endif
 265         {0,0,NULL,0}
 266 };
 267
 268 #ifdef CONFIG_SECURITY
 269 static struct pid_entry tgid_attr_stuff[] = {
 270         E(PROC_TGID_ATTR_CURRENT,  "current",  S_IFREG|S_IRUGO|S_IWUGO),
 271         E(PROC_TGID_ATTR_PREV,     "prev",     S_IFREG|S_IRUGO),
 272         E(PROC_TGID_ATTR_EXEC,     "exec",     S_IFREG|S_IRUGO|S_IWUGO),
 273         E(PROC_TGID_ATTR_FSCREATE, "fscreate", S_IFREG|S_IRUGO|S_IWUGO),
 274         {0,0,NULL,0}
 275 };
 276 static struct pid_entry tid_attr_stuff[] = {
 277         E(PROC_TID_ATTR_CURRENT,   "current",  S_IFREG|S_IRUGO|S_IWUGO),
 278         E(PROC_TID_ATTR_PREV,      "prev",     S_IFREG|S_IRUGO),
 279         E(PROC_TID_ATTR_EXEC,      "exec",     S_IFREG|S_IRUGO|S_IWUGO),
 280         E(PROC_TID_ATTR_FSCREATE,  "fscreate", S_IFREG|S_IRUGO|S_IWUGO),
 281         {0,0,NULL,0}
 282 };
 283 #endif
 284
 285 #undef E
 286
 287 static int proc_fd_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
 288 {
 289         struct task_struct *task = proc_task(inode);
 290         struct files_struct *files;
 291         struct file *file;
 292         int fd = proc_type(inode) - PROC_TID_FD_DIR;
 293
 294         files = get_files_struct(task);
 295         if (files) {
 296                 rcu_read_lock();
 297                 file = fcheck_files(files, fd);
 298                 if (file) {
 299                         *mnt = mntget(file->f_vfsmnt);
 300                         *dentry = dget(file->f_dentry);
 301                         rcu_read_unlock();
 302                         put_files_struct(files);
 303                         return 0;
 304                 }
 305                 rcu_read_unlock();
 306                 put_files_struct(files);
 307         }
 308         return -ENOENT;
 309 }
 310
 311 static struct fs_struct *get_fs_struct(struct task_struct *task)
 312 {
 313         struct fs_struct *fs;
 314         task_lock(task);
 315         fs = task->fs;
 316         if(fs)
 317                 atomic_inc(&fs->count);
 318         task_unlock(task);
 319         return fs;
 320 }
 321
 322 static int proc_cwd_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
 323 {
 324         struct fs_struct *fs = get_fs_struct(proc_task(inode));
 325         int result = -ENOENT;
 326         if (fs) {
 327                 read_lock(&fs->lock);
 328                 *mnt = mntget(fs->pwdmnt);
 329                 *dentry = dget(fs->pwd);
 330                 read_unlock(&fs->lock);
 331                 result = 0;
 332                 put_fs_struct(fs);
 333         }
 334         return result;
 335 }
 336
 337 static int proc_root_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
 338 {
 339         struct fs_struct *fs = get_fs_struct(proc_task(inode));
 340         int result = -ENOENT;
 341         if (fs) {
 342                 read_lock(&fs->lock);
 343                 *mnt = mntget(fs->rootmnt);
 344                 *dentry = dget(fs->root);
 345                 read_unlock(&fs->lock);
 346                 result = 0;
 347                 put_fs_struct(fs);
 348         }
 349         return result;
 350 }
 351
 352
 353 /* Same as proc_root_link, but this addionally tries to get fs from other
 354  * threads in the group */
 355 static int proc_task_root_link(struct inode *inode, struct dentry **dentry,
 356                                 struct vfsmount **mnt)
 357 {
 358         struct fs_struct *fs;
 359         int result = -ENOENT;
 360         struct task_struct *leader = proc_task(inode);
 361
 362         task_lock(leader);
 363         fs = leader->fs;
 364         if (fs) {
 365                 atomic_inc(&fs->count);
 366                 task_unlock(leader);
 367         } else {
 368                 /* Try to get fs from other threads */
 369                 task_unlock(leader);
 370                 read_lock(&tasklist_lock);
 371                 if (pid_alive(leader)) {
 372                         struct task_struct *task = leader;
 373
 374                         while ((task = next_thread(task)) != leader) {
 375                                 task_lock(task);
 376                                 fs = task->fs;
 377                                 if (fs) {
 378                                         atomic_inc(&fs->count);
 379                                         task_unlock(task);
 380                                         break;
 381                                 }
 382                                 task_unlock(task);
 383                         }
 384                 }
 385                 read_unlock(&tasklist_lock);
 386         }
 387
 388         if (fs) {
 389                 read_lock(&fs->lock);
 390                 *mnt = mntget(fs->rootmnt);
 391                 *dentry = dget(fs->root);
 392                 read_unlock(&fs->lock);
 393                 result = 0;
 394                 put_fs_struct(fs);
 395         }
 396         return result;
 397 }
 398
 399
 400 #define MAY_PTRACE(task) \
 401         (task == current || \
 402         (task->parent == current && \
 403         (task->ptrace & PT_PTRACED) && \
 404          (task->state == TASK_STOPPED || task->state == TASK_TRACED) && \
 405          security_ptrace(current,task) == 0))
 406
 407 static int proc_pid_environ(struct task_struct *task, char * buffer)
 408 {
 409         int res = 0;
 410         struct mm_struct *mm = get_task_mm(task);
 411         if (mm) {
 412                 unsigned int len = mm->env_end - mm->env_start;
 413                 if (len > PAGE_SIZE)
 414                         len = PAGE_SIZE;
 415                 res = access_process_vm(task, mm->env_start, buffer, len, 0);
 416                 if (!ptrace_may_attach(task))
 417                         res = -ESRCH;
 418                 mmput(mm);
 419         }
 420         return res;
 421 }
 422
 423 static int proc_pid_cmdline(struct task_struct *task, char * buffer)
 424 {
 425         int res = 0;
 426         unsigned int len;
 427         struct mm_struct *mm = get_task_mm(task);
 428         if (!mm)
 429                 goto out;
 430         if (!mm->arg_end)
 431                 goto out_mm;    /* Shh! No looking before we're done */
 432
 433         len = mm->arg_end - mm->arg_start;
 434
 435         if (len > PAGE_SIZE)
 436                 len = PAGE_SIZE;
 437
 438         res = access_process_vm(task, mm->arg_start, buffer, len, 0);
 439
 440         // If the nul at the end of args has been overwritten, then
 441         // assume application is using setproctitle(3).
 442         if (res > 0 && buffer[res-1] != '\0' && len < PAGE_SIZE) {
 443                 len = strnlen(buffer, res);
 444                 if (len < res) {
 445                     res = len;
 446                 } else {
 447                         len = mm->env_end - mm->env_start;
 448                         if (len > PAGE_SIZE - res)
 449                                 len = PAGE_SIZE - res;
 450                         res += access_process_vm(task, mm->env_start, buffer+res, len, 0);
 451                         res = strnlen(buffer, res);
 452                 }
 453         }
 454 out_mm:
 455         mmput(mm);
 456 out:
 457         return res;
 458 }
 459
 460 static int proc_pid_auxv(struct task_struct *task, char *buffer)
 461 {
 462         int res = 0;
 463         struct mm_struct *mm = get_task_mm(task);
 464         if (mm) {
 465                 unsigned int nwords = 0;
 466                 do
 467                         nwords += 2;
 468                 while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */
 469                 res = nwords * sizeof(mm->saved_auxv[0]);
 470                 if (res > PAGE_SIZE)
 471                         res = PAGE_SIZE;
 472                 memcpy(buffer, mm->saved_auxv, res);
 473                 mmput(mm);
 474         }
 475         return res;
 476 }
 477
 478
 479 #ifdef CONFIG_KALLSYMS
 480 /*
 481  * Provides a wchan file via kallsyms in a proper one-value-per-file format.
 482  * Returns the resolved symbol.  If that fails, simply return the address.
 483  */
 484 static int proc_pid_wchan(struct task_struct *task, char *buffer)
 485 {
 486         char *modname;
 487         const char *sym_name;
 488         unsigned long wchan, size, offset;
 489         char namebuf[KSYM_NAME_LEN+1];
 490
 491         wchan = get_wchan(task);
 492
 493         sym_name = kallsyms_lookup(wchan, &size, &offset, &modname, namebuf);
 494         if (sym_name)
 495                 return sprintf(buffer, "%s", sym_name);
 496         return sprintf(buffer, "%lu", wchan);
 497 }
 498 #endif /* CONFIG_KALLSYMS */
 499
 500 #ifdef CONFIG_SCHEDSTATS
 501 /*
 502  * Provides /proc/PID/schedstat
 503  */
 504 static int proc_pid_schedstat(struct task_struct *task, char *buffer)
 505 {
 506         return sprintf(buffer, "%lu %lu %lu\n",
 507                         task->sched_info.cpu_time,
 508                         task->sched_info.run_delay,
 509                         task->sched_info.pcnt);
 510 }
 511 #endif
 512
 513 /* The badness from the OOM killer */
 514 unsigned long badness(struct task_struct *p, unsigned long uptime);
 515 static int proc_oom_score(struct task_struct *task, char *buffer)
 516 {
 517         unsigned long points;
 518         struct timespec uptime;
 519
 520         do_posix_clock_monotonic_gettime(&uptime);
 521         points = badness(task, uptime.tv_sec);
 522         return sprintf(buffer, "%lu\n", points);
 523 }
 524
 525 /************************************************************************/
 526 /*                       Here the fs part begins                        */
 527 /************************************************************************/
 528
 529 /* permission checks */
 530
 531 /* If the process being read is separated by chroot from the reading process,
 532  * don't let the reader access the threads.
 533  */
 534 static int proc_check_chroot(struct dentry *root, struct vfsmount *vfsmnt)
 535 {
 536         struct dentry *de, *base;
 537         struct vfsmount *our_vfsmnt, *mnt;
 538         int res = 0;
 539         read_lock(&current->fs->lock);
 540         our_vfsmnt = mntget(current->fs->rootmnt);
 541         base = dget(current->fs->root);
 542         read_unlock(&current->fs->lock);
 543
 544         spin_lock(&vfsmount_lock);
 545         de = root;
 546         mnt = vfsmnt;
 547
 548         while (vfsmnt != our_vfsmnt) {
 549                 if (vfsmnt == vfsmnt->mnt_parent)
 550                         goto out;
 551                 de = vfsmnt->mnt_mountpoint;
 552                 vfsmnt = vfsmnt->mnt_parent;
 553         }
 554
 555         if (!is_subdir(de, base))
 556                 goto out;
 557         spin_unlock(&vfsmount_lock);
 558
 559 exit:
 560         dput(base);
 561         mntput(our_vfsmnt);
 562         dput(root);
 563         mntput(mnt);
 564         return res;
 565 out:
 566         spin_unlock(&vfsmount_lock);
 567         res = -EACCES;
 568         goto exit;
 569 }
 570
 571 static int proc_check_root(struct inode *inode)
 572 {
 573         struct dentry *root;
 574         struct vfsmount *vfsmnt;
 575
 576         if (proc_root_link(inode, &root, &vfsmnt)) /* Ewww... */
 577                 return -ENOENT;
 578         return proc_check_chroot(root, vfsmnt);
 579 }
 580
 581 static int proc_permission(struct inode *inode, int mask, struct nameidata *nd)
 582 {
 583         if (generic_permission(inode, mask, NULL) != 0)
 584                 return -EACCES;
 585         return proc_check_root(inode);
 586 }
 587
 588 static int proc_task_permission(struct inode *inode, int mask, struct nameidata *nd)
 589 {
 590         struct dentry *root;
 591         struct vfsmount *vfsmnt;
 592
 593         if (generic_permission(inode, mask, NULL) != 0)
 594                 return -EACCES;
 595
 596         if (proc_task_root_link(inode, &root, &vfsmnt))
 597                 return -ENOENT;
 598
 599         return proc_check_chroot(root, vfsmnt);
 600 }
 601
 602 extern struct seq_operations proc_pid_maps_op;
 603 static int maps_open(struct inode *inode, struct file *file)
 604 {
 605         struct task_struct *task = proc_task(inode);
 606         int ret = seq_open(file, &proc_pid_maps_op);
 607         if (!ret) {
 608                 struct seq_file *m = file->private_data;
 609                 m->private = task;
 610         }
 611         return ret;
 612 }
 613
 614 static struct file_operations proc_maps_operations = {
 615         .open           = maps_open,
 616         .read           = seq_read,
 617         .llseek         = seq_lseek,
 618         .release        = seq_release,
 619 };
 620
 621 #ifdef CONFIG_NUMA
 622 extern struct seq_operations proc_pid_numa_maps_op;
 623 static int numa_maps_open(struct inode *inode, struct file *file)
 624 {
 625         struct task_struct *task = proc_task(inode);
 626         int ret = seq_open(file, &proc_pid_numa_maps_op);
 627         if (!ret) {
 628                 struct seq_file *m = file->private_data;
 629                 m->private = task;
 630         }
 631         return ret;
 632 }
 633
 634 static struct file_operations proc_numa_maps_operations = {
 635         .open           = numa_maps_open,
 636         .read           = seq_read,
 637         .llseek         = seq_lseek,
 638         .release        = seq_release,
 639 };
 640 #endif
 641
 642 #ifdef CONFIG_MMU
 643 extern struct seq_operations proc_pid_smaps_op;
 644 static int smaps_open(struct inode *inode, struct file *file)
 645 {
 646         struct task_struct *task = proc_task(inode);
 647         int ret = seq_open(file, &proc_pid_smaps_op);
 648         if (!ret) {
 649                 struct seq_file *m = file->private_data;
 650                 m->private = task;
 651         }
 652         return ret;
 653 }
 654
 655 static struct file_operations proc_smaps_operations = {
 656         .open           = smaps_open,
 657         .read           = seq_read,
 658         .llseek         = seq_lseek,
 659         .release        = seq_release,
 660 };
 661 #endif
 662
 663 extern struct seq_operations mounts_op;
 664 struct proc_mounts {
 665         struct seq_file m;
 666         int event;
 667 };
 668
 669 static int mounts_open(struct inode *inode, struct file *file)
 670 {
 671         struct task_struct *task = proc_task(inode);
 672         struct namespace *namespace;
 673         struct proc_mounts *p;
 674         int ret = -EINVAL;
 675
 676         task_lock(task);
 677         namespace = task->namespace;
 678         if (namespace)
 679                 get_namespace(namespace);
 680         task_unlock(task);
 681
 682         if (namespace) {
 683                 ret = -ENOMEM;
 684                 p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL);
 685                 if (p) {
 686                         file->private_data = &p->m;
 687                         ret = seq_open(file, &mounts_op);
 688                         if (!ret) {
 689                                 p->m.private = namespace;
 690                                 p->event = namespace->event;
 691                                 return 0;
 692                         }
 693                         kfree(p);
 694                 }
 695                 put_namespace(namespace);
 696         }
 697         return ret;
 698 }
 699
 700 static int mounts_release(struct inode *inode, struct file *file)
 701 {
 702         struct seq_file *m = file->private_data;
 703         struct namespace *namespace = m->private;
 704         put_namespace(namespace);
 705         return seq_release(inode, file);
 706 }
 707
 708 static unsigned mounts_poll(struct file *file, poll_table *wait)
 709 {
 710         struct proc_mounts *p = file->private_data;
 711         struct namespace *ns = p->m.private;
 712         unsigned res = 0;
 713
 714         poll_wait(file, &ns->poll, wait);
 715
 716         spin_lock(&vfsmount_lock);
 717         if (p->event != ns->event) {
 718                 p->event = ns->event;
 719                 res = POLLERR;
 720         }
 721         spin_unlock(&vfsmount_lock);
 722
 723         return res;
 724 }
 725
 726 static struct file_operations proc_mounts_operations = {
 727         .open           = mounts_open,
 728         .read           = seq_read,
 729         .llseek         = seq_lseek,
 730         .release        = mounts_release,
 731         .poll           = mounts_poll,
 732 };
 733
 734 #define PROC_BLOCK_SIZE (3*1024)                /* 4K page size but our output routines use some slack for overruns */
 735
 736 static ssize_t proc_info_read(struct file * file, char __user * buf,
 737                           size_t count, loff_t *ppos)
 738 {
 739         struct inode * inode = file->f_dentry->d_inode;
 740         unsigned long page;
 741         ssize_t length;
 742         struct task_struct *task = proc_task(inode);
 743
 744         if (count > PROC_BLOCK_SIZE)
 745                 count = PROC_BLOCK_SIZE;
 746         if (!(page = __get_free_page(GFP_KERNEL)))
 747                 return -ENOMEM;
 748
 749         length = PROC_I(inode)->op.proc_read(task, (char*)page);
 750
 751         if (length >= 0)
 752                 length = simple_read_from_buffer(buf, count, ppos, (char *)page, length);
 753         free_page(page);
 754         return length;
 755 }
 756
 757 static struct file_operations proc_info_file_operations = {
 758         .read           = proc_info_read,
 759 };
 760
 761 static int mem_open(struct inode* inode, struct file* file)
 762 {
 763         file->private_data = (void*)((long)current->self_exec_id);
 764         return 0;
 765 }
 766
 767 static ssize_t mem_read(struct file * file, char __user * buf,
 768                         size_t count, loff_t *ppos)
 769 {
 770         struct task_struct *task = proc_task(file->f_dentry->d_inode);
 771         char *page;
 772         unsigned long src = *ppos;
 773         int ret = -ESRCH;
 774         struct mm_struct *mm;
 775
 776         if (!MAY_PTRACE(task) || !ptrace_may_attach(task))
 777                 goto out;
 778
 779         ret = -ENOMEM;
 780         page = (char *)__get_free_page(GFP_USER);
 781         if (!page)
 782                 goto out;
 783
 784         ret = 0;
 785
 786         mm = get_task_mm(task);
 787         if (!mm)
 788                 goto out_free;
 789
 790         ret = -EIO;
 791
 792         if (file->private_data != (void*)((long)current->self_exec_id))
 793                 goto out_put;
 794
 795         ret = 0;
 796
 797         while (count > 0) {
 798                 int this_len, retval;
 799
 800                 this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
 801                 retval = access_process_vm(task, src, page, this_len, 0);
 802                 if (!retval || !MAY_PTRACE(task) || !ptrace_may_attach(task)) {
 803                         if (!ret)
 804                                 ret = -EIO;
 805                         break;
 806                 }
 807
 808                 if (copy_to_user(buf, page, retval)) {
 809                         ret = -EFAULT;
 810                         break;
 811                 }
 812
 813                 ret += retval;
 814                 src += retval;
 815                 buf += retval;
 816                 count -= retval;
 817         }
 818         *ppos = src;
 819
 820 out_put:
 821         mmput(mm);
 822 out_free:
 823         free_page((unsigned long) page);
 824 out:
 825         return ret;
 826 }
 827
 828 #define mem_write NULL
 829
 830 #ifndef mem_write
 831 /* This is a security hazard */
 832 static ssize_t mem_write(struct file * file, const char * buf,
 833                          size_t count, loff_t *ppos)
 834 {
 835         int copied = 0;
 836         char *page;
 837         struct task_struct *task = proc_task(file->f_dentry->d_inode);
 838         unsigned long dst = *ppos;
 839
 840         if (!MAY_PTRACE(task) || !ptrace_may_attach(task))
 841                 return -ESRCH;
 842
 843         page = (char *)__get_free_page(GFP_USER);
 844         if (!page)
 845                 return -ENOMEM;
 846
 847         while (count > 0) {
 848                 int this_len, retval;
 849
 850                 this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
 851                 if (copy_from_user(page, buf, this_len)) {
 852                         copied = -EFAULT;
 853                         break;
 854                 }
 855                 retval = access_process_vm(task, dst, page, this_len, 1);
 856                 if (!retval) {
 857                         if (!copied)
 858                                 copied = -EIO;
 859                         break;
 860                 }
 861                 copied += retval;
 862                 buf += retval;
 863                 dst += retval;
 864                 count -= retval;
 865         }
 866         *ppos = dst;
 867         free_page((unsigned long) page);
 868         return copied;
 869 }
 870 #endif
 871
 872 static loff_t mem_lseek(struct file * file, loff_t offset, int orig)
 873 {
 874         switch (orig) {
 875         case 0:
 876                 file->f_pos = offset;
 877                 break;
 878         case 1:
 879                 file->f_pos += offset;
 880                 break;
 881         default:
 882                 return -EINVAL;
 883         }
 884         force_successful_syscall_return();
 885         return file->f_pos;
 886 }
 887
 888 static struct file_operations proc_mem_operations = {
 889         .llseek         = mem_lseek,
 890         .read           = mem_read,
 891         .write          = mem_write,
 892         .open           = mem_open,
 893 };
 894
 895 static ssize_t oom_adjust_read(struct file *file, char __user *buf,
 896                                 size_t count, loff_t *ppos)
 897 {
 898         struct task_struct *task = proc_task(file->f_dentry->d_inode);
 899         char buffer[8];
 900         size_t len;
 901         int oom_adjust = task->oomkilladj;
 902         loff_t __ppos = *ppos;
 903
 904         len = sprintf(buffer, "%i\n", oom_adjust);
 905         if (__ppos >= len)
 906                 return 0;
 907         if (count > len-__ppos)
 908                 count = len-__ppos;
 909         if (copy_to_user(buf, buffer + __ppos, count))
 910                 return -EFAULT;
 911         *ppos = __ppos + count;
 912         return count;
 913 }
 914
 915 static ssize_t oom_adjust_write(struct file *file, const char __user *buf,
 916                                 size_t count, loff_t *ppos)
 917 {
 918         struct task_struct *task = proc_task(file->f_dentry->d_inode);
 919         char buffer[8], *end;
 920         int oom_adjust;
 921
 922         if (!capable(CAP_SYS_RESOURCE))
 923                 return -EPERM;
 924         memset(buffer, 0, 8);
 925         if (count > 6)
 926                 count = 6;
 927         if (copy_from_user(buffer, buf, count))
 928                 return -EFAULT;
 929         oom_adjust = simple_strtol(buffer, &end, 0);
 930         if ((oom_adjust < -16 || oom_adjust > 15) && oom_adjust != OOM_DISABLE)
 931                 return -EINVAL;
 932         if (*end == '\n')
 933                 end++;
 934         task->oomkilladj = oom_adjust;
 935         if (end - buffer == 0)
 936                 return -EIO;
 937         return end - buffer;
 938 }
 939
 940 static struct file_operations proc_oom_adjust_operations = {
 941         .read           = oom_adjust_read,
 942         .write          = oom_adjust_write,
 943 };
 944
 945 static struct inode_operations proc_mem_inode_operations = {
 946         .permission     = proc_permission,
 947 };
 948
 949 #ifdef CONFIG_AUDITSYSCALL
 950 #define TMPBUFLEN 21
 951 static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
 952                                   size_t count, loff_t *ppos)
 953 {
 954         struct inode * inode = file->f_dentry->d_inode;
 955         struct task_struct *task = proc_task(inode);
 956         ssize_t length;
 957         char tmpbuf[TMPBUFLEN];
 958
 959         length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
 960                                 audit_get_loginuid(task->audit_context));
 961         return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
 962 }
 963
 964 static ssize_t proc_loginuid_write(struct file * file, const char __user * buf,
 965                                    size_t count, loff_t *ppos)
 966 {
 967         struct inode * inode = file->f_dentry->d_inode;
 968         char *page, *tmp;
 969         ssize_t length;
 970         struct task_struct *task = proc_task(inode);
 971         uid_t loginuid;
 972
 973         if (!capable(CAP_AUDIT_CONTROL))
 974                 return -EPERM;
 975
 976         if (current != task)
 977                 return -EPERM;
 978
 979         if (count > PAGE_SIZE)
 980                 count = PAGE_SIZE;
 981
 982         if (*ppos != 0) {
 983                 /* No partial writes. */
 984                 return -EINVAL;
 985         }
 986         page = (char*)__get_free_page(GFP_USER);
 987         if (!page)
 988                 return -ENOMEM;
 989         length = -EFAULT;
 990         if (copy_from_user(page, buf, count))
 991                 goto out_free_page;
 992
 993         loginuid = simple_strtoul(page, &tmp, 10);
 994         if (tmp == page) {
 995                 length = -EINVAL;
 996                 goto out_free_page;
 997
 998         }
 999         length = audit_set_loginuid(task, loginuid);
1000         if (likely(length == 0))
1001                 length = count;
1002
1003 out_free_page:
1004         free_page((unsigned long) page);
1005         return length;
1006 }
1007
1008 static struct file_operations proc_loginuid_operations = {
1009         .read           = proc_loginuid_read,
1010         .write          = proc_loginuid_write,
1011 };
1012 #endif
1013
1014 #ifdef CONFIG_SECCOMP
1015 static ssize_t seccomp_read(struct file *file, char __user *buf,
1016                             size_t count, loff_t *ppos)
1017 {
1018         struct task_struct *tsk = proc_task(file->f_dentry->d_inode);
1019         char __buf[20];
1020         loff_t __ppos = *ppos;
1021         size_t len;
1022
1023         /* no need to print the trailing zero, so use only len */
1024         len = sprintf(__buf, "%u\n", tsk->seccomp.mode);
1025         if (__ppos >= len)
1026                 return 0;
1027         if (count > len - __ppos)
1028                 count = len - __ppos;
1029         if (copy_to_user(buf, __buf + __ppos, count))
1030                 return -EFAULT;
1031         *ppos = __ppos + count;
1032         return count;
1033 }
1034
1035 static ssize_t seccomp_write(struct file *file, const char __user *buf,
1036                              size_t count, loff_t *ppos)
1037 {
1038         struct task_struct *tsk = proc_task(file->f_dentry->d_inode);
1039         char __buf[20], *end;
1040         unsigned int seccomp_mode;
1041
1042         /* can set it only once to be even more secure */
1043         if (unlikely(tsk->seccomp.mode))
1044                 return -EPERM;
1045
1046         memset(__buf, 0, sizeof(__buf));
1047         count = min(count, sizeof(__buf) - 1);
1048         if (copy_from_user(__buf, buf, count))
1049                 return -EFAULT;
1050         seccomp_mode = simple_strtoul(__buf, &end, 0);
1051         if (*end == '\n')
1052                 end++;
1053         if (seccomp_mode && seccomp_mode <= NR_SECCOMP_MODES) {
1054                 tsk->seccomp.mode = seccomp_mode;
1055                 set_tsk_thread_flag(tsk, TIF_SECCOMP);
1056         } else
1057                 return -EINVAL;
1058         if (unlikely(!(end - __buf)))
1059                 return -EIO;
1060         return end - __buf;
1061 }
1062
1063 static struct file_operations proc_seccomp_operations = {
1064         .read           = seccomp_read,
1065         .write          = seccomp_write,
1066 };
1067 #endif /* CONFIG_SECCOMP */
1068
1069 static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd)
1070 {
1071         struct inode *inode = dentry->d_inode;
1072         int error = -EACCES;
1073
1074         /* We don't need a base pointer in the /proc filesystem */
1075         path_release(nd);
1076
1077         if (current->fsuid != inode->i_uid && !capable(CAP_DAC_OVERRIDE))
1078                 goto out;
1079         error = proc_check_root(inode);
1080         if (error)
1081                 goto out;
1082
1083         error = PROC_I(inode)->op.proc_get_link(inode, &nd->dentry, &nd->mnt);
1084         nd->last_type = LAST_BIND;
1085 out:
1086         return ERR_PTR(error);
1087 }
1088
1089 static int do_proc_readlink(struct dentry *dentry, struct vfsmount *mnt,
1090                             char __user *buffer, int buflen)
1091 {
1092         struct inode * inode;
1093         char *tmp = (char*)__get_free_page(GFP_KERNEL), *path;
1094         int len;
1095
1096         if (!tmp)
1097                 return -ENOMEM;
1098
1099         inode = dentry->d_inode;
1100         path = d_path(dentry, mnt, tmp, PAGE_SIZE);
1101         len = PTR_ERR(path);
1102         if (IS_ERR(path))
1103                 goto out;
1104         len = tmp + PAGE_SIZE - 1 - path;
1105
1106         if (len > buflen)
1107                 len = buflen;
1108         if (copy_to_user(buffer, path, len))
1109                 len = -EFAULT;
1110  out:
1111         free_page((unsigned long)tmp);
1112         return len;
1113 }
1114
1115 static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen)
1116 {
1117         int error = -EACCES;
1118         struct inode *inode = dentry->d_inode;
1119         struct dentry *de;
1120         struct vfsmount *mnt = NULL;
1121
1122         lock_kernel();
1123
1124         if (current->fsuid != inode->i_uid && !capable(CAP_DAC_OVERRIDE))
1125                 goto out;
1126         error = proc_check_root(inode);
1127         if (error)
1128                 goto out;
1129
1130         error = PROC_I(inode)->op.proc_get_link(inode, &de, &mnt);
1131         if (error)
1132                 goto out;
1133
1134         error = do_proc_readlink(de, mnt, buffer, buflen);
1135         dput(de);
1136         mntput(mnt);
1137 out:
1138         unlock_kernel();
1139         return error;
1140 }
1141
1142 static struct inode_operations proc_pid_link_inode_operations = {
1143         .readlink       = proc_pid_readlink,
1144         .follow_link    = proc_pid_follow_link
1145 };
1146
1147 #define NUMBUF 10
1148
1149 static int proc_readfd(struct file * filp, void * dirent, filldir_t filldir)
1150 {
1151         struct inode *inode = filp->f_dentry->d_inode;
1152         struct task_struct *p = proc_task(inode);
1153         unsigned int fd, tid, ino;
1154         int retval;
1155         char buf[NUMBUF];
1156         struct files_struct * files;
1157         struct fdtable *fdt;
1158
1159         retval = -ENOENT;
1160         if (!pid_alive(p))
1161                 goto out;
1162         retval = 0;
1163         tid = p->pid;
1164
1165         fd = filp->f_pos;
1166         switch (fd) {
1167                 case 0:
1168                         if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0)
1169                                 goto out;
1170                         filp->f_pos++;
1171                 case 1:
1172                         ino = fake_ino(tid, PROC_TID_INO);
1173                         if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0)
1174                                 goto out;
1175                         filp->f_pos++;
1176                 default:
1177                         files = get_files_struct(p);
1178                         if (!files)
1179                                 goto out;
1180                         rcu_read_lock();
1181                         fdt = files_fdtable(files);
1182                         for (fd = filp->f_pos-2;
1183                              fd < fdt->max_fds;
1184                              fd++, filp->f_pos++) {
1185                                 unsigned int i,j;
1186
1187                                 if (!fcheck_files(files, fd))
1188                                         continue;
1189                                 rcu_read_unlock();
1190
1191                                 j = NUMBUF;
1192                                 i = fd;
1193                                 do {
1194                                         j--;
1195                                         buf[j] = '0' + (i % 10);
1196                                         i /= 10;
1197                                 } while (i);
1198
1199                                 ino = fake_ino(tid, PROC_TID_FD_DIR + fd);
1200                                 if (filldir(dirent, buf+j, NUMBUF-j, fd+2, ino, DT_LNK) < 0) {
1201                                         rcu_read_lock();
1202                                         break;
1203                                 }
1204                                 rcu_read_lock();
1205                         }
1206                         rcu_read_unlock();
1207                         put_files_struct(files);
1208         }
1209 out:
1210         return retval;
1211 }
1212
1213 static int proc_pident_readdir(struct file *filp,
1214                 void *dirent, filldir_t filldir,
1215                 struct pid_entry *ents, unsigned int nents)
1216 {
1217         int i;
1218         int pid;
1219         struct dentry *dentry = filp->f_dentry;
1220         struct inode *inode = dentry->d_inode;
1221         struct pid_entry *p;
1222         ino_t ino;
1223         int ret;
1224
1225         ret = -ENOENT;
1226         if (!pid_alive(proc_task(inode)))
1227                 goto out;
1228
1229         ret = 0;
1230         pid = proc_task(inode)->pid;
1231         i = filp->f_pos;
1232         switch (i) {
1233         case 0:
1234                 ino = inode->i_ino;
1235                 if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
1236                         goto out;
1237                 i++;
1238                 filp->f_pos++;
1239                 /* fall through */
1240         case 1:
1241                 ino = parent_ino(dentry);
1242                 if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
1243                         goto out;
1244                 i++;
1245                 filp->f_pos++;
1246                 /* fall through */
1247         default:
1248                 i -= 2;
1249                 if (i >= nents) {
1250                         ret = 1;
1251                         goto out;
1252                 }
1253                 p = ents + i;
1254                 while (p->name) {
1255                         if (filldir(dirent, p->name, p->len, filp->f_pos,
1256                                     fake_ino(pid, p->type), p->mode >> 12) < 0)
1257                                 goto out;
1258                         filp->f_pos++;
1259                         p++;
1260                 }
1261         }
1262
1263         ret = 1;
1264 out:
1265         return ret;
1266 }
1267
1268 static int proc_tgid_base_readdir(struct file * filp,
1269                              void * dirent, filldir_t filldir)
1270 {
1271         return proc_pident_readdir(filp,dirent,filldir,
1272                                    tgid_base_stuff,ARRAY_SIZE(tgid_base_stuff));
1273 }
1274
1275 static int proc_tid_base_readdir(struct file * filp,
1276                              void * dirent, filldir_t filldir)
1277 {
1278         return proc_pident_readdir(filp,dirent,filldir,
1279                                    tid_base_stuff,ARRAY_SIZE(tid_base_stuff));
1280 }
1281
1282 /* building an inode */
1283
1284 static int task_dumpable(struct task_struct *task)
1285 {
1286         int dumpable = 0;
1287         struct mm_struct *mm;
1288
1289         task_lock(task);
1290         mm = task->mm;
1291         if (mm)
1292                 dumpable = mm->dumpable;
1293         task_unlock(task);
1294         if(dumpable == 1)
1295                 return 1;
1296         return 0;
1297 }
1298
1299
1300 static struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task, int ino)
1301 {
1302         struct inode * inode;
1303         struct proc_inode *ei;
1304
1305         /* We need a new inode */
1306
1307         inode = new_inode(sb);
1308         if (!inode)
1309                 goto out;
1310
1311         /* Common stuff */
1312         ei = PROC_I(inode);
1313         ei->task = NULL;
1314         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
1315         inode->i_ino = fake_ino(task->pid, ino);
1316
1317         if (!pid_alive(task))
1318                 goto out_unlock;
1319
1320         /*
1321          * grab the reference to task.
1322          */
1323         get_task_struct(task);
1324         ei->task = task;
1325         ei->type = ino;
1326         inode->i_uid = 0;
1327         inode->i_gid = 0;
1328         if (ino == PROC_TGID_INO || ino == PROC_TID_INO || task_dumpable(task)) {
1329                 inode->i_uid = task->euid;
1330                 inode->i_gid = task->egid;
1331         }
1332         security_task_to_inode(task, inode);
1333
1334 out:
1335         return inode;
1336
1337 out_unlock:
1338         ei->pde = NULL;
1339         iput(inode);
1340         return NULL;
1341 }
1342
1343 /* dentry stuff */
1344
1345 /*
1346  *      Exceptional case: normally we are not allowed to unhash a busy
1347  * directory. In this case, however, we can do it - no aliasing problems
1348  * due to the way we treat inodes.
1349  *
1350  * Rewrite the inode's ownerships here because the owning task may have
1351  * performed a setuid(), etc.
1352  */
1353 static int pid_revalidate(struct dentry *dentry, struct nameidata *nd)
1354 {
1355         struct inode *inode = dentry->d_inode;
1356         struct task_struct *task = proc_task(inode);
1357         if (pid_alive(task)) {
1358                 if (proc_type(inode) == PROC_TGID_INO || proc_type(inode) == PROC_TID_INO || task_dumpable(task)) {
1359                         inode->i_uid = task->euid;
1360                         inode->i_gid = task->egid;
1361                 } else {
1362                         inode->i_uid = 0;
1363                         inode->i_gid = 0;
1364                 }
1365                 security_task_to_inode(task, inode);
1366                 return 1;
1367         }
1368         d_drop(dentry);
1369         return 0;
1370 }
1371
1372 static int tid_fd_revalidate(struct dentry *dentry, struct nameidata *nd)
1373 {
1374         struct inode *inode = dentry->d_inode;
1375         struct task_struct *task = proc_task(inode);
1376         int fd = proc_type(inode) - PROC_TID_FD_DIR;
1377         struct files_struct *files;
1378
1379         files = get_files_struct(task);
1380         if (files) {
1381                 rcu_read_lock();
1382                 if (fcheck_files(files, fd)) {
1383                         rcu_read_unlock();
1384                         put_files_struct(files);
1385                         if (task_dumpable(task)) {
1386                                 inode->i_uid = task->euid;
1387                                 inode->i_gid = task->egid;
1388                         } else {
1389                                 inode->i_uid = 0;
1390                                 inode->i_gid = 0;
1391                         }
1392                         security_task_to_inode(task, inode);
1393                         return 1;
1394                 }
1395                 rcu_read_unlock();
1396                 put_files_struct(files);
1397         }
1398         d_drop(dentry);
1399         return 0;
1400 }
1401
1402 static void pid_base_iput(struct dentry *dentry, struct inode *inode)
1403 {
1404         struct task_struct *task = proc_task(inode);
1405         spin_lock(&task->proc_lock);
1406         if (task->proc_dentry == dentry)
1407                 task->proc_dentry = NULL;
1408         spin_unlock(&task->proc_lock);
1409         iput(inode);
1410 }
1411
1412 static int pid_delete_dentry(struct dentry * dentry)
1413 {
1414         /* Is the task we represent dead?
1415          * If so, then don't put the dentry on the lru list,
1416          * kill it immediately.
1417          */
1418         return !pid_alive(proc_task(dentry->d_inode));
1419 }
1420
1421 static struct dentry_operations tid_fd_dentry_operations =
1422 {
1423         .d_revalidate   = tid_fd_revalidate,
1424         .d_delete       = pid_delete_dentry,
1425 };
1426
1427 static struct dentry_operations pid_dentry_operations =
1428 {
1429         .d_revalidate   = pid_revalidate,
1430         .d_delete       = pid_delete_dentry,
1431 };
1432
1433 static struct dentry_operations pid_base_dentry_operations =
1434 {
1435         .d_revalidate   = pid_revalidate,
1436         .d_iput         = pid_base_iput,
1437         .d_delete       = pid_delete_dentry,
1438 };
1439
1440 /* Lookups */
1441
1442 static unsigned name_to_int(struct dentry *dentry)
1443 {
1444         const char *name = dentry->d_name.name;
1445         int len = dentry->d_name.len;
1446         unsigned n = 0;
1447
1448         if (len > 1 && *name == '0')
1449                 goto out;
1450         while (len-- > 0) {
1451                 unsigned c = *name++ - '0';
1452                 if (c > 9)
1453                         goto out;
1454                 if (n >= (~0U-9)/10)
1455                         goto out;
1456                 n *= 10;
1457                 n += c;
1458         }
1459         return n;
1460 out:
1461         return ~0U;
1462 }
1463
1464 /* SMP-safe */
1465 static struct dentry *proc_lookupfd(struct inode * dir, struct dentry * dentry, struct nameidata *nd)
1466 {
1467         struct task_struct *task = proc_task(dir);
1468         unsigned fd = name_to_int(dentry);
1469         struct file * file;
1470         struct files_struct * files;
1471         struct inode *inode;
1472         struct proc_inode *ei;
1473
1474         if (fd == ~0U)
1475                 goto out;
1476         if (!pid_alive(task))
1477                 goto out;
1478
1479         inode = proc_pid_make_inode(dir->i_sb, task, PROC_TID_FD_DIR+fd);
1480         if (!inode)
1481                 goto out;
1482         ei = PROC_I(inode);
1483         files = get_files_struct(task);
1484         if (!files)
1485                 goto out_unlock;
1486         inode->i_mode = S_IFLNK;
1487         rcu_read_lock();
1488         file = fcheck_files(files, fd);
1489         if (!file)
1490                 goto out_unlock2;
1491         if (file->f_mode & 1)
1492                 inode->i_mode |= S_IRUSR | S_IXUSR;
1493         if (file->f_mode & 2)
1494                 inode->i_mode |= S_IWUSR | S_IXUSR;
1495         rcu_read_unlock();
1496         put_files_struct(files);
1497         inode->i_op = &proc_pid_link_inode_operations;
1498         inode->i_size = 64;
1499         ei->op.proc_get_link = proc_fd_link;
1500         dentry->d_op = &tid_fd_dentry_operations;
1501         d_add(dentry, inode);
1502         return NULL;
1503
1504 out_unlock2:
1505         rcu_read_unlock();
1506         put_files_struct(files);
1507 out_unlock:
1508         iput(inode);
1509 out:
1510         return ERR_PTR(-ENOENT);
1511 }
1512
1513 static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldir);
1514 static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd);
1515
1516 static struct file_operations proc_fd_operations = {
1517         .read           = generic_read_dir,
1518         .readdir        = proc_readfd,
1519 };
1520
1521 static struct file_operations proc_task_operations = {
1522         .read           = generic_read_dir,
1523         .readdir        = proc_task_readdir,
1524 };
1525
1526 /*
1527  * proc directories can do almost nothing..
1528  */
1529 static struct inode_operations proc_fd_inode_operations = {
1530         .lookup         = proc_lookupfd,
1531         .permission     = proc_permission,
1532 };
1533
1534 static struct inode_operations proc_task_inode_operations = {
1535         .lookup         = proc_task_lookup,
1536         .permission     = proc_task_permission,
1537 };
1538
1539 #ifdef CONFIG_SECURITY
1540 static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,
1541                                   size_t count, loff_t *ppos)
1542 {
1543         struct inode * inode = file->f_dentry->d_inode;
1544         unsigned long page;
1545         ssize_t length;
1546         struct task_struct *task = proc_task(inode);
1547
1548         if (count > PAGE_SIZE)
1549                 count = PAGE_SIZE;
1550         if (!(page = __get_free_page(GFP_KERNEL)))
1551                 return -ENOMEM;
1552
1553         length = security_getprocattr(task,
1554                                       (char*)file->f_dentry->d_name.name,
1555                                       (void*)page, count);
1556         if (length >= 0)
1557                 length = simple_read_from_buffer(buf, count, ppos, (char *)page, length);
1558         free_page(page);
1559         return length;
1560 }
1561
1562 static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,
1563                                    size_t count, loff_t *ppos)
1564 {
1565         struct inode * inode = file->f_dentry->d_inode;
1566         char *page;
1567         ssize_t length;
1568         struct task_struct *task = proc_task(inode);
1569
1570         if (count > PAGE_SIZE)
1571                 count = PAGE_SIZE;
1572         if (*ppos != 0) {
1573                 /* No partial writes. */
1574                 return -EINVAL;
1575         }
1576         page = (char*)__get_free_page(GFP_USER);
1577         if (!page)
1578                 return -ENOMEM;
1579         length = -EFAULT;
1580         if (copy_from_user(page, buf, count))
1581                 goto out;
1582
1583         length = security_setprocattr(task,
1584                                       (char*)file->f_dentry->d_name.name,
1585                                       (void*)page, count);
1586 out:
1587         free_page((unsigned long) page);
1588         return length;
1589 }
1590
1591 static struct file_operations proc_pid_attr_operations = {
1592         .read           = proc_pid_attr_read,
1593         .write          = proc_pid_attr_write,
1594 };
1595
1596 static struct file_operations proc_tid_attr_operations;
1597 static struct inode_operations proc_tid_attr_inode_operations;
1598 static struct file_operations proc_tgid_attr_operations;
1599 static struct inode_operations proc_tgid_attr_inode_operations;
1600 #endif
1601
1602 static int get_tid_list(int index, unsigned int *tids, struct inode *dir);
1603
1604 /* SMP-safe */
1605 static struct dentry *proc_pident_lookup(struct inode *dir,
1606                                          struct dentry *dentry,
1607                                          struct pid_entry *ents)
1608 {
1609         struct inode *inode;
1610         int error;
1611         struct task_struct *task = proc_task(dir);
1612         struct pid_entry *p;
1613         struct proc_inode *ei;
1614
1615         error = -ENOENT;
1616         inode = NULL;
1617
1618         if (!pid_alive(task))
1619                 goto out;
1620
1621         for (p = ents; p->name; p++) {
1622                 if (p->len != dentry->d_name.len)
1623                         continue;
1624                 if (!memcmp(dentry->d_name.name, p->name, p->len))
1625                         break;
1626         }
1627         if (!p->name)
1628                 goto out;
1629
1630         error = -EINVAL;
1631         inode = proc_pid_make_inode(dir->i_sb, task, p->type);
1632         if (!inode)
1633                 goto out;
1634
1635         ei = PROC_I(inode);
1636         inode->i_mode = p->mode;
1637         /*
1638          * Yes, it does not scale. And it should not. Don't add
1639          * new entries into /proc/<tgid>/ without very good reasons.
1640          */
1641         switch(p->type) {
1642                 case PROC_TGID_TASK:
1643                         inode->i_nlink = 2 + get_tid_list(2, NULL, dir);
1644                         inode->i_op = &proc_task_inode_operations;
1645                         inode->i_fop = &proc_task_operations;
1646                         break;
1647                 case PROC_TID_FD:
1648                 case PROC_TGID_FD:
1649                         inode->i_nlink = 2;
1650                         inode->i_op = &proc_fd_inode_operations;
1651                         inode->i_fop = &proc_fd_operations;
1652                         break;
1653                 case PROC_TID_EXE:
1654                 case PROC_TGID_EXE:
1655                         inode->i_op = &proc_pid_link_inode_operations;
1656                         ei->op.proc_get_link = proc_exe_link;
1657                         break;
1658                 case PROC_TID_CWD:
1659                 case PROC_TGID_CWD:
1660                         inode->i_op = &proc_pid_link_inode_operations;
1661                         ei->op.proc_get_link = proc_cwd_link;
1662                         break;
1663                 case PROC_TID_ROOT:
1664                 case PROC_TGID_ROOT:
1665                         inode->i_op = &proc_pid_link_inode_operations;
1666                         ei->op.proc_get_link = proc_root_link;
1667                         break;
1668                 case PROC_TID_ENVIRON:
1669                 case PROC_TGID_ENVIRON:
1670                         inode->i_fop = &proc_info_file_operations;
1671                         ei->op.proc_read = proc_pid_environ;
1672                         break;
1673                 case PROC_TID_AUXV:
1674                 case PROC_TGID_AUXV:
1675                         inode->i_fop = &proc_info_file_operations;
1676                         ei->op.proc_read = proc_pid_auxv;
1677                         break;
1678                 case PROC_TID_STATUS:
1679                 case PROC_TGID_STATUS:
1680                         inode->i_fop = &proc_info_file_operations;
1681                         ei->op.proc_read = proc_pid_status;
1682                         break;
1683                 case PROC_TID_STAT:
1684                         inode->i_fop = &proc_info_file_operations;
1685                         ei->op.proc_read = proc_tid_stat;
1686                         break;
1687                 case PROC_TGID_STAT:
1688                         inode->i_fop = &proc_info_file_operations;
1689                         ei->op.proc_read = proc_tgid_stat;
1690                         break;
1691                 case PROC_TID_CMDLINE:
1692                 case PROC_TGID_CMDLINE:
1693                         inode->i_fop = &proc_info_file_operations;
1694                         ei->op.proc_read = proc_pid_cmdline;
1695                         break;
1696                 case PROC_TID_STATM:
1697                 case PROC_TGID_STATM:
1698                         inode->i_fop = &proc_info_file_operations;
1699                         ei->op.proc_read = proc_pid_statm;
1700                         break;
1701                 case PROC_TID_MAPS:
1702                 case PROC_TGID_MAPS:
1703                         inode->i_fop = &proc_maps_operations;
1704                         break;
1705 #ifdef CONFIG_NUMA
1706                 case PROC_TID_NUMA_MAPS:
1707                 case PROC_TGID_NUMA_MAPS:
1708                         inode->i_fop = &proc_numa_maps_operations;
1709                         break;
1710 #endif
1711                 case PROC_TID_MEM:
1712                 case PROC_TGID_MEM:
1713                         inode->i_op = &proc_mem_inode_operations;
1714                         inode->i_fop = &proc_mem_operations;
1715                         break;
1716 #ifdef CONFIG_SECCOMP
1717                 case PROC_TID_SECCOMP:
1718                 case PROC_TGID_SECCOMP:
1719                         inode->i_fop = &proc_seccomp_operations;
1720                         break;
1721 #endif /* CONFIG_SECCOMP */
1722                 case PROC_TID_MOUNTS:
1723                 case PROC_TGID_MOUNTS:
1724                         inode->i_fop = &proc_mounts_operations;
1725                         break;
1726 #ifdef CONFIG_MMU
1727                 case PROC_TID_SMAPS:
1728                 case PROC_TGID_SMAPS:
1729                         inode->i_fop = &proc_smaps_operations;
1730                         break;
1731 #endif
1732 #ifdef CONFIG_SECURITY
1733                 case PROC_TID_ATTR:
1734                         inode->i_nlink = 2;
1735                         inode->i_op = &proc_tid_attr_inode_operations;
1736                         inode->i_fop = &proc_tid_attr_operations;
1737                         break;
1738                 case PROC_TGID_ATTR:
1739                         inode->i_nlink = 2;
1740                         inode->i_op = &proc_tgid_attr_inode_operations;
1741                         inode->i_fop = &proc_tgid_attr_operations;
1742                         break;
1743                 case PROC_TID_ATTR_CURRENT:
1744                 case PROC_TGID_ATTR_CURRENT:
1745                 case PROC_TID_ATTR_PREV:
1746                 case PROC_TGID_ATTR_PREV:
1747                 case PROC_TID_ATTR_EXEC:
1748                 case PROC_TGID_ATTR_EXEC:
1749                 case PROC_TID_ATTR_FSCREATE:
1750                 case PROC_TGID_ATTR_FSCREATE:
1751                         inode->i_fop = &proc_pid_attr_operations;
1752                         break;
1753 #endif
1754 #ifdef CONFIG_KALLSYMS
1755                 case PROC_TID_WCHAN:
1756                 case PROC_TGID_WCHAN:
1757                         inode->i_fop = &proc_info_file_operations;
1758                         ei->op.proc_read = proc_pid_wchan;
1759                         break;
1760 #endif
1761 #ifdef CONFIG_SCHEDSTATS
1762                 case PROC_TID_SCHEDSTAT:
1763                 case PROC_TGID_SCHEDSTAT:
1764                         inode->i_fop = &proc_info_file_operations;
1765                         ei->op.proc_read = proc_pid_schedstat;
1766                         break;
1767 #endif
1768 #ifdef CONFIG_CPUSETS
1769                 case PROC_TID_CPUSET:
1770                 case PROC_TGID_CPUSET:
1771                         inode->i_fop = &proc_cpuset_operations;
1772                         break;
1773 #endif
1774                 case PROC_TID_OOM_SCORE:
1775                 case PROC_TGID_OOM_SCORE:
1776                         inode->i_fop = &proc_info_file_operations;
1777                         ei->op.proc_read = proc_oom_score;
1778                         break;
1779                 case PROC_TID_OOM_ADJUST:
1780                 case PROC_TGID_OOM_ADJUST:
1781                         inode->i_fop = &proc_oom_adjust_operations;
1782                         break;
1783 #ifdef CONFIG_AUDITSYSCALL
1784                 case PROC_TID_LOGINUID:
1785                 case PROC_TGID_LOGINUID:
1786                         inode->i_fop = &proc_loginuid_operations;
1787                         break;
1788 #endif
1789                 default:
1790                         printk("procfs: impossible type (%d)",p->type);
1791                         iput(inode);
1792                         return ERR_PTR(-EINVAL);
1793         }
1794         dentry->d_op = &pid_dentry_operations;
1795         d_add(dentry, inode);
1796         return NULL;
1797
1798 out:
1799         return ERR_PTR(error);
1800 }
1801
1802 static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
1803         return proc_pident_lookup(dir, dentry, tgid_base_stuff);
1804 }
1805
1806 static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
1807         return proc_pident_lookup(dir, dentry, tid_base_stuff);
1808 }
1809
1810 static struct file_operations proc_tgid_base_operations = {
1811         .read           = generic_read_dir,
1812         .readdir        = proc_tgid_base_readdir,
1813 };
1814
1815 static struct file_operations proc_tid_base_operations = {
1816         .read           = generic_read_dir,
1817         .readdir        = proc_tid_base_readdir,
1818 };
1819
1820 static struct inode_operations proc_tgid_base_inode_operations = {
1821         .lookup         = proc_tgid_base_lookup,
1822 };
1823
1824 static struct inode_operations proc_tid_base_inode_operations = {
1825         .lookup         = proc_tid_base_lookup,
1826 };
1827
1828 #ifdef CONFIG_SECURITY
1829 static int proc_tgid_attr_readdir(struct file * filp,
1830                              void * dirent, filldir_t filldir)
1831 {
1832         return proc_pident_readdir(filp,dirent,filldir,
1833                                    tgid_attr_stuff,ARRAY_SIZE(tgid_attr_stuff));
1834 }
1835
1836 static int proc_tid_attr_readdir(struct file * filp,
1837                              void * dirent, filldir_t filldir)
1838 {
1839         return proc_pident_readdir(filp,dirent,filldir,
1840                                    tid_attr_stuff,ARRAY_SIZE(tid_attr_stuff));
1841 }
1842
1843 static struct file_operations proc_tgid_attr_operations = {
1844         .read           = generic_read_dir,
1845         .readdir        = proc_tgid_attr_readdir,
1846 };
1847
1848 static struct file_operations proc_tid_attr_operations = {
1849         .read           = generic_read_dir,
1850         .readdir        = proc_tid_attr_readdir,
1851 };
1852
1853 static struct dentry *proc_tgid_attr_lookup(struct inode *dir,
1854                                 struct dentry *dentry, struct nameidata *nd)
1855 {
1856         return proc_pident_lookup(dir, dentry, tgid_attr_stuff);
1857 }
1858
1859 static struct dentry *proc_tid_attr_lookup(struct inode *dir,
1860                                 struct dentry *dentry, struct nameidata *nd)
1861 {
1862         return proc_pident_lookup(dir, dentry, tid_attr_stuff);
1863 }
1864
1865 static struct inode_operations proc_tgid_attr_inode_operations = {
1866         .lookup         = proc_tgid_attr_lookup,
1867 };
1868
1869 static struct inode_operations proc_tid_attr_inode_operations = {
1870         .lookup         = proc_tid_attr_lookup,
1871 };
1872 #endif
1873
1874 /*
1875  * /proc/self:
1876  */
1877 static int proc_self_readlink(struct dentry *dentry, char __user *buffer,
1878                               int buflen)
1879 {
1880         char tmp[30];
1881         sprintf(tmp, "%d", current->tgid);
1882         return vfs_readlink(dentry,buffer,buflen,tmp);
1883 }
1884
1885 static void *proc_self_follow_link(struct dentry *dentry, struct nameidata *nd)
1886 {
1887         char tmp[30];
1888         sprintf(tmp, "%d", current->tgid);
1889         return ERR_PTR(vfs_follow_link(nd,tmp));
1890 }
1891
1892 static struct inode_operations proc_self_inode_operations = {
1893         .readlink       = proc_self_readlink,
1894         .follow_link    = proc_self_follow_link,
1895 };
1896
1897 /**
1898  * proc_pid_unhash -  Unhash /proc/@pid entry from the dcache.
1899  * @p: task that should be flushed.
1900  *
1901  * Drops the /proc/@pid dcache entry from the hash chains.
1902  *
1903  * Dropping /proc/@pid entries and detach_pid must be synchroneous,
1904  * otherwise e.g. /proc/@pid/exe might point to the wrong executable,
1905  * if the pid value is immediately reused. This is enforced by
1906  * - caller must acquire spin_lock(p->proc_lock)
1907  * - must be called before detach_pid()
1908  * - proc_pid_lookup acquires proc_lock, and checks that
1909  *   the target is not dead by looking at the attach count
1910  *   of PIDTYPE_PID.
1911  */
1912
1913 struct dentry *proc_pid_unhash(struct task_struct *p)
1914 {
1915         struct dentry *proc_dentry;
1916
1917         proc_dentry = p->proc_dentry;
1918         if (proc_dentry != NULL) {
1919
1920                 spin_lock(&dcache_lock);
1921                 spin_lock(&proc_dentry->d_lock);
1922                 if (!d_unhashed(proc_dentry)) {
1923                         dget_locked(proc_dentry);
1924                         __d_drop(proc_dentry);
1925                         spin_unlock(&proc_dentry->d_lock);
1926                 } else {
1927                         spin_unlock(&proc_dentry->d_lock);
1928                         proc_dentry = NULL;
1929                 }
1930                 spin_unlock(&dcache_lock);
1931         }
1932         return proc_dentry;
1933 }
1934
1935 /**
1936  * proc_pid_flush - recover memory used by stale /proc/@pid/x entries
1937  * @proc_dentry: directoy to prune.
1938  *
1939  * Shrink the /proc directory that was used by the just killed thread.
1940  */
1941
1942 void proc_pid_flush(struct dentry *proc_dentry)
1943 {
1944         might_sleep();
1945         if(proc_dentry != NULL) {
1946                 shrink_dcache_parent(proc_dentry);
1947                 dput(proc_dentry);
1948         }
1949 }
1950
1951 /* SMP-safe */
1952 struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
1953 {
1954         struct task_struct *task;
1955         struct inode *inode;
1956         struct proc_inode *ei;
1957         unsigned tgid;
1958         int died;
1959
1960         if (dentry->d_name.len == 4 && !memcmp(dentry->d_name.name,"self",4)) {
1961                 inode = new_inode(dir->i_sb);
1962                 if (!inode)
1963                         return ERR_PTR(-ENOMEM);
1964                 ei = PROC_I(inode);
1965                 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
1966                 inode->i_ino = fake_ino(0, PROC_TGID_INO);
1967                 ei->pde = NULL;
1968                 inode->i_mode = S_IFLNK|S_IRWXUGO;
1969                 inode->i_uid = inode->i_gid = 0;
1970                 inode->i_size = 64;
1971                 inode->i_op = &proc_self_inode_operations;
1972                 d_add(dentry, inode);
1973                 return NULL;
1974         }
1975         tgid = name_to_int(dentry);
1976         if (tgid == ~0U)
1977                 goto out;
1978
1979         read_lock(&tasklist_lock);
1980         task = find_task_by_pid(tgid);
1981         if (task)
1982                 get_task_struct(task);
1983         read_unlock(&tasklist_lock);
1984         if (!task)
1985                 goto out;
1986
1987         inode = proc_pid_make_inode(dir->i_sb, task, PROC_TGID_INO);
1988
1989
1990         if (!inode) {
1991                 put_task_struct(task);
1992                 goto out;
1993         }
1994         inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
1995         inode->i_op = &proc_tgid_base_inode_operations;
1996         inode->i_fop = &proc_tgid_base_operations;
1997         inode->i_flags|=S_IMMUTABLE;
1998 #ifdef CONFIG_SECURITY
1999         inode->i_nlink = 5;
2000 #else
2001         inode->i_nlink = 4;
2002 #endif
2003
2004         dentry->d_op = &pid_base_dentry_operations;
2005
2006         died = 0;
2007         d_add(dentry, inode);
2008         spin_lock(&task->proc_lock);
2009         task->proc_dentry = dentry;
2010         if (!pid_alive(task)) {
2011                 dentry = proc_pid_unhash(task);
2012                 died = 1;
2013         }
2014         spin_unlock(&task->proc_lock);
2015
2016         put_task_struct(task);
2017         if (died) {
2018                 proc_pid_flush(dentry);
2019                 goto out;
2020         }
2021         return NULL;
2022 out:
2023         return ERR_PTR(-ENOENT);
2024 }
2025
2026 /* SMP-safe */
2027 static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
2028 {
2029         struct task_struct *task;
2030         struct task_struct *leader = proc_task(dir);
2031         struct inode *inode;
2032         unsigned tid;
2033
2034         tid = name_to_int(dentry);
2035         if (tid == ~0U)
2036                 goto out;
2037
2038         read_lock(&tasklist_lock);
2039         task = find_task_by_pid(tid);
2040         if (task)
2041                 get_task_struct(task);
2042         read_unlock(&tasklist_lock);
2043         if (!task)
2044                 goto out;
2045         if (leader->tgid != task->tgid)
2046                 goto out_drop_task;
2047
2048         inode = proc_pid_make_inode(dir->i_sb, task, PROC_TID_INO);
2049
2050
2051         if (!inode)
2052                 goto out_drop_task;
2053         inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
2054         inode->i_op = &proc_tid_base_inode_operations;
2055         inode->i_fop = &proc_tid_base_operations;
2056         inode->i_flags|=S_IMMUTABLE;
2057 #ifdef CONFIG_SECURITY
2058         inode->i_nlink = 4;
2059 #else
2060         inode->i_nlink = 3;
2061 #endif
2062
2063         dentry->d_op = &pid_base_dentry_operations;
2064
2065         d_add(dentry, inode);
2066
2067         put_task_struct(task);
2068         return NULL;
2069 out_drop_task:
2070         put_task_struct(task);
2071 out:
2072         return ERR_PTR(-ENOENT);
2073 }
2074
2075 #define PROC_NUMBUF 10
2076 #define PROC_MAXPIDS 20
2077
2078 /*
2079  * Get a few tgid's to return for filldir - we need to hold the
2080  * tasklist lock while doing this, and we must release it before
2081  * we actually do the filldir itself, so we use a temp buffer..
2082  */
2083 static int get_tgid_list(int index, unsigned long version, unsigned int *tgids)
2084 {
2085         struct task_struct *p;
2086         int nr_tgids = 0;
2087
2088         index--;
2089         read_lock(&tasklist_lock);
2090         p = NULL;
2091         if (version) {
2092                 p = find_task_by_pid(version);
2093                 if (p && !thread_group_leader(p))
2094                         p = NULL;
2095         }
2096
2097         if (p)
2098                 index = 0;
2099         else
2100                 p = next_task(&init_task);
2101
2102         for ( ; p != &init_task; p = next_task(p)) {
2103                 int tgid = p->pid;
2104                 if (!pid_alive(p))
2105                         continue;
2106                 if (--index >= 0)
2107                         continue;
2108                 tgids[nr_tgids] = tgid;
2109                 nr_tgids++;
2110                 if (nr_tgids >= PROC_MAXPIDS)
2111                         break;
2112         }
2113         read_unlock(&tasklist_lock);
2114         return nr_tgids;
2115 }
2116
2117 /*
2118  * Get a few tid's to return for filldir - we need to hold the
2119  * tasklist lock while doing this, and we must release it before
2120  * we actually do the filldir itself, so we use a temp buffer..
2121  */
2122 static int get_tid_list(int index, unsigned int *tids, struct inode *dir)
2123 {
2124         struct task_struct *leader_task = proc_task(dir);
2125         struct task_struct *task = leader_task;
2126         int nr_tids = 0;
2127
2128         index -= 2;
2129         read_lock(&tasklist_lock);
2130         /*
2131          * The starting point task (leader_task) might be an already
2132          * unlinked task, which cannot be used to access the task-list
2133          * via next_thread().
2134          */
2135         if (pid_alive(task)) do {
2136                 int tid = task->pid;
2137
2138                 if (--index >= 0)
2139                         continue;
2140                 if (tids != NULL)
2141                         tids[nr_tids] = tid;
2142                 nr_tids++;
2143                 if (nr_tids >= PROC_MAXPIDS)
2144                         break;
2145         } while ((task = next_thread(task)) != leader_task);
2146         read_unlock(&tasklist_lock);
2147         return nr_tids;
2148 }
2149
2150 /* for the /proc/ directory itself, after non-process stuff has been done */
2151 int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir)
2152 {
2153         unsigned int tgid_array[PROC_MAXPIDS];
2154         char buf[PROC_NUMBUF];
2155         unsigned int nr = filp->f_pos - FIRST_PROCESS_ENTRY;
2156         unsigned int nr_tgids, i;
2157         int next_tgid;
2158
2159         if (!nr) {
2160                 ino_t ino = fake_ino(0,PROC_TGID_INO);
2161                 if (filldir(dirent, "self", 4, filp->f_pos, ino, DT_LNK) < 0)
2162                         return 0;
2163                 filp->f_pos++;
2164                 nr++;
2165         }
2166
2167         /* f_version caches the tgid value that the last readdir call couldn't
2168          * return. lseek aka telldir automagically resets f_version to 0.
2169          */
2170         next_tgid = filp->f_version;
2171         filp->f_version = 0;
2172         for (;;) {
2173                 nr_tgids = get_tgid_list(nr, next_tgid, tgid_array);
2174                 if (!nr_tgids) {
2175                         /* no more entries ! */
2176                         break;
2177                 }
2178                 next_tgid = 0;
2179
2180                 /* do not use the last found pid, reserve it for next_tgid */
2181                 if (nr_tgids == PROC_MAXPIDS) {
2182                         nr_tgids--;
2183                         next_tgid = tgid_array[nr_tgids];
2184                 }
2185
2186                 for (i=0;i<nr_tgids;i++) {
2187                         int tgid = tgid_array[i];
2188                         ino_t ino = fake_ino(tgid,PROC_TGID_INO);
2189                         unsigned long j = PROC_NUMBUF;
2190
2191                         do
2192                                 buf[--j] = '0' + (tgid % 10);
2193                         while ((tgid /= 10) != 0);
2194
2195                         if (filldir(dirent, buf+j, PROC_NUMBUF-j, filp->f_pos, ino, DT_DIR) < 0) {
2196                                 /* returning this tgid failed, save it as the first
2197                                  * pid for the next readir call */
2198                                 filp->f_version = tgid_array[i];
2199                                 goto out;
2200                         }
2201                         filp->f_pos++;
2202                         nr++;
2203                 }
2204         }
2205 out:
2206         return 0;
2207 }
2208
2209 /* for the /proc/TGID/task/ directories */
2210 static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldir)
2211 {
2212         unsigned int tid_array[PROC_MAXPIDS];
2213         char buf[PROC_NUMBUF];
2214         unsigned int nr_tids, i;
2215         struct dentry *dentry = filp->f_dentry;
2216         struct inode *inode = dentry->d_inode;
2217         int retval = -ENOENT;
2218         ino_t ino;
2219         unsigned long pos = filp->f_pos;  /* avoiding "long long" filp->f_pos */
2220
2221         if (!pid_alive(proc_task(inode)))
2222                 goto out;
2223         retval = 0;
2224
2225         switch (pos) {
2226         case 0:
2227                 ino = inode->i_ino;
2228                 if (filldir(dirent, ".", 1, pos, ino, DT_DIR) < 0)
2229                         goto out;
2230                 pos++;
2231                 /* fall through */
2232         case 1:
2233                 ino = parent_ino(dentry);
2234                 if (filldir(dirent, "..", 2, pos, ino, DT_DIR) < 0)
2235                         goto out;
2236                 pos++;
2237                 /* fall through */
2238         }
2239
2240         nr_tids = get_tid_list(pos, tid_array, inode);
2241         inode->i_nlink = pos + nr_tids;
2242
2243         for (i = 0; i < nr_tids; i++) {
2244                 unsigned long j = PROC_NUMBUF;
2245                 int tid = tid_array[i];
2246
2247                 ino = fake_ino(tid,PROC_TID_INO);
2248
2249                 do
2250                         buf[--j] = '0' + (tid % 10);
2251                 while ((tid /= 10) != 0);
2252
2253                 if (filldir(dirent, buf+j, PROC_NUMBUF-j, pos, ino, DT_DIR) < 0)
2254                         break;
2255                 pos++;
2256         }
2257 out:
2258         filp->f_pos = pos;
2259         return retval;
2260 }