base.c 62.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 *  linux/fs/proc/base.c
 *
 *  Copyright (C) 1991, 1992 Linus Torvalds
 *
 *  proc base directory handling functions
 *
 *  1999, Al Viro. Rewritten. Now it covers the whole per-process part.
 *  Instead of using magical inumbers to determine the kind of object
 *  we allocate and fill in-core inodes upon lookup. They don't even
 *  go into icache. We cache the reference to task_struct upon lookup too.
 *  Eventually it should become a filesystem in its own. We don't use the
 *  rest of procfs anymore.
M
Mauricio Lin 已提交
14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
 *
 *
 *  Changelog:
 *  17-Jan-2005
 *  Allan Bezerra
 *  Bruna Moreira <bruna.moreira@indt.org.br>
 *  Edjard Mota <edjard.mota@indt.org.br>
 *  Ilias Biris <ilias.biris@indt.org.br>
 *  Mauricio Lin <mauricio.lin@indt.org.br>
 *
 *  Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT
 *
 *  A new process specific entry (smaps) included in /proc. It shows the
 *  size of rss for each memory area. The maps entry lacks information
 *  about physical memory size (rss) for each mapped file, i.e.,
 *  rss information for executables and library files.
 *  This additional information is useful for any tools that need to know
 *  about physical memory consumption for a process specific library.
 *
 *  Changelog:
 *  21-Feb-2005
 *  Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT
 *  Pud inclusion in the page table walking.
 *
 *  ChangeLog:
 *  10-Mar-2005
 *  10LE Instituto Nokia de Tecnologia - INdT:
 *  A better way to walks through the page table as suggested by Hugh Dickins.
 *
 *  Simo Piiroinen <simo.piiroinen@nokia.com>:
 *  Smaps information related to shared, private, clean and dirty pages.
 *
 *  Paul Mundt <paul.mundt@nokia.com>:
 *  Overall revision about smaps.
L
Linus Torvalds 已提交
48 49 50 51 52 53 54 55 56
 */

#include <asm/uaccess.h>

#include <linux/errno.h>
#include <linux/time.h>
#include <linux/proc_fs.h>
#include <linux/stat.h>
#include <linux/init.h>
57
#include <linux/capability.h>
L
Linus Torvalds 已提交
58 59 60 61
#include <linux/file.h>
#include <linux/string.h>
#include <linux/seq_file.h>
#include <linux/namei.h>
62
#include <linux/mnt_namespace.h>
L
Linus Torvalds 已提交
63
#include <linux/mm.h>
64
#include <linux/rcupdate.h>
L
Linus Torvalds 已提交
65
#include <linux/kallsyms.h>
K
Kees Cook 已提交
66
#include <linux/module.h>
L
Linus Torvalds 已提交
67 68 69
#include <linux/mount.h>
#include <linux/security.h>
#include <linux/ptrace.h>
70
#include <linux/cgroup.h>
L
Linus Torvalds 已提交
71 72
#include <linux/cpuset.h>
#include <linux/audit.h>
A
Al Viro 已提交
73
#include <linux/poll.h>
74
#include <linux/nsproxy.h>
75
#include <linux/oom.h>
76
#include <linux/elf.h>
77
#include <linux/pid_namespace.h>
L
Linus Torvalds 已提交
78 79
#include "internal.h"

80 81 82 83 84 85 86 87 88 89
/* NOTE:
 *	Implementing inode permission operations in /proc is almost
 *	certainly an error.  Permission checks need to happen during
 *	each system call not at open time.  The reason is that most of
 *	what we wish to check for permissions in /proc varies at runtime.
 *
 *	The classic example of a problem is opening file descriptors
 *	in /proc for a task before it execs a suid executable.
 */

L
Linus Torvalds 已提交
90

91
/* Worst case buffer size needed for holding an integer. */
A
Andrew Morton 已提交
92
#define PROC_NUMBUF 13
93

L
Linus Torvalds 已提交
94 95
struct pid_entry {
	char *name;
96
	int len;
L
Linus Torvalds 已提交
97
	mode_t mode;
98
	const struct inode_operations *iop;
99
	const struct file_operations *fop;
100
	union proc_op op;
L
Linus Torvalds 已提交
101 102
};

103
#define NOD(NAME, MODE, IOP, FOP, OP) {			\
104
	.name = (NAME),					\
105
	.len  = sizeof(NAME) - 1,			\
106 107 108 109 110 111
	.mode = MODE,					\
	.iop  = IOP,					\
	.fop  = FOP,					\
	.op   = OP,					\
}

112 113
#define DIR(NAME, MODE, OTYPE)							\
	NOD(NAME, (S_IFDIR|(MODE)),						\
114 115
		&proc_##OTYPE##_inode_operations, &proc_##OTYPE##_operations,	\
		{} )
116 117
#define LNK(NAME, OTYPE)					\
	NOD(NAME, (S_IFLNK|S_IRWXUGO),				\
118 119
		&proc_pid_link_inode_operations, NULL,		\
		{ .proc_get_link = &proc_##OTYPE##_link } )
120 121
#define REG(NAME, MODE, OTYPE)				\
	NOD(NAME, (S_IFREG|(MODE)), NULL,		\
122
		&proc_##OTYPE##_operations, {})
123 124
#define INF(NAME, MODE, OTYPE)				\
	NOD(NAME, (S_IFREG|(MODE)), 			\
125 126
		NULL, &proc_info_file_operations,	\
		{ .proc_read = &proc_##OTYPE } )
L
Linus Torvalds 已提交
127

K
Kees Cook 已提交
128 129 130
int maps_protect;
EXPORT_SYMBOL(maps_protect);

131
static struct fs_struct *get_fs_struct(struct task_struct *task)
L
Linus Torvalds 已提交
132 133
{
	struct fs_struct *fs;
134 135
	task_lock(task);
	fs = task->fs;
L
Linus Torvalds 已提交
136 137
	if(fs)
		atomic_inc(&fs->count);
138 139 140 141
	task_unlock(task);
	return fs;
}

142 143 144 145 146 147 148 149 150 151 152 153 154
static int get_nr_threads(struct task_struct *tsk)
{
	/* Must be called with the rcu_read_lock held */
	unsigned long flags;
	int count = 0;

	if (lock_task_sighand(tsk, &flags)) {
		count = atomic_read(&tsk->signal->count);
		unlock_task_sighand(tsk, &flags);
	}
	return count;
}

155 156
static int proc_cwd_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
{
157 158
	struct task_struct *task = get_proc_task(inode);
	struct fs_struct *fs = NULL;
159
	int result = -ENOENT;
160 161 162 163 164

	if (task) {
		fs = get_fs_struct(task);
		put_task_struct(task);
	}
L
Linus Torvalds 已提交
165 166 167 168 169 170 171 172 173 174 175 176 177
	if (fs) {
		read_lock(&fs->lock);
		*mnt = mntget(fs->pwdmnt);
		*dentry = dget(fs->pwd);
		read_unlock(&fs->lock);
		result = 0;
		put_fs_struct(fs);
	}
	return result;
}

static int proc_root_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
{
178 179
	struct task_struct *task = get_proc_task(inode);
	struct fs_struct *fs = NULL;
L
Linus Torvalds 已提交
180
	int result = -ENOENT;
181 182 183 184 185

	if (task) {
		fs = get_fs_struct(task);
		put_task_struct(task);
	}
L
Linus Torvalds 已提交
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
	if (fs) {
		read_lock(&fs->lock);
		*mnt = mntget(fs->rootmnt);
		*dentry = dget(fs->root);
		read_unlock(&fs->lock);
		result = 0;
		put_fs_struct(fs);
	}
	return result;
}

#define MAY_PTRACE(task) \
	(task == current || \
	(task->parent == current && \
	(task->ptrace & PT_PTRACED) && \
	 (task->state == TASK_STOPPED || task->state == TASK_TRACED) && \
	 security_ptrace(current,task) == 0))

static int proc_pid_cmdline(struct task_struct *task, char * buffer)
{
	int res = 0;
	unsigned int len;
	struct mm_struct *mm = get_task_mm(task);
	if (!mm)
		goto out;
	if (!mm->arg_end)
		goto out_mm;	/* Shh! No looking before we're done */

 	len = mm->arg_end - mm->arg_start;
 
	if (len > PAGE_SIZE)
		len = PAGE_SIZE;
 
	res = access_process_vm(task, mm->arg_start, buffer, len, 0);

	// If the nul at the end of args has been overwritten, then
	// assume application is using setproctitle(3).
	if (res > 0 && buffer[res-1] != '\0' && len < PAGE_SIZE) {
		len = strnlen(buffer, res);
		if (len < res) {
		    res = len;
		} else {
			len = mm->env_end - mm->env_start;
			if (len > PAGE_SIZE - res)
				len = PAGE_SIZE - res;
			res += access_process_vm(task, mm->env_start, buffer+res, len, 0);
			res = strnlen(buffer, res);
		}
	}
out_mm:
	mmput(mm);
out:
	return res;
}

static int proc_pid_auxv(struct task_struct *task, char *buffer)
{
	int res = 0;
	struct mm_struct *mm = get_task_mm(task);
	if (mm) {
		unsigned int nwords = 0;
		do
			nwords += 2;
		while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */
		res = nwords * sizeof(mm->saved_auxv[0]);
		if (res > PAGE_SIZE)
			res = PAGE_SIZE;
		memcpy(buffer, mm->saved_auxv, res);
		mmput(mm);
	}
	return res;
}


#ifdef CONFIG_KALLSYMS
/*
 * Provides a wchan file via kallsyms in a proper one-value-per-file format.
 * Returns the resolved symbol.  If that fails, simply return the address.
 */
static int proc_pid_wchan(struct task_struct *task, char *buffer)
{
A
Alexey Dobriyan 已提交
267
	unsigned long wchan;
268
	char symname[KSYM_NAME_LEN];
L
Linus Torvalds 已提交
269 270 271

	wchan = get_wchan(task);

272 273 274 275
	if (lookup_symbol_name(wchan, symname) < 0)
		return sprintf(buffer, "%lu", wchan);
	else
		return sprintf(buffer, "%s", symname);
L
Linus Torvalds 已提交
276 277 278 279 280 281 282 283 284
}
#endif /* CONFIG_KALLSYMS */

#ifdef CONFIG_SCHEDSTATS
/*
 * Provides /proc/PID/schedstat
 */
static int proc_pid_schedstat(struct task_struct *task, char *buffer)
{
285
	return sprintf(buffer, "%llu %llu %lu\n",
L
Linus Torvalds 已提交
286 287
			task->sched_info.cpu_time,
			task->sched_info.run_delay,
288
			task->sched_info.pcount);
L
Linus Torvalds 已提交
289 290 291 292 293 294 295 296 297 298 299
}
#endif

/* The badness from the OOM killer */
unsigned long badness(struct task_struct *p, unsigned long uptime);
static int proc_oom_score(struct task_struct *task, char *buffer)
{
	unsigned long points;
	struct timespec uptime;

	do_posix_clock_monotonic_gettime(&uptime);
300
	read_lock(&tasklist_lock);
L
Linus Torvalds 已提交
301
	points = badness(task, uptime.tv_sec);
302
	read_unlock(&tasklist_lock);
L
Linus Torvalds 已提交
303 304 305 306 307 308 309 310
	return sprintf(buffer, "%lu\n", points);
}

/************************************************************************/
/*                       Here the fs part begins                        */
/************************************************************************/

/* permission checks */
311
static int proc_fd_access_allowed(struct inode *inode)
L
Linus Torvalds 已提交
312
{
313 314
	struct task_struct *task;
	int allowed = 0;
315 316 317
	/* Allow access to a task's file descriptors if it is us or we
	 * may use ptrace attach to the process and find out that
	 * information.
318 319
	 */
	task = get_proc_task(inode);
320 321
	if (task) {
		allowed = ptrace_may_attach(task);
322
		put_task_struct(task);
323
	}
324
	return allowed;
L
Linus Torvalds 已提交
325 326
}

327 328 329 330 331 332 333 334 335
static int proc_setattr(struct dentry *dentry, struct iattr *attr)
{
	int error;
	struct inode *inode = dentry->d_inode;

	if (attr->ia_valid & ATTR_MODE)
		return -EPERM;

	error = inode_change_ok(inode, attr);
336 337
	if (!error)
		error = inode_setattr(inode, attr);
338 339 340
	return error;
}

341
static const struct inode_operations proc_def_inode_operations = {
342 343 344
	.setattr	= proc_setattr,
};

L
Linus Torvalds 已提交
345
extern struct seq_operations mounts_op;
A
Al Viro 已提交
346 347 348 349 350
struct proc_mounts {
	struct seq_file m;
	int event;
};

L
Linus Torvalds 已提交
351 352
static int mounts_open(struct inode *inode, struct file *file)
{
353
	struct task_struct *task = get_proc_task(inode);
354
	struct nsproxy *nsp;
355
	struct mnt_namespace *ns = NULL;
A
Al Viro 已提交
356 357
	struct proc_mounts *p;
	int ret = -EINVAL;
L
Linus Torvalds 已提交
358

359
	if (task) {
360 361 362 363
		rcu_read_lock();
		nsp = task_nsproxy(task);
		if (nsp) {
			ns = nsp->mnt_ns;
364 365 366
			if (ns)
				get_mnt_ns(ns);
		}
367 368
		rcu_read_unlock();

369 370
		put_task_struct(task);
	}
A
Al Viro 已提交
371

372
	if (ns) {
A
Al Viro 已提交
373 374 375 376 377 378
		ret = -ENOMEM;
		p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL);
		if (p) {
			file->private_data = &p->m;
			ret = seq_open(file, &mounts_op);
			if (!ret) {
379 380
				p->m.private = ns;
				p->event = ns->event;
A
Al Viro 已提交
381 382 383
				return 0;
			}
			kfree(p);
L
Linus Torvalds 已提交
384
		}
385
		put_mnt_ns(ns);
L
Linus Torvalds 已提交
386 387 388 389 390 391 392
	}
	return ret;
}

static int mounts_release(struct inode *inode, struct file *file)
{
	struct seq_file *m = file->private_data;
393 394
	struct mnt_namespace *ns = m->private;
	put_mnt_ns(ns);
L
Linus Torvalds 已提交
395 396 397
	return seq_release(inode, file);
}

A
Al Viro 已提交
398 399 400
static unsigned mounts_poll(struct file *file, poll_table *wait)
{
	struct proc_mounts *p = file->private_data;
401
	struct mnt_namespace *ns = p->m.private;
A
Al Viro 已提交
402 403 404 405 406 407 408 409 410 411 412 413 414 415
	unsigned res = 0;

	poll_wait(file, &ns->poll, wait);

	spin_lock(&vfsmount_lock);
	if (p->event != ns->event) {
		p->event = ns->event;
		res = POLLERR;
	}
	spin_unlock(&vfsmount_lock);

	return res;
}

416
static const struct file_operations proc_mounts_operations = {
L
Linus Torvalds 已提交
417 418 419 420
	.open		= mounts_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= mounts_release,
A
Al Viro 已提交
421
	.poll		= mounts_poll,
L
Linus Torvalds 已提交
422 423
};

424 425 426 427 428 429 430
extern struct seq_operations mountstats_op;
static int mountstats_open(struct inode *inode, struct file *file)
{
	int ret = seq_open(file, &mountstats_op);

	if (!ret) {
		struct seq_file *m = file->private_data;
431
		struct nsproxy *nsp;
432
		struct mnt_namespace *mnt_ns = NULL;
433 434 435
		struct task_struct *task = get_proc_task(inode);

		if (task) {
436 437 438 439 440 441 442 443 444
			rcu_read_lock();
			nsp = task_nsproxy(task);
			if (nsp) {
				mnt_ns = nsp->mnt_ns;
				if (mnt_ns)
					get_mnt_ns(mnt_ns);
			}
			rcu_read_unlock();

445 446
			put_task_struct(task);
		}
447

448 449
		if (mnt_ns)
			m->private = mnt_ns;
450 451 452 453 454 455 456 457
		else {
			seq_release(inode, file);
			ret = -EINVAL;
		}
	}
	return ret;
}

458
static const struct file_operations proc_mountstats_operations = {
459 460 461 462 463 464
	.open		= mountstats_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= mounts_release,
};

L
Linus Torvalds 已提交
465 466 467 468 469
#define PROC_BLOCK_SIZE	(3*1024)		/* 4K page size but our output routines use some slack for overruns */

static ssize_t proc_info_read(struct file * file, char __user * buf,
			  size_t count, loff_t *ppos)
{
470
	struct inode * inode = file->f_path.dentry->d_inode;
L
Linus Torvalds 已提交
471 472
	unsigned long page;
	ssize_t length;
473 474 475 476 477
	struct task_struct *task = get_proc_task(inode);

	length = -ESRCH;
	if (!task)
		goto out_no_task;
L
Linus Torvalds 已提交
478 479 480

	if (count > PROC_BLOCK_SIZE)
		count = PROC_BLOCK_SIZE;
481 482

	length = -ENOMEM;
483
	if (!(page = __get_free_page(GFP_TEMPORARY)))
484
		goto out;
L
Linus Torvalds 已提交
485 486 487 488 489 490

	length = PROC_I(inode)->op.proc_read(task, (char*)page);

	if (length >= 0)
		length = simple_read_from_buffer(buf, count, ppos, (char *)page, length);
	free_page(page);
491 492 493
out:
	put_task_struct(task);
out_no_task:
L
Linus Torvalds 已提交
494 495 496
	return length;
}

497
static const struct file_operations proc_info_file_operations = {
L
Linus Torvalds 已提交
498 499 500 501 502 503 504 505 506 507 508 509
	.read		= proc_info_read,
};

static int mem_open(struct inode* inode, struct file* file)
{
	file->private_data = (void*)((long)current->self_exec_id);
	return 0;
}

static ssize_t mem_read(struct file * file, char __user * buf,
			size_t count, loff_t *ppos)
{
510
	struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
L
Linus Torvalds 已提交
511 512 513 514 515
	char *page;
	unsigned long src = *ppos;
	int ret = -ESRCH;
	struct mm_struct *mm;

516 517 518
	if (!task)
		goto out_no_task;

519
	if (!MAY_PTRACE(task) || !ptrace_may_attach(task))
L
Linus Torvalds 已提交
520 521 522
		goto out;

	ret = -ENOMEM;
523
	page = (char *)__get_free_page(GFP_TEMPORARY);
L
Linus Torvalds 已提交
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
	if (!page)
		goto out;

	ret = 0;
 
	mm = get_task_mm(task);
	if (!mm)
		goto out_free;

	ret = -EIO;
 
	if (file->private_data != (void*)((long)current->self_exec_id))
		goto out_put;

	ret = 0;
 
	while (count > 0) {
		int this_len, retval;

		this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
		retval = access_process_vm(task, src, page, this_len, 0);
545
		if (!retval || !MAY_PTRACE(task) || !ptrace_may_attach(task)) {
L
Linus Torvalds 已提交
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567
			if (!ret)
				ret = -EIO;
			break;
		}

		if (copy_to_user(buf, page, retval)) {
			ret = -EFAULT;
			break;
		}
 
		ret += retval;
		src += retval;
		buf += retval;
		count -= retval;
	}
	*ppos = src;

out_put:
	mmput(mm);
out_free:
	free_page((unsigned long) page);
out:
568 569
	put_task_struct(task);
out_no_task:
L
Linus Torvalds 已提交
570 571 572 573 574 575 576
	return ret;
}

#define mem_write NULL

#ifndef mem_write
/* This is a security hazard */
577
static ssize_t mem_write(struct file * file, const char __user *buf,
L
Linus Torvalds 已提交
578 579
			 size_t count, loff_t *ppos)
{
580
	int copied;
L
Linus Torvalds 已提交
581
	char *page;
582
	struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
L
Linus Torvalds 已提交
583 584
	unsigned long dst = *ppos;

585 586 587 588
	copied = -ESRCH;
	if (!task)
		goto out_no_task;

589
	if (!MAY_PTRACE(task) || !ptrace_may_attach(task))
590
		goto out;
L
Linus Torvalds 已提交
591

592
	copied = -ENOMEM;
593
	page = (char *)__get_free_page(GFP_TEMPORARY);
L
Linus Torvalds 已提交
594
	if (!page)
595
		goto out;
L
Linus Torvalds 已提交
596

597
	copied = 0;
L
Linus Torvalds 已提交
598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618
	while (count > 0) {
		int this_len, retval;

		this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
		if (copy_from_user(page, buf, this_len)) {
			copied = -EFAULT;
			break;
		}
		retval = access_process_vm(task, dst, page, this_len, 1);
		if (!retval) {
			if (!copied)
				copied = -EIO;
			break;
		}
		copied += retval;
		buf += retval;
		dst += retval;
		count -= retval;			
	}
	*ppos = dst;
	free_page((unsigned long) page);
619 620 621
out:
	put_task_struct(task);
out_no_task:
L
Linus Torvalds 已提交
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
	return copied;
}
#endif

static loff_t mem_lseek(struct file * file, loff_t offset, int orig)
{
	switch (orig) {
	case 0:
		file->f_pos = offset;
		break;
	case 1:
		file->f_pos += offset;
		break;
	default:
		return -EINVAL;
	}
	force_successful_syscall_return();
	return file->f_pos;
}

642
static const struct file_operations proc_mem_operations = {
L
Linus Torvalds 已提交
643 644 645 646 647 648
	.llseek		= mem_lseek,
	.read		= mem_read,
	.write		= mem_write,
	.open		= mem_open,
};

649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718
static ssize_t environ_read(struct file *file, char __user *buf,
			size_t count, loff_t *ppos)
{
	struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
	char *page;
	unsigned long src = *ppos;
	int ret = -ESRCH;
	struct mm_struct *mm;

	if (!task)
		goto out_no_task;

	if (!ptrace_may_attach(task))
		goto out;

	ret = -ENOMEM;
	page = (char *)__get_free_page(GFP_TEMPORARY);
	if (!page)
		goto out;

	ret = 0;

	mm = get_task_mm(task);
	if (!mm)
		goto out_free;

	while (count > 0) {
		int this_len, retval, max_len;

		this_len = mm->env_end - (mm->env_start + src);

		if (this_len <= 0)
			break;

		max_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
		this_len = (this_len > max_len) ? max_len : this_len;

		retval = access_process_vm(task, (mm->env_start + src),
			page, this_len, 0);

		if (retval <= 0) {
			ret = retval;
			break;
		}

		if (copy_to_user(buf, page, retval)) {
			ret = -EFAULT;
			break;
		}

		ret += retval;
		src += retval;
		buf += retval;
		count -= retval;
	}
	*ppos = src;

	mmput(mm);
out_free:
	free_page((unsigned long) page);
out:
	put_task_struct(task);
out_no_task:
	return ret;
}

static const struct file_operations proc_environ_operations = {
	.read		= environ_read,
};

L
Linus Torvalds 已提交
719 720 721
static ssize_t oom_adjust_read(struct file *file, char __user *buf,
				size_t count, loff_t *ppos)
{
722
	struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
723
	char buffer[PROC_NUMBUF];
L
Linus Torvalds 已提交
724
	size_t len;
725
	int oom_adjust;
L
Linus Torvalds 已提交
726

727 728 729 730 731
	if (!task)
		return -ESRCH;
	oom_adjust = task->oomkilladj;
	put_task_struct(task);

732
	len = snprintf(buffer, sizeof(buffer), "%i\n", oom_adjust);
733 734

	return simple_read_from_buffer(buf, count, ppos, buffer, len);
L
Linus Torvalds 已提交
735 736 737 738 739
}

static ssize_t oom_adjust_write(struct file *file, const char __user *buf,
				size_t count, loff_t *ppos)
{
740
	struct task_struct *task;
741
	char buffer[PROC_NUMBUF], *end;
L
Linus Torvalds 已提交
742 743
	int oom_adjust;

744 745 746
	memset(buffer, 0, sizeof(buffer));
	if (count > sizeof(buffer) - 1)
		count = sizeof(buffer) - 1;
L
Linus Torvalds 已提交
747 748 749
	if (copy_from_user(buffer, buf, count))
		return -EFAULT;
	oom_adjust = simple_strtol(buffer, &end, 0);
750 751
	if ((oom_adjust < OOM_ADJUST_MIN || oom_adjust > OOM_ADJUST_MAX) &&
	     oom_adjust != OOM_DISABLE)
L
Linus Torvalds 已提交
752 753 754
		return -EINVAL;
	if (*end == '\n')
		end++;
755
	task = get_proc_task(file->f_path.dentry->d_inode);
756 757
	if (!task)
		return -ESRCH;
758 759 760 761
	if (oom_adjust < task->oomkilladj && !capable(CAP_SYS_RESOURCE)) {
		put_task_struct(task);
		return -EACCES;
	}
L
Linus Torvalds 已提交
762
	task->oomkilladj = oom_adjust;
763
	put_task_struct(task);
L
Linus Torvalds 已提交
764 765 766 767 768
	if (end - buffer == 0)
		return -EIO;
	return end - buffer;
}

769
static const struct file_operations proc_oom_adjust_operations = {
L
Linus Torvalds 已提交
770 771 772 773
	.read		= oom_adjust_read,
	.write		= oom_adjust_write,
};

774
#ifdef CONFIG_MMU
775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807
static ssize_t clear_refs_write(struct file *file, const char __user *buf,
				size_t count, loff_t *ppos)
{
	struct task_struct *task;
	char buffer[PROC_NUMBUF], *end;
	struct mm_struct *mm;

	memset(buffer, 0, sizeof(buffer));
	if (count > sizeof(buffer) - 1)
		count = sizeof(buffer) - 1;
	if (copy_from_user(buffer, buf, count))
		return -EFAULT;
	if (!simple_strtol(buffer, &end, 0))
		return -EINVAL;
	if (*end == '\n')
		end++;
	task = get_proc_task(file->f_path.dentry->d_inode);
	if (!task)
		return -ESRCH;
	mm = get_task_mm(task);
	if (mm) {
		clear_refs_smap(mm);
		mmput(mm);
	}
	put_task_struct(task);
	if (end - buffer == 0)
		return -EIO;
	return end - buffer;
}

static struct file_operations proc_clear_refs_operations = {
	.write		= clear_refs_write,
};
808
#endif
809

L
Linus Torvalds 已提交
810 811 812 813 814
#ifdef CONFIG_AUDITSYSCALL
#define TMPBUFLEN 21
static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
				  size_t count, loff_t *ppos)
{
815
	struct inode * inode = file->f_path.dentry->d_inode;
816
	struct task_struct *task = get_proc_task(inode);
L
Linus Torvalds 已提交
817 818 819
	ssize_t length;
	char tmpbuf[TMPBUFLEN];

820 821
	if (!task)
		return -ESRCH;
L
Linus Torvalds 已提交
822 823
	length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
				audit_get_loginuid(task->audit_context));
824
	put_task_struct(task);
L
Linus Torvalds 已提交
825 826 827 828 829 830
	return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
}

static ssize_t proc_loginuid_write(struct file * file, const char __user * buf,
				   size_t count, loff_t *ppos)
{
831
	struct inode * inode = file->f_path.dentry->d_inode;
L
Linus Torvalds 已提交
832 833 834 835 836 837 838
	char *page, *tmp;
	ssize_t length;
	uid_t loginuid;

	if (!capable(CAP_AUDIT_CONTROL))
		return -EPERM;

839
	if (current != pid_task(proc_pid(inode), PIDTYPE_PID))
L
Linus Torvalds 已提交
840 841
		return -EPERM;

842 843
	if (count >= PAGE_SIZE)
		count = PAGE_SIZE - 1;
L
Linus Torvalds 已提交
844 845 846 847 848

	if (*ppos != 0) {
		/* No partial writes. */
		return -EINVAL;
	}
849
	page = (char*)__get_free_page(GFP_TEMPORARY);
L
Linus Torvalds 已提交
850 851 852 853 854 855
	if (!page)
		return -ENOMEM;
	length = -EFAULT;
	if (copy_from_user(page, buf, count))
		goto out_free_page;

856
	page[count] = '\0';
L
Linus Torvalds 已提交
857 858 859 860 861 862
	loginuid = simple_strtoul(page, &tmp, 10);
	if (tmp == page) {
		length = -EINVAL;
		goto out_free_page;

	}
863
	length = audit_set_loginuid(current, loginuid);
L
Linus Torvalds 已提交
864 865 866 867 868 869 870 871
	if (likely(length == 0))
		length = count;

out_free_page:
	free_page((unsigned long) page);
	return length;
}

872
static const struct file_operations proc_loginuid_operations = {
L
Linus Torvalds 已提交
873 874 875 876 877
	.read		= proc_loginuid_read,
	.write		= proc_loginuid_write,
};
#endif

878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
#ifdef CONFIG_FAULT_INJECTION
static ssize_t proc_fault_inject_read(struct file * file, char __user * buf,
				      size_t count, loff_t *ppos)
{
	struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
	char buffer[PROC_NUMBUF];
	size_t len;
	int make_it_fail;

	if (!task)
		return -ESRCH;
	make_it_fail = task->make_it_fail;
	put_task_struct(task);

	len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail);
893 894

	return simple_read_from_buffer(buf, count, ppos, buffer, len);
895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923
}

static ssize_t proc_fault_inject_write(struct file * file,
			const char __user * buf, size_t count, loff_t *ppos)
{
	struct task_struct *task;
	char buffer[PROC_NUMBUF], *end;
	int make_it_fail;

	if (!capable(CAP_SYS_RESOURCE))
		return -EPERM;
	memset(buffer, 0, sizeof(buffer));
	if (count > sizeof(buffer) - 1)
		count = sizeof(buffer) - 1;
	if (copy_from_user(buffer, buf, count))
		return -EFAULT;
	make_it_fail = simple_strtol(buffer, &end, 0);
	if (*end == '\n')
		end++;
	task = get_proc_task(file->f_dentry->d_inode);
	if (!task)
		return -ESRCH;
	task->make_it_fail = make_it_fail;
	put_task_struct(task);
	if (end - buffer == 0)
		return -EIO;
	return end - buffer;
}

924
static const struct file_operations proc_fault_inject_operations = {
925 926 927 928 929
	.read		= proc_fault_inject_read,
	.write		= proc_fault_inject_write,
};
#endif

I
Ingo Molnar 已提交
930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987
#ifdef CONFIG_SCHED_DEBUG
/*
 * Print out various scheduling related per-task fields:
 */
static int sched_show(struct seq_file *m, void *v)
{
	struct inode *inode = m->private;
	struct task_struct *p;

	WARN_ON(!inode);

	p = get_proc_task(inode);
	if (!p)
		return -ESRCH;
	proc_sched_show_task(p, m);

	put_task_struct(p);

	return 0;
}

static ssize_t
sched_write(struct file *file, const char __user *buf,
	    size_t count, loff_t *offset)
{
	struct inode *inode = file->f_path.dentry->d_inode;
	struct task_struct *p;

	WARN_ON(!inode);

	p = get_proc_task(inode);
	if (!p)
		return -ESRCH;
	proc_sched_set_task(p);

	put_task_struct(p);

	return count;
}

static int sched_open(struct inode *inode, struct file *filp)
{
	int ret;

	ret = single_open(filp, sched_show, NULL);
	if (!ret) {
		struct seq_file *m = filp->private_data;

		m->private = inode;
	}
	return ret;
}

static const struct file_operations proc_pid_sched_operations = {
	.open		= sched_open,
	.read		= seq_read,
	.write		= sched_write,
	.llseek		= seq_lseek,
988
	.release	= single_release,
I
Ingo Molnar 已提交
989 990 991 992
};

#endif

993
static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd)
L
Linus Torvalds 已提交
994 995 996 997 998 999 1000
{
	struct inode *inode = dentry->d_inode;
	int error = -EACCES;

	/* We don't need a base pointer in the /proc filesystem */
	path_release(nd);

1001 1002
	/* Are we allowed to snoop on the tasks file descriptors? */
	if (!proc_fd_access_allowed(inode))
L
Linus Torvalds 已提交
1003 1004 1005 1006 1007
		goto out;

	error = PROC_I(inode)->op.proc_get_link(inode, &nd->dentry, &nd->mnt);
	nd->last_type = LAST_BIND;
out:
1008
	return ERR_PTR(error);
L
Linus Torvalds 已提交
1009 1010 1011 1012 1013 1014
}

static int do_proc_readlink(struct dentry *dentry, struct vfsmount *mnt,
			    char __user *buffer, int buflen)
{
	struct inode * inode;
1015 1016
	char *tmp = (char*)__get_free_page(GFP_TEMPORARY);
	char *path;
L
Linus Torvalds 已提交
1017 1018 1019 1020
	int len;

	if (!tmp)
		return -ENOMEM;
1021

L
Linus Torvalds 已提交
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044
	inode = dentry->d_inode;
	path = d_path(dentry, mnt, tmp, PAGE_SIZE);
	len = PTR_ERR(path);
	if (IS_ERR(path))
		goto out;
	len = tmp + PAGE_SIZE - 1 - path;

	if (len > buflen)
		len = buflen;
	if (copy_to_user(buffer, path, len))
		len = -EFAULT;
 out:
	free_page((unsigned long)tmp);
	return len;
}

static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen)
{
	int error = -EACCES;
	struct inode *inode = dentry->d_inode;
	struct dentry *de;
	struct vfsmount *mnt = NULL;

1045 1046
	/* Are we allowed to snoop on the tasks file descriptors? */
	if (!proc_fd_access_allowed(inode))
L
Linus Torvalds 已提交
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
		goto out;

	error = PROC_I(inode)->op.proc_get_link(inode, &de, &mnt);
	if (error)
		goto out;

	error = do_proc_readlink(de, mnt, buffer, buflen);
	dput(de);
	mntput(mnt);
out:
	return error;
}

1060
static const struct inode_operations proc_pid_link_inode_operations = {
L
Linus Torvalds 已提交
1061
	.readlink	= proc_pid_readlink,
1062 1063
	.follow_link	= proc_pid_follow_link,
	.setattr	= proc_setattr,
L
Linus Torvalds 已提交
1064 1065
};

1066 1067 1068 1069

/* building an inode */

static int task_dumpable(struct task_struct *task)
L
Linus Torvalds 已提交
1070
{
1071 1072
	int dumpable = 0;
	struct mm_struct *mm;
L
Linus Torvalds 已提交
1073

1074 1075 1076
	task_lock(task);
	mm = task->mm;
	if (mm)
1077
		dumpable = get_dumpable(mm);
1078 1079 1080 1081 1082
	task_unlock(task);
	if(dumpable == 1)
		return 1;
	return 0;
}
L
Linus Torvalds 已提交
1083 1084


1085
static struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task)
1086 1087 1088
{
	struct inode * inode;
	struct proc_inode *ei;
L
Linus Torvalds 已提交
1089

1090
	/* We need a new inode */
L
Linus Torvalds 已提交
1091

1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
	inode = new_inode(sb);
	if (!inode)
		goto out;

	/* Common stuff */
	ei = PROC_I(inode);
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	inode->i_op = &proc_def_inode_operations;

	/*
	 * grab the reference to task.
	 */
1104
	ei->pid = get_task_pid(task, PIDTYPE_PID);
1105 1106 1107 1108 1109 1110 1111 1112
	if (!ei->pid)
		goto out_unlock;

	inode->i_uid = 0;
	inode->i_gid = 0;
	if (task_dumpable(task)) {
		inode->i_uid = task->euid;
		inode->i_gid = task->egid;
L
Linus Torvalds 已提交
1113
	}
1114 1115
	security_task_to_inode(task, inode);

L
Linus Torvalds 已提交
1116
out:
1117 1118 1119 1120 1121
	return inode;

out_unlock:
	iput(inode);
	return NULL;
L
Linus Torvalds 已提交
1122 1123
}

1124
static int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
L
Linus Torvalds 已提交
1125 1126
{
	struct inode *inode = dentry->d_inode;
1127 1128
	struct task_struct *task;
	generic_fillattr(inode, stat);
L
Linus Torvalds 已提交
1129

1130 1131 1132 1133 1134 1135 1136 1137 1138
	rcu_read_lock();
	stat->uid = 0;
	stat->gid = 0;
	task = pid_task(proc_pid(inode), PIDTYPE_PID);
	if (task) {
		if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
		    task_dumpable(task)) {
			stat->uid = task->euid;
			stat->gid = task->egid;
L
Linus Torvalds 已提交
1139 1140
		}
	}
1141
	rcu_read_unlock();
A
Alan Cox 已提交
1142
	return 0;
L
Linus Torvalds 已提交
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153
}

/* dentry stuff */

/*
 *	Exceptional case: normally we are not allowed to unhash a busy
 * directory. In this case, however, we can do it - no aliasing problems
 * due to the way we treat inodes.
 *
 * Rewrite the inode's ownerships here because the owning task may have
 * performed a setuid(), etc.
1154 1155 1156 1157 1158 1159 1160
 *
 * Before the /proc/pid/status file was created the only way to read
 * the effective uid of a /process was to stat /proc/pid.  Reading
 * /proc/pid/status is slow enough that procps and other packages
 * kept stating /proc/pid.  To keep the rules in /proc simple I have
 * made this apply to all per process world readable and executable
 * directories.
L
Linus Torvalds 已提交
1161 1162 1163 1164
 */
static int pid_revalidate(struct dentry *dentry, struct nameidata *nd)
{
	struct inode *inode = dentry->d_inode;
1165 1166 1167 1168
	struct task_struct *task = get_proc_task(inode);
	if (task) {
		if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
		    task_dumpable(task)) {
L
Linus Torvalds 已提交
1169 1170 1171 1172 1173 1174
			inode->i_uid = task->euid;
			inode->i_gid = task->egid;
		} else {
			inode->i_uid = 0;
			inode->i_gid = 0;
		}
L
Linus Torvalds 已提交
1175
		inode->i_mode &= ~(S_ISUID | S_ISGID);
L
Linus Torvalds 已提交
1176
		security_task_to_inode(task, inode);
1177
		put_task_struct(task);
L
Linus Torvalds 已提交
1178 1179 1180 1181 1182 1183
		return 1;
	}
	d_drop(dentry);
	return 0;
}

1184
static int pid_delete_dentry(struct dentry * dentry)
1185
{
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200
	/* Is the task we represent dead?
	 * If so, then don't put the dentry on the lru list,
	 * kill it immediately.
	 */
	return !proc_pid(dentry->d_inode)->tasks[PIDTYPE_PID].first;
}

static struct dentry_operations pid_dentry_operations =
{
	.d_revalidate	= pid_revalidate,
	.d_delete	= pid_delete_dentry,
};

/* Lookups */

1201 1202
typedef struct dentry *instantiate_t(struct inode *, struct dentry *,
				struct task_struct *, const void *);
1203

1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
/*
 * Fill a directory entry.
 *
 * If possible create the dcache entry and derive our inode number and
 * file type from dcache entry.
 *
 * Since all of the proc inode numbers are dynamically generated, the inode
 * numbers do not exist until the inode is cache.  This means creating the
 * the dcache entry in readdir is necessary to keep the inode numbers
 * reported by readdir in sync with the inode numbers reported
 * by stat.
 */
1216 1217
static int proc_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
	char *name, int len,
1218
	instantiate_t instantiate, struct task_struct *task, const void *ptr)
1219
{
1220
	struct dentry *child, *dir = filp->f_path.dentry;
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257
	struct inode *inode;
	struct qstr qname;
	ino_t ino = 0;
	unsigned type = DT_UNKNOWN;

	qname.name = name;
	qname.len  = len;
	qname.hash = full_name_hash(name, len);

	child = d_lookup(dir, &qname);
	if (!child) {
		struct dentry *new;
		new = d_alloc(dir, &qname);
		if (new) {
			child = instantiate(dir->d_inode, new, task, ptr);
			if (child)
				dput(new);
			else
				child = new;
		}
	}
	if (!child || IS_ERR(child) || !child->d_inode)
		goto end_instantiate;
	inode = child->d_inode;
	if (inode) {
		ino = inode->i_ino;
		type = inode->i_mode >> 12;
	}
	dput(child);
end_instantiate:
	if (!ino)
		ino = find_inode_number(dir, &qname);
	if (!ino)
		ino = 1;
	return filldir(dirent, name, len, filp->f_pos, ino, type);
}

1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279
static unsigned name_to_int(struct dentry *dentry)
{
	const char *name = dentry->d_name.name;
	int len = dentry->d_name.len;
	unsigned n = 0;

	if (len > 1 && *name == '0')
		goto out;
	while (len-- > 0) {
		unsigned c = *name++ - '0';
		if (c > 9)
			goto out;
		if (n >= (~0U-9)/10)
			goto out;
		n *= 10;
		n += c;
	}
	return n;
out:
	return ~0U;
}

M
Miklos Szeredi 已提交
1280 1281 1282 1283
#define PROC_FDINFO_MAX 64

static int proc_fd_info(struct inode *inode, struct dentry **dentry,
			struct vfsmount **mnt, char *info)
1284 1285 1286 1287 1288
{
	struct task_struct *task = get_proc_task(inode);
	struct files_struct *files = NULL;
	struct file *file;
	int fd = proc_fd(inode);
1289 1290

	if (task) {
1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
		files = get_files_struct(task);
		put_task_struct(task);
	}
	if (files) {
		/*
		 * We are not taking a ref to the file structure, so we must
		 * hold ->file_lock.
		 */
		spin_lock(&files->file_lock);
		file = fcheck_files(files, fd);
		if (file) {
M
Miklos Szeredi 已提交
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311
			if (mnt)
				*mnt = mntget(file->f_path.mnt);
			if (dentry)
				*dentry = dget(file->f_path.dentry);
			if (info)
				snprintf(info, PROC_FDINFO_MAX,
					 "pos:\t%lli\n"
					 "flags:\t0%o\n",
					 (long long) file->f_pos,
					 file->f_flags);
1312 1313 1314
			spin_unlock(&files->file_lock);
			put_files_struct(files);
			return 0;
1315
		}
1316 1317
		spin_unlock(&files->file_lock);
		put_files_struct(files);
1318
	}
1319
	return -ENOENT;
1320 1321
}

M
Miklos Szeredi 已提交
1322 1323 1324 1325 1326 1327
static int proc_fd_link(struct inode *inode, struct dentry **dentry,
			struct vfsmount **mnt)
{
	return proc_fd_info(inode, dentry, mnt, NULL);
}

L
Linus Torvalds 已提交
1328 1329 1330
static int tid_fd_revalidate(struct dentry *dentry, struct nameidata *nd)
{
	struct inode *inode = dentry->d_inode;
1331
	struct task_struct *task = get_proc_task(inode);
1332
	int fd = proc_fd(inode);
L
Linus Torvalds 已提交
1333 1334
	struct files_struct *files;

1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348
	if (task) {
		files = get_files_struct(task);
		if (files) {
			rcu_read_lock();
			if (fcheck_files(files, fd)) {
				rcu_read_unlock();
				put_files_struct(files);
				if (task_dumpable(task)) {
					inode->i_uid = task->euid;
					inode->i_gid = task->egid;
				} else {
					inode->i_uid = 0;
					inode->i_gid = 0;
				}
L
Linus Torvalds 已提交
1349
				inode->i_mode &= ~(S_ISUID | S_ISGID);
1350 1351 1352 1353
				security_task_to_inode(task, inode);
				put_task_struct(task);
				return 1;
			}
1354
			rcu_read_unlock();
L
Linus Torvalds 已提交
1355 1356
			put_files_struct(files);
		}
1357
		put_task_struct(task);
L
Linus Torvalds 已提交
1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368
	}
	d_drop(dentry);
	return 0;
}

static struct dentry_operations tid_fd_dentry_operations =
{
	.d_revalidate	= tid_fd_revalidate,
	.d_delete	= pid_delete_dentry,
};

1369
static struct dentry *proc_fd_instantiate(struct inode *dir,
1370
	struct dentry *dentry, struct task_struct *task, const void *ptr)
L
Linus Torvalds 已提交
1371
{
1372
	unsigned fd = *(const unsigned *)ptr;
1373 1374 1375 1376 1377
	struct file *file;
	struct files_struct *files;
 	struct inode *inode;
 	struct proc_inode *ei;
	struct dentry *error = ERR_PTR(-ENOENT);
L
Linus Torvalds 已提交
1378

1379
	inode = proc_pid_make_inode(dir->i_sb, task);
L
Linus Torvalds 已提交
1380 1381 1382
	if (!inode)
		goto out;
	ei = PROC_I(inode);
1383
	ei->fd = fd;
L
Linus Torvalds 已提交
1384 1385
	files = get_files_struct(task);
	if (!files)
1386
		goto out_iput;
L
Linus Torvalds 已提交
1387
	inode->i_mode = S_IFLNK;
1388 1389 1390 1391 1392 1393

	/*
	 * We are not taking a ref to the file structure, so we must
	 * hold ->file_lock.
	 */
	spin_lock(&files->file_lock);
L
Linus Torvalds 已提交
1394 1395
	file = fcheck_files(files, fd);
	if (!file)
1396
		goto out_unlock;
L
Linus Torvalds 已提交
1397 1398 1399 1400
	if (file->f_mode & 1)
		inode->i_mode |= S_IRUSR | S_IXUSR;
	if (file->f_mode & 2)
		inode->i_mode |= S_IWUSR | S_IXUSR;
1401
	spin_unlock(&files->file_lock);
L
Linus Torvalds 已提交
1402
	put_files_struct(files);
1403

L
Linus Torvalds 已提交
1404 1405 1406 1407 1408
	inode->i_op = &proc_pid_link_inode_operations;
	inode->i_size = 64;
	ei->op.proc_get_link = proc_fd_link;
	dentry->d_op = &tid_fd_dentry_operations;
	d_add(dentry, inode);
1409 1410
	/* Close the race of the process dying before we return the dentry */
	if (tid_fd_revalidate(dentry, NULL))
1411
		error = NULL;
L
Linus Torvalds 已提交
1412

1413 1414 1415
 out:
	return error;
out_unlock:
1416
	spin_unlock(&files->file_lock);
L
Linus Torvalds 已提交
1417
	put_files_struct(files);
1418
out_iput:
L
Linus Torvalds 已提交
1419
	iput(inode);
1420
	goto out;
L
Linus Torvalds 已提交
1421 1422
}

M
Miklos Szeredi 已提交
1423 1424 1425
static struct dentry *proc_lookupfd_common(struct inode *dir,
					   struct dentry *dentry,
					   instantiate_t instantiate)
1426 1427 1428 1429 1430 1431 1432 1433 1434 1435
{
	struct task_struct *task = get_proc_task(dir);
	unsigned fd = name_to_int(dentry);
	struct dentry *result = ERR_PTR(-ENOENT);

	if (!task)
		goto out_no_task;
	if (fd == ~0U)
		goto out;

M
Miklos Szeredi 已提交
1436
	result = instantiate(dir, dentry, task, &fd);
1437 1438 1439 1440 1441 1442
out:
	put_task_struct(task);
out_no_task:
	return result;
}

M
Miklos Szeredi 已提交
1443 1444
static int proc_readfd_common(struct file * filp, void * dirent,
			      filldir_t filldir, instantiate_t instantiate)
1445
{
1446
	struct dentry *dentry = filp->f_path.dentry;
1447 1448 1449 1450 1451 1452
	struct inode *inode = dentry->d_inode;
	struct task_struct *p = get_proc_task(inode);
	unsigned int fd, tid, ino;
	int retval;
	struct files_struct * files;
	struct fdtable *fdt;
L
Linus Torvalds 已提交
1453

1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
	retval = -ENOENT;
	if (!p)
		goto out_no_task;
	retval = 0;
	tid = p->pid;

	fd = filp->f_pos;
	switch (fd) {
		case 0:
			if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0)
				goto out;
			filp->f_pos++;
		case 1:
			ino = parent_ino(dentry);
			if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0)
				goto out;
			filp->f_pos++;
		default:
			files = get_files_struct(p);
			if (!files)
				goto out;
			rcu_read_lock();
			fdt = files_fdtable(files);
			for (fd = filp->f_pos-2;
			     fd < fdt->max_fds;
			     fd++, filp->f_pos++) {
M
Miklos Szeredi 已提交
1480 1481
				char name[PROC_NUMBUF];
				int len;
1482 1483 1484 1485 1486

				if (!fcheck_files(files, fd))
					continue;
				rcu_read_unlock();

M
Miklos Szeredi 已提交
1487 1488 1489 1490
				len = snprintf(name, sizeof(name), "%d", fd);
				if (proc_fill_cache(filp, dirent, filldir,
						    name, len, instantiate,
						    p, &fd) < 0) {
1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
					rcu_read_lock();
					break;
				}
				rcu_read_lock();
			}
			rcu_read_unlock();
			put_files_struct(files);
	}
out:
	put_task_struct(p);
out_no_task:
	return retval;
}

M
Miklos Szeredi 已提交
1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530
static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry,
				    struct nameidata *nd)
{
	return proc_lookupfd_common(dir, dentry, proc_fd_instantiate);
}

static int proc_readfd(struct file *filp, void *dirent, filldir_t filldir)
{
	return proc_readfd_common(filp, dirent, filldir, proc_fd_instantiate);
}

static ssize_t proc_fdinfo_read(struct file *file, char __user *buf,
				      size_t len, loff_t *ppos)
{
	char tmp[PROC_FDINFO_MAX];
	int err = proc_fd_info(file->f_path.dentry->d_inode, NULL, NULL, tmp);
	if (!err)
		err = simple_read_from_buffer(buf, len, ppos, tmp, strlen(tmp));
	return err;
}

static const struct file_operations proc_fdinfo_file_operations = {
	.open		= nonseekable_open,
	.read		= proc_fdinfo_read,
};

1531
static const struct file_operations proc_fd_operations = {
1532 1533
	.read		= generic_read_dir,
	.readdir	= proc_readfd,
L
Linus Torvalds 已提交
1534 1535
};

1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552
/*
 * /proc/pid/fd needs a special permission handler so that a process can still
 * access /proc/self/fd after it has executed a setuid().
 */
static int proc_fd_permission(struct inode *inode, int mask,
				struct nameidata *nd)
{
	int rv;

	rv = generic_permission(inode, mask, NULL);
	if (rv == 0)
		return 0;
	if (task_pid(current) == proc_pid(inode))
		rv = 0;
	return rv;
}

L
Linus Torvalds 已提交
1553 1554 1555
/*
 * proc directories can do almost nothing..
 */
1556
static const struct inode_operations proc_fd_inode_operations = {
L
Linus Torvalds 已提交
1557
	.lookup		= proc_lookupfd,
1558
	.permission	= proc_fd_permission,
1559
	.setattr	= proc_setattr,
L
Linus Torvalds 已提交
1560 1561
};

M
Miklos Szeredi 已提交
1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613
static struct dentry *proc_fdinfo_instantiate(struct inode *dir,
	struct dentry *dentry, struct task_struct *task, const void *ptr)
{
	unsigned fd = *(unsigned *)ptr;
 	struct inode *inode;
 	struct proc_inode *ei;
	struct dentry *error = ERR_PTR(-ENOENT);

	inode = proc_pid_make_inode(dir->i_sb, task);
	if (!inode)
		goto out;
	ei = PROC_I(inode);
	ei->fd = fd;
	inode->i_mode = S_IFREG | S_IRUSR;
	inode->i_fop = &proc_fdinfo_file_operations;
	dentry->d_op = &tid_fd_dentry_operations;
	d_add(dentry, inode);
	/* Close the race of the process dying before we return the dentry */
	if (tid_fd_revalidate(dentry, NULL))
		error = NULL;

 out:
	return error;
}

static struct dentry *proc_lookupfdinfo(struct inode *dir,
					struct dentry *dentry,
					struct nameidata *nd)
{
	return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate);
}

static int proc_readfdinfo(struct file *filp, void *dirent, filldir_t filldir)
{
	return proc_readfd_common(filp, dirent, filldir,
				  proc_fdinfo_instantiate);
}

static const struct file_operations proc_fdinfo_operations = {
	.read		= generic_read_dir,
	.readdir	= proc_readfdinfo,
};

/*
 * proc directories can do almost nothing..
 */
static const struct inode_operations proc_fdinfo_inode_operations = {
	.lookup		= proc_lookupfdinfo,
	.setattr	= proc_setattr,
};


1614
static struct dentry *proc_pident_instantiate(struct inode *dir,
1615
	struct dentry *dentry, struct task_struct *task, const void *ptr)
1616
{
1617
	const struct pid_entry *p = ptr;
1618 1619 1620 1621
	struct inode *inode;
	struct proc_inode *ei;
	struct dentry *error = ERR_PTR(-EINVAL);

1622
	inode = proc_pid_make_inode(dir->i_sb, task);
1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643
	if (!inode)
		goto out;

	ei = PROC_I(inode);
	inode->i_mode = p->mode;
	if (S_ISDIR(inode->i_mode))
		inode->i_nlink = 2;	/* Use getattr to fix if necessary */
	if (p->iop)
		inode->i_op = p->iop;
	if (p->fop)
		inode->i_fop = p->fop;
	ei->op = p->op;
	dentry->d_op = &pid_dentry_operations;
	d_add(dentry, inode);
	/* Close the race of the process dying before we return the dentry */
	if (pid_revalidate(dentry, NULL))
		error = NULL;
out:
	return error;
}

L
Linus Torvalds 已提交
1644 1645
static struct dentry *proc_pident_lookup(struct inode *dir, 
					 struct dentry *dentry,
1646
					 const struct pid_entry *ents,
1647
					 unsigned int nents)
L
Linus Torvalds 已提交
1648 1649
{
	struct inode *inode;
1650
	struct dentry *error;
1651
	struct task_struct *task = get_proc_task(dir);
1652
	const struct pid_entry *p, *last;
L
Linus Torvalds 已提交
1653

1654
	error = ERR_PTR(-ENOENT);
L
Linus Torvalds 已提交
1655 1656
	inode = NULL;

1657 1658
	if (!task)
		goto out_no_task;
L
Linus Torvalds 已提交
1659

1660 1661 1662 1663
	/*
	 * Yes, it does not scale. And it should not. Don't add
	 * new entries into /proc/<tgid>/ without very good reasons.
	 */
1664 1665
	last = &ents[nents - 1];
	for (p = ents; p <= last; p++) {
L
Linus Torvalds 已提交
1666 1667 1668 1669 1670
		if (p->len != dentry->d_name.len)
			continue;
		if (!memcmp(dentry->d_name.name, p->name, p->len))
			break;
	}
1671
	if (p > last)
L
Linus Torvalds 已提交
1672 1673
		goto out;

1674
	error = proc_pident_instantiate(dir, dentry, task, p);
L
Linus Torvalds 已提交
1675
out:
1676 1677
	put_task_struct(task);
out_no_task:
1678
	return error;
L
Linus Torvalds 已提交
1679 1680
}

1681 1682
static int proc_pident_fill_cache(struct file *filp, void *dirent,
	filldir_t filldir, struct task_struct *task, const struct pid_entry *p)
1683 1684 1685 1686 1687
{
	return proc_fill_cache(filp, dirent, filldir, p->name, p->len,
				proc_pident_instantiate, task, p);
}

1688 1689
static int proc_pident_readdir(struct file *filp,
		void *dirent, filldir_t filldir,
1690
		const struct pid_entry *ents, unsigned int nents)
1691 1692 1693
{
	int i;
	int pid;
1694
	struct dentry *dentry = filp->f_path.dentry;
1695 1696
	struct inode *inode = dentry->d_inode;
	struct task_struct *task = get_proc_task(inode);
1697
	const struct pid_entry *p, *last;
1698 1699 1700 1701 1702
	ino_t ino;
	int ret;

	ret = -ENOENT;
	if (!task)
1703
		goto out_no_task;
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729

	ret = 0;
	pid = task->pid;
	i = filp->f_pos;
	switch (i) {
	case 0:
		ino = inode->i_ino;
		if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
			goto out;
		i++;
		filp->f_pos++;
		/* fall through */
	case 1:
		ino = parent_ino(dentry);
		if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
			goto out;
		i++;
		filp->f_pos++;
		/* fall through */
	default:
		i -= 2;
		if (i >= nents) {
			ret = 1;
			goto out;
		}
		p = ents + i;
1730 1731
		last = &ents[nents - 1];
		while (p <= last) {
1732
			if (proc_pident_fill_cache(filp, dirent, filldir, task, p) < 0)
1733 1734 1735 1736 1737 1738 1739 1740
				goto out;
			filp->f_pos++;
			p++;
		}
	}

	ret = 1;
out:
1741 1742
	put_task_struct(task);
out_no_task:
1743
	return ret;
L
Linus Torvalds 已提交
1744 1745
}

1746 1747 1748 1749
#ifdef CONFIG_SECURITY
static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,
				  size_t count, loff_t *ppos)
{
1750
	struct inode * inode = file->f_path.dentry->d_inode;
1751
	char *p = NULL;
1752 1753 1754 1755
	ssize_t length;
	struct task_struct *task = get_proc_task(inode);

	if (!task)
1756
		return -ESRCH;
1757 1758

	length = security_getprocattr(task,
1759
				      (char*)file->f_path.dentry->d_name.name,
1760
				      &p);
1761
	put_task_struct(task);
1762 1763 1764
	if (length > 0)
		length = simple_read_from_buffer(buf, count, ppos, p, length);
	kfree(p);
1765
	return length;
L
Linus Torvalds 已提交
1766 1767
}

1768 1769 1770
static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,
				   size_t count, loff_t *ppos)
{
1771
	struct inode * inode = file->f_path.dentry->d_inode;
1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787
	char *page;
	ssize_t length;
	struct task_struct *task = get_proc_task(inode);

	length = -ESRCH;
	if (!task)
		goto out_no_task;
	if (count > PAGE_SIZE)
		count = PAGE_SIZE;

	/* No partial writes. */
	length = -EINVAL;
	if (*ppos != 0)
		goto out;

	length = -ENOMEM;
1788
	page = (char*)__get_free_page(GFP_TEMPORARY);
1789 1790 1791 1792 1793 1794 1795 1796
	if (!page)
		goto out;

	length = -EFAULT;
	if (copy_from_user(page, buf, count))
		goto out_free;

	length = security_setprocattr(task,
1797
				      (char*)file->f_path.dentry->d_name.name,
1798 1799 1800 1801 1802 1803 1804 1805 1806
				      (void*)page, count);
out_free:
	free_page((unsigned long) page);
out:
	put_task_struct(task);
out_no_task:
	return length;
}

1807
static const struct file_operations proc_pid_attr_operations = {
1808 1809 1810 1811
	.read		= proc_pid_attr_read,
	.write		= proc_pid_attr_write,
};

1812
static const struct pid_entry attr_dir_stuff[] = {
1813 1814 1815 1816 1817 1818
	REG("current",    S_IRUGO|S_IWUGO, pid_attr),
	REG("prev",       S_IRUGO,	   pid_attr),
	REG("exec",       S_IRUGO|S_IWUGO, pid_attr),
	REG("fscreate",   S_IRUGO|S_IWUGO, pid_attr),
	REG("keycreate",  S_IRUGO|S_IWUGO, pid_attr),
	REG("sockcreate", S_IRUGO|S_IWUGO, pid_attr),
1819 1820
};

1821
static int proc_attr_dir_readdir(struct file * filp,
1822 1823 1824
			     void * dirent, filldir_t filldir)
{
	return proc_pident_readdir(filp,dirent,filldir,
1825
				   attr_dir_stuff,ARRAY_SIZE(attr_dir_stuff));
1826 1827
}

1828
static const struct file_operations proc_attr_dir_operations = {
L
Linus Torvalds 已提交
1829
	.read		= generic_read_dir,
1830
	.readdir	= proc_attr_dir_readdir,
L
Linus Torvalds 已提交
1831 1832
};

1833
static struct dentry *proc_attr_dir_lookup(struct inode *dir,
1834 1835
				struct dentry *dentry, struct nameidata *nd)
{
1836 1837
	return proc_pident_lookup(dir, dentry,
				  attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
1838 1839
}

1840
static const struct inode_operations proc_attr_dir_inode_operations = {
1841
	.lookup		= proc_attr_dir_lookup,
1842
	.getattr	= pid_getattr,
1843
	.setattr	= proc_setattr,
L
Linus Torvalds 已提交
1844 1845
};

1846 1847
#endif

1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932
#if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf,
					 size_t count, loff_t *ppos)
{
	struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
	struct mm_struct *mm;
	char buffer[PROC_NUMBUF];
	size_t len;
	int ret;

	if (!task)
		return -ESRCH;

	ret = 0;
	mm = get_task_mm(task);
	if (mm) {
		len = snprintf(buffer, sizeof(buffer), "%08lx\n",
			       ((mm->flags & MMF_DUMP_FILTER_MASK) >>
				MMF_DUMP_FILTER_SHIFT));
		mmput(mm);
		ret = simple_read_from_buffer(buf, count, ppos, buffer, len);
	}

	put_task_struct(task);

	return ret;
}

static ssize_t proc_coredump_filter_write(struct file *file,
					  const char __user *buf,
					  size_t count,
					  loff_t *ppos)
{
	struct task_struct *task;
	struct mm_struct *mm;
	char buffer[PROC_NUMBUF], *end;
	unsigned int val;
	int ret;
	int i;
	unsigned long mask;

	ret = -EFAULT;
	memset(buffer, 0, sizeof(buffer));
	if (count > sizeof(buffer) - 1)
		count = sizeof(buffer) - 1;
	if (copy_from_user(buffer, buf, count))
		goto out_no_task;

	ret = -EINVAL;
	val = (unsigned int)simple_strtoul(buffer, &end, 0);
	if (*end == '\n')
		end++;
	if (end - buffer == 0)
		goto out_no_task;

	ret = -ESRCH;
	task = get_proc_task(file->f_dentry->d_inode);
	if (!task)
		goto out_no_task;

	ret = end - buffer;
	mm = get_task_mm(task);
	if (!mm)
		goto out_no_mm;

	for (i = 0, mask = 1; i < MMF_DUMP_FILTER_BITS; i++, mask <<= 1) {
		if (val & mask)
			set_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
		else
			clear_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
	}

	mmput(mm);
 out_no_mm:
	put_task_struct(task);
 out_no_task:
	return ret;
}

static const struct file_operations proc_coredump_filter_operations = {
	.read		= proc_coredump_filter_read,
	.write		= proc_coredump_filter_write,
};
#endif

1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950
/*
 * /proc/self:
 */
static int proc_self_readlink(struct dentry *dentry, char __user *buffer,
			      int buflen)
{
	char tmp[PROC_NUMBUF];
	sprintf(tmp, "%d", current->tgid);
	return vfs_readlink(dentry,buffer,buflen,tmp);
}

static void *proc_self_follow_link(struct dentry *dentry, struct nameidata *nd)
{
	char tmp[PROC_NUMBUF];
	sprintf(tmp, "%d", current->tgid);
	return ERR_PTR(vfs_follow_link(nd,tmp));
}

1951
static const struct inode_operations proc_self_inode_operations = {
1952 1953 1954 1955
	.readlink	= proc_self_readlink,
	.follow_link	= proc_self_follow_link,
};

1956 1957 1958 1959 1960 1961 1962
/*
 * proc base
 *
 * These are the directory entries in the root directory of /proc
 * that properly belong to the /proc filesystem, as they describe
 * describe something that is process related.
 */
1963
static const struct pid_entry proc_base_stuff[] = {
1964
	NOD("self", S_IFLNK|S_IRWXUGO,
1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990
		&proc_self_inode_operations, NULL, {}),
};

/*
 *	Exceptional case: normally we are not allowed to unhash a busy
 * directory. In this case, however, we can do it - no aliasing problems
 * due to the way we treat inodes.
 */
static int proc_base_revalidate(struct dentry *dentry, struct nameidata *nd)
{
	struct inode *inode = dentry->d_inode;
	struct task_struct *task = get_proc_task(inode);
	if (task) {
		put_task_struct(task);
		return 1;
	}
	d_drop(dentry);
	return 0;
}

static struct dentry_operations proc_base_dentry_operations =
{
	.d_revalidate	= proc_base_revalidate,
	.d_delete	= pid_delete_dentry,
};

1991
static struct dentry *proc_base_instantiate(struct inode *dir,
1992
	struct dentry *dentry, struct task_struct *task, const void *ptr)
1993
{
1994
	const struct pid_entry *p = ptr;
1995 1996
	struct inode *inode;
	struct proc_inode *ei;
1997
	struct dentry *error = ERR_PTR(-EINVAL);
1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011

	/* Allocate the inode */
	error = ERR_PTR(-ENOMEM);
	inode = new_inode(dir->i_sb);
	if (!inode)
		goto out;

	/* Initialize the inode */
	ei = PROC_I(inode);
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;

	/*
	 * grab the reference to the task.
	 */
2012
	ei->pid = get_task_pid(task, PIDTYPE_PID);
2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037
	if (!ei->pid)
		goto out_iput;

	inode->i_uid = 0;
	inode->i_gid = 0;
	inode->i_mode = p->mode;
	if (S_ISDIR(inode->i_mode))
		inode->i_nlink = 2;
	if (S_ISLNK(inode->i_mode))
		inode->i_size = 64;
	if (p->iop)
		inode->i_op = p->iop;
	if (p->fop)
		inode->i_fop = p->fop;
	ei->op = p->op;
	dentry->d_op = &proc_base_dentry_operations;
	d_add(dentry, inode);
	error = NULL;
out:
	return error;
out_iput:
	iput(inode);
	goto out;
}

2038 2039 2040 2041
static struct dentry *proc_base_lookup(struct inode *dir, struct dentry *dentry)
{
	struct dentry *error;
	struct task_struct *task = get_proc_task(dir);
2042
	const struct pid_entry *p, *last;
2043 2044 2045 2046 2047 2048 2049

	error = ERR_PTR(-ENOENT);

	if (!task)
		goto out_no_task;

	/* Lookup the directory entry */
2050 2051
	last = &proc_base_stuff[ARRAY_SIZE(proc_base_stuff) - 1];
	for (p = proc_base_stuff; p <= last; p++) {
2052 2053 2054 2055 2056
		if (p->len != dentry->d_name.len)
			continue;
		if (!memcmp(dentry->d_name.name, p->name, p->len))
			break;
	}
2057
	if (p > last)
2058 2059 2060 2061 2062 2063 2064 2065 2066 2067
		goto out;

	error = proc_base_instantiate(dir, dentry, task, p);

out:
	put_task_struct(task);
out_no_task:
	return error;
}

2068 2069
static int proc_base_fill_cache(struct file *filp, void *dirent,
	filldir_t filldir, struct task_struct *task, const struct pid_entry *p)
2070 2071 2072 2073 2074
{
	return proc_fill_cache(filp, dirent, filldir, p->name, p->len,
				proc_base_instantiate, task, p);
}

2075 2076 2077 2078
#ifdef CONFIG_TASK_IO_ACCOUNTING
static int proc_pid_io_accounting(struct task_struct *task, char *buffer)
{
	return sprintf(buffer,
2079
#ifdef CONFIG_TASK_XACCT
2080 2081 2082 2083
			"rchar: %llu\n"
			"wchar: %llu\n"
			"syscr: %llu\n"
			"syscw: %llu\n"
2084
#endif
2085 2086 2087
			"read_bytes: %llu\n"
			"write_bytes: %llu\n"
			"cancelled_write_bytes: %llu\n",
2088
#ifdef CONFIG_TASK_XACCT
2089 2090 2091 2092
			(unsigned long long)task->rchar,
			(unsigned long long)task->wchar,
			(unsigned long long)task->syscr,
			(unsigned long long)task->syscw,
2093
#endif
2094 2095 2096 2097 2098 2099
			(unsigned long long)task->ioac.read_bytes,
			(unsigned long long)task->ioac.write_bytes,
			(unsigned long long)task->ioac.cancelled_write_bytes);
}
#endif

2100 2101 2102
/*
 * Thread groups
 */
2103
static const struct file_operations proc_task_operations;
2104
static const struct inode_operations proc_task_inode_operations;
2105

2106
static const struct pid_entry tgid_base_stuff[] = {
2107 2108
	DIR("task",       S_IRUGO|S_IXUGO, task),
	DIR("fd",         S_IRUSR|S_IXUSR, fd),
M
Miklos Szeredi 已提交
2109
	DIR("fdinfo",     S_IRUSR|S_IXUSR, fdinfo),
2110
	REG("environ",    S_IRUSR, environ),
2111 2112
	INF("auxv",       S_IRUSR, pid_auxv),
	INF("status",     S_IRUGO, pid_status),
I
Ingo Molnar 已提交
2113 2114 2115
#ifdef CONFIG_SCHED_DEBUG
	REG("sched",      S_IRUGO|S_IWUSR, pid_sched),
#endif
2116 2117 2118 2119
	INF("cmdline",    S_IRUGO, pid_cmdline),
	INF("stat",       S_IRUGO, tgid_stat),
	INF("statm",      S_IRUGO, pid_statm),
	REG("maps",       S_IRUGO, maps),
2120
#ifdef CONFIG_NUMA
2121
	REG("numa_maps",  S_IRUGO, numa_maps),
2122
#endif
2123 2124 2125 2126 2127 2128
	REG("mem",        S_IRUSR|S_IWUSR, mem),
	LNK("cwd",        cwd),
	LNK("root",       root),
	LNK("exe",        exe),
	REG("mounts",     S_IRUGO, mounts),
	REG("mountstats", S_IRUSR, mountstats),
2129
#ifdef CONFIG_MMU
2130
	REG("clear_refs", S_IWUSR, clear_refs),
2131
	REG("smaps",      S_IRUGO, smaps),
2132 2133
#endif
#ifdef CONFIG_SECURITY
2134
	DIR("attr",       S_IRUGO|S_IXUGO, attr_dir),
2135 2136
#endif
#ifdef CONFIG_KALLSYMS
2137
	INF("wchan",      S_IRUGO, pid_wchan),
2138 2139
#endif
#ifdef CONFIG_SCHEDSTATS
2140
	INF("schedstat",  S_IRUGO, pid_schedstat),
2141
#endif
2142
#ifdef CONFIG_PROC_PID_CPUSET
2143
	REG("cpuset",     S_IRUGO, cpuset),
2144 2145 2146
#endif
#ifdef CONFIG_CGROUPS
	REG("cgroup",  S_IRUGO, cgroup),
2147
#endif
2148 2149
	INF("oom_score",  S_IRUGO, oom_score),
	REG("oom_adj",    S_IRUGO|S_IWUSR, oom_adjust),
2150
#ifdef CONFIG_AUDITSYSCALL
2151
	REG("loginuid",   S_IWUSR|S_IRUGO, loginuid),
2152
#endif
2153 2154 2155
#ifdef CONFIG_FAULT_INJECTION
	REG("make-it-fail", S_IRUGO|S_IWUSR, fault_inject),
#endif
2156 2157 2158
#if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
	REG("coredump_filter", S_IRUGO|S_IWUSR, coredump_filter),
#endif
2159 2160 2161
#ifdef CONFIG_TASK_IO_ACCOUNTING
	INF("io",	S_IRUGO, pid_io_accounting),
#endif
2162
};
L
Linus Torvalds 已提交
2163

2164
static int proc_tgid_base_readdir(struct file * filp,
L
Linus Torvalds 已提交
2165 2166 2167
			     void * dirent, filldir_t filldir)
{
	return proc_pident_readdir(filp,dirent,filldir,
2168
				   tgid_base_stuff,ARRAY_SIZE(tgid_base_stuff));
L
Linus Torvalds 已提交
2169 2170
}

2171
static const struct file_operations proc_tgid_base_operations = {
L
Linus Torvalds 已提交
2172
	.read		= generic_read_dir,
2173
	.readdir	= proc_tgid_base_readdir,
L
Linus Torvalds 已提交
2174 2175
};

2176
static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
2177 2178
	return proc_pident_lookup(dir, dentry,
				  tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
L
Linus Torvalds 已提交
2179 2180
}

2181
static const struct inode_operations proc_tgid_base_inode_operations = {
2182
	.lookup		= proc_tgid_base_lookup,
2183
	.getattr	= pid_getattr,
2184
	.setattr	= proc_setattr,
L
Linus Torvalds 已提交
2185 2186 2187
};

/**
2188 2189 2190 2191 2192 2193 2194 2195 2196
 * proc_flush_task -  Remove dcache entries for @task from the /proc dcache.
 *
 * @task: task that should be flushed.
 *
 * Looks in the dcache for
 * /proc/@pid
 * /proc/@tgid/task/@pid
 * if either directory is present flushes it and all of it'ts children
 * from the dcache.
L
Linus Torvalds 已提交
2197
 *
2198 2199 2200 2201 2202
 * It is safe and reasonable to cache /proc entries for a task until
 * that task exits.  After that they just clog up the dcache with
 * useless entries, possibly causing useful dcache entries to be
 * flushed instead.  This routine is proved to flush those useless
 * dcache entries at process exit time.
L
Linus Torvalds 已提交
2203
 *
2204 2205 2206
 * NOTE: This routine is just an optimization so it does not guarantee
 *       that no dcache entries will exist at process exit time it
 *       just makes it very unlikely that any will persist.
L
Linus Torvalds 已提交
2207
 */
2208
static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
L
Linus Torvalds 已提交
2209
{
2210
	struct dentry *dentry, *leader, *dir;
2211
	char buf[PROC_NUMBUF];
2212 2213 2214
	struct qstr name;

	name.name = buf;
2215 2216
	name.len = snprintf(buf, sizeof(buf), "%d", pid);
	dentry = d_hash_and_lookup(mnt->mnt_root, &name);
2217 2218 2219 2220 2221
	if (dentry) {
		shrink_dcache_parent(dentry);
		d_drop(dentry);
		dput(dentry);
	}
L
Linus Torvalds 已提交
2222

2223
	if (tgid == 0)
2224
		goto out;
L
Linus Torvalds 已提交
2225

2226
	name.name = buf;
2227 2228
	name.len = snprintf(buf, sizeof(buf), "%d", tgid);
	leader = d_hash_and_lookup(mnt->mnt_root, &name);
2229 2230
	if (!leader)
		goto out;
L
Linus Torvalds 已提交
2231

2232 2233 2234 2235 2236 2237 2238
	name.name = "task";
	name.len = strlen(name.name);
	dir = d_hash_and_lookup(leader, &name);
	if (!dir)
		goto out_put_leader;

	name.name = buf;
2239
	name.len = snprintf(buf, sizeof(buf), "%d", pid);
2240 2241 2242 2243 2244
	dentry = d_hash_and_lookup(dir, &name);
	if (dentry) {
		shrink_dcache_parent(dentry);
		d_drop(dentry);
		dput(dentry);
L
Linus Torvalds 已提交
2245
	}
2246 2247 2248 2249 2250 2251

	dput(dir);
out_put_leader:
	dput(leader);
out:
	return;
L
Linus Torvalds 已提交
2252 2253
}

2254 2255 2256 2257 2258 2259 2260 2261
/*
 * when flushing dentries from proc one need to flush them from global
 * proc (proc_mnt) and from all the namespaces' procs this task was seen
 * in. this call is supposed to make all this job.
 */

void proc_flush_task(struct task_struct *task)
{
2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277
	int i, leader;
	struct pid *pid, *tgid;
	struct upid *upid;

	leader = thread_group_leader(task);
	proc_flush_task_mnt(proc_mnt, task->pid, leader ? task->tgid : 0);
	pid = task_pid(task);
	if (pid->level == 0)
		return;

	tgid = task_tgid(task);
	for (i = 1; i <= pid->level; i++) {
		upid = &pid->numbers[i];
		proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr,
				leader ? 0 : tgid->numbers[i].nr);
	}
2278 2279
}

2280 2281
static struct dentry *proc_pid_instantiate(struct inode *dir,
					   struct dentry * dentry,
2282
					   struct task_struct *task, const void *ptr)
2283 2284 2285 2286
{
	struct dentry *error = ERR_PTR(-ENOENT);
	struct inode *inode;

2287
	inode = proc_pid_make_inode(dir->i_sb, task);
2288 2289 2290 2291 2292 2293 2294
	if (!inode)
		goto out;

	inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
	inode->i_op = &proc_tgid_base_inode_operations;
	inode->i_fop = &proc_tgid_base_operations;
	inode->i_flags|=S_IMMUTABLE;
M
Miklos Szeredi 已提交
2295
	inode->i_nlink = 5;
2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309
#ifdef CONFIG_SECURITY
	inode->i_nlink += 1;
#endif

	dentry->d_op = &pid_dentry_operations;

	d_add(dentry, inode);
	/* Close the race of the process dying before we return the dentry */
	if (pid_revalidate(dentry, NULL))
		error = NULL;
out:
	return error;
}

L
Linus Torvalds 已提交
2310 2311
struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
{
2312
	struct dentry *result = ERR_PTR(-ENOENT);
L
Linus Torvalds 已提交
2313 2314 2315
	struct task_struct *task;
	unsigned tgid;

2316 2317 2318 2319
	result = proc_base_lookup(dir, dentry);
	if (!IS_ERR(result) || PTR_ERR(result) != -ENOENT)
		goto out;

L
Linus Torvalds 已提交
2320 2321 2322 2323
	tgid = name_to_int(dentry);
	if (tgid == ~0U)
		goto out;

2324
	rcu_read_lock();
L
Linus Torvalds 已提交
2325 2326 2327
	task = find_task_by_pid(tgid);
	if (task)
		get_task_struct(task);
2328
	rcu_read_unlock();
L
Linus Torvalds 已提交
2329 2330 2331
	if (!task)
		goto out;

2332
	result = proc_pid_instantiate(dir, dentry, task, NULL);
L
Linus Torvalds 已提交
2333 2334
	put_task_struct(task);
out:
2335
	return result;
L
Linus Torvalds 已提交
2336 2337 2338
}

/*
2339
 * Find the first task with tgid >= tgid
2340
 *
L
Linus Torvalds 已提交
2341
 */
2342
static struct task_struct *next_tgid(unsigned int tgid)
L
Linus Torvalds 已提交
2343
{
2344 2345
	struct task_struct *task;
	struct pid *pid;
L
Linus Torvalds 已提交
2346

2347
	rcu_read_lock();
2348 2349
retry:
	task = NULL;
2350
	pid = find_ge_pid(tgid, &init_pid_ns);
2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368
	if (pid) {
		tgid = pid->nr + 1;
		task = pid_task(pid, PIDTYPE_PID);
		/* What we to know is if the pid we have find is the
		 * pid of a thread_group_leader.  Testing for task
		 * being a thread_group_leader is the obvious thing
		 * todo but there is a window when it fails, due to
		 * the pid transfer logic in de_thread.
		 *
		 * So we perform the straight forward test of seeing
		 * if the pid we have found is the pid of a thread
		 * group leader, and don't worry if the task we have
		 * found doesn't happen to be a thread group leader.
		 * As we don't care in the case of readdir.
		 */
		if (!task || !has_group_leader_pid(task))
			goto retry;
		get_task_struct(task);
2369
	}
2370
	rcu_read_unlock();
2371
	return task;
L
Linus Torvalds 已提交
2372 2373
}

2374
#define TGID_OFFSET (FIRST_PROCESS_ENTRY + ARRAY_SIZE(proc_base_stuff))
2375

2376 2377 2378 2379 2380 2381 2382 2383 2384
static int proc_pid_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
	struct task_struct *task, int tgid)
{
	char name[PROC_NUMBUF];
	int len = snprintf(name, sizeof(name), "%d", tgid);
	return proc_fill_cache(filp, dirent, filldir, name, len,
				proc_pid_instantiate, task, NULL);
}

L
Linus Torvalds 已提交
2385 2386 2387 2388
/* for the /proc/ directory itself, after non-process stuff has been done */
int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir)
{
	unsigned int nr = filp->f_pos - FIRST_PROCESS_ENTRY;
2389
	struct task_struct *reaper = get_proc_task(filp->f_path.dentry->d_inode);
2390 2391
	struct task_struct *task;
	int tgid;
L
Linus Torvalds 已提交
2392

2393 2394 2395
	if (!reaper)
		goto out_no_task;

2396
	for (; nr < ARRAY_SIZE(proc_base_stuff); filp->f_pos++, nr++) {
2397
		const struct pid_entry *p = &proc_base_stuff[nr];
2398
		if (proc_base_fill_cache(filp, dirent, filldir, reaper, p) < 0)
2399
			goto out;
L
Linus Torvalds 已提交
2400 2401
	}

2402 2403
	tgid = filp->f_pos - TGID_OFFSET;
	for (task = next_tgid(tgid);
2404
	     task;
2405
	     put_task_struct(task), task = next_tgid(tgid + 1)) {
2406
		tgid = task->pid;
2407
		filp->f_pos = tgid + TGID_OFFSET;
2408
		if (proc_pid_fill_cache(filp, dirent, filldir, task, tgid) < 0) {
2409
			put_task_struct(task);
2410
			goto out;
L
Linus Torvalds 已提交
2411
		}
2412
	}
2413 2414
	filp->f_pos = PID_MAX_LIMIT + TGID_OFFSET;
out:
2415 2416
	put_task_struct(reaper);
out_no_task:
2417 2418
	return 0;
}
L
Linus Torvalds 已提交
2419

2420 2421 2422
/*
 * Tasks
 */
2423
static const struct pid_entry tid_base_stuff[] = {
2424
	DIR("fd",        S_IRUSR|S_IXUSR, fd),
M
Miklos Szeredi 已提交
2425
	DIR("fdinfo",    S_IRUSR|S_IXUSR, fdinfo),
2426
	REG("environ",   S_IRUSR, environ),
2427 2428
	INF("auxv",      S_IRUSR, pid_auxv),
	INF("status",    S_IRUGO, pid_status),
I
Ingo Molnar 已提交
2429 2430 2431
#ifdef CONFIG_SCHED_DEBUG
	REG("sched",     S_IRUGO|S_IWUSR, pid_sched),
#endif
2432 2433 2434 2435
	INF("cmdline",   S_IRUGO, pid_cmdline),
	INF("stat",      S_IRUGO, tid_stat),
	INF("statm",     S_IRUGO, pid_statm),
	REG("maps",      S_IRUGO, maps),
2436
#ifdef CONFIG_NUMA
2437
	REG("numa_maps", S_IRUGO, numa_maps),
2438
#endif
2439 2440 2441 2442 2443
	REG("mem",       S_IRUSR|S_IWUSR, mem),
	LNK("cwd",       cwd),
	LNK("root",      root),
	LNK("exe",       exe),
	REG("mounts",    S_IRUGO, mounts),
2444
#ifdef CONFIG_MMU
2445
	REG("clear_refs", S_IWUSR, clear_refs),
2446
	REG("smaps",     S_IRUGO, smaps),
2447 2448
#endif
#ifdef CONFIG_SECURITY
2449
	DIR("attr",      S_IRUGO|S_IXUGO, attr_dir),
2450 2451
#endif
#ifdef CONFIG_KALLSYMS
2452
	INF("wchan",     S_IRUGO, pid_wchan),
2453 2454
#endif
#ifdef CONFIG_SCHEDSTATS
2455
	INF("schedstat", S_IRUGO, pid_schedstat),
2456
#endif
2457
#ifdef CONFIG_PROC_PID_CPUSET
2458
	REG("cpuset",    S_IRUGO, cpuset),
2459 2460 2461
#endif
#ifdef CONFIG_CGROUPS
	REG("cgroup",  S_IRUGO, cgroup),
2462
#endif
2463 2464
	INF("oom_score", S_IRUGO, oom_score),
	REG("oom_adj",   S_IRUGO|S_IWUSR, oom_adjust),
2465
#ifdef CONFIG_AUDITSYSCALL
2466
	REG("loginuid",  S_IWUSR|S_IRUGO, loginuid),
2467
#endif
2468 2469 2470
#ifdef CONFIG_FAULT_INJECTION
	REG("make-it-fail", S_IRUGO|S_IWUSR, fault_inject),
#endif
2471 2472 2473 2474 2475 2476 2477 2478 2479 2480
};

static int proc_tid_base_readdir(struct file * filp,
			     void * dirent, filldir_t filldir)
{
	return proc_pident_readdir(filp,dirent,filldir,
				   tid_base_stuff,ARRAY_SIZE(tid_base_stuff));
}

static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
2481 2482
	return proc_pident_lookup(dir, dentry,
				  tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
2483 2484
}

2485
static const struct file_operations proc_tid_base_operations = {
2486 2487 2488 2489
	.read		= generic_read_dir,
	.readdir	= proc_tid_base_readdir,
};

2490
static const struct inode_operations proc_tid_base_inode_operations = {
2491 2492 2493 2494 2495
	.lookup		= proc_tid_base_lookup,
	.getattr	= pid_getattr,
	.setattr	= proc_setattr,
};

2496
static struct dentry *proc_task_instantiate(struct inode *dir,
2497
	struct dentry *dentry, struct task_struct *task, const void *ptr)
2498 2499 2500
{
	struct dentry *error = ERR_PTR(-ENOENT);
	struct inode *inode;
2501
	inode = proc_pid_make_inode(dir->i_sb, task);
2502 2503 2504 2505 2506 2507 2508

	if (!inode)
		goto out;
	inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
	inode->i_op = &proc_tid_base_inode_operations;
	inode->i_fop = &proc_tid_base_operations;
	inode->i_flags|=S_IMMUTABLE;
M
Miklos Szeredi 已提交
2509
	inode->i_nlink = 4;
2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523
#ifdef CONFIG_SECURITY
	inode->i_nlink += 1;
#endif

	dentry->d_op = &pid_dentry_operations;

	d_add(dentry, inode);
	/* Close the race of the process dying before we return the dentry */
	if (pid_revalidate(dentry, NULL))
		error = NULL;
out:
	return error;
}

2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547
static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
{
	struct dentry *result = ERR_PTR(-ENOENT);
	struct task_struct *task;
	struct task_struct *leader = get_proc_task(dir);
	unsigned tid;

	if (!leader)
		goto out_no_task;

	tid = name_to_int(dentry);
	if (tid == ~0U)
		goto out;

	rcu_read_lock();
	task = find_task_by_pid(tid);
	if (task)
		get_task_struct(task);
	rcu_read_unlock();
	if (!task)
		goto out;
	if (leader->tgid != task->tgid)
		goto out_drop_task;

2548
	result = proc_task_instantiate(dir, dentry, task, NULL);
2549 2550 2551 2552 2553 2554 2555 2556
out_drop_task:
	put_task_struct(task);
out:
	put_task_struct(leader);
out_no_task:
	return result;
}

2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568
/*
 * Find the first tid of a thread group to return to user space.
 *
 * Usually this is just the thread group leader, but if the users
 * buffer was too small or there was a seek into the middle of the
 * directory we have more work todo.
 *
 * In the case of a short read we start with find_task_by_pid.
 *
 * In the case of a seek we start with the leader and walk nr
 * threads past it.
 */
2569 2570
static struct task_struct *first_tid(struct task_struct *leader,
					int tid, int nr)
2571
{
O
Oleg Nesterov 已提交
2572
	struct task_struct *pos;
L
Linus Torvalds 已提交
2573

2574
	rcu_read_lock();
2575 2576 2577
	/* Attempt to start with the pid of a thread */
	if (tid && (nr > 0)) {
		pos = find_task_by_pid(tid);
O
Oleg Nesterov 已提交
2578 2579
		if (pos && (pos->group_leader == leader))
			goto found;
2580
	}
L
Linus Torvalds 已提交
2581

2582
	/* If nr exceeds the number of threads there is nothing todo */
O
Oleg Nesterov 已提交
2583 2584 2585
	pos = NULL;
	if (nr && nr >= get_nr_threads(leader))
		goto out;
L
Linus Torvalds 已提交
2586

O
Oleg Nesterov 已提交
2587 2588
	/* If we haven't found our starting place yet start
	 * with the leader and walk nr threads forward.
2589
	 */
O
Oleg Nesterov 已提交
2590 2591 2592 2593 2594 2595
	for (pos = leader; nr > 0; --nr) {
		pos = next_thread(pos);
		if (pos == leader) {
			pos = NULL;
			goto out;
		}
L
Linus Torvalds 已提交
2596
	}
O
Oleg Nesterov 已提交
2597 2598 2599
found:
	get_task_struct(pos);
out:
2600
	rcu_read_unlock();
2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611
	return pos;
}

/*
 * Find the next thread in the thread list.
 * Return NULL if there is an error or no next thread.
 *
 * The reference to the input task_struct is released.
 */
static struct task_struct *next_tid(struct task_struct *start)
{
O
Oleg Nesterov 已提交
2612
	struct task_struct *pos = NULL;
2613
	rcu_read_lock();
O
Oleg Nesterov 已提交
2614
	if (pid_alive(start)) {
2615
		pos = next_thread(start);
O
Oleg Nesterov 已提交
2616 2617 2618 2619 2620
		if (thread_group_leader(pos))
			pos = NULL;
		else
			get_task_struct(pos);
	}
2621
	rcu_read_unlock();
2622 2623
	put_task_struct(start);
	return pos;
L
Linus Torvalds 已提交
2624 2625
}

2626 2627 2628 2629 2630 2631 2632 2633 2634
static int proc_task_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
	struct task_struct *task, int tid)
{
	char name[PROC_NUMBUF];
	int len = snprintf(name, sizeof(name), "%d", tid);
	return proc_fill_cache(filp, dirent, filldir, name, len,
				proc_task_instantiate, task, NULL);
}

L
Linus Torvalds 已提交
2635 2636 2637
/* for the /proc/TGID/task/ directories */
static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldir)
{
2638
	struct dentry *dentry = filp->f_path.dentry;
L
Linus Torvalds 已提交
2639
	struct inode *inode = dentry->d_inode;
2640
	struct task_struct *leader = NULL;
2641
	struct task_struct *task;
L
Linus Torvalds 已提交
2642 2643
	int retval = -ENOENT;
	ino_t ino;
2644
	int tid;
L
Linus Torvalds 已提交
2645 2646
	unsigned long pos = filp->f_pos;  /* avoiding "long long" filp->f_pos */

2647 2648 2649 2650 2651 2652 2653 2654 2655 2656
	task = get_proc_task(inode);
	if (!task)
		goto out_no_task;
	rcu_read_lock();
	if (pid_alive(task)) {
		leader = task->group_leader;
		get_task_struct(leader);
	}
	rcu_read_unlock();
	put_task_struct(task);
2657 2658
	if (!leader)
		goto out_no_task;
L
Linus Torvalds 已提交
2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675
	retval = 0;

	switch (pos) {
	case 0:
		ino = inode->i_ino;
		if (filldir(dirent, ".", 1, pos, ino, DT_DIR) < 0)
			goto out;
		pos++;
		/* fall through */
	case 1:
		ino = parent_ino(dentry);
		if (filldir(dirent, "..", 2, pos, ino, DT_DIR) < 0)
			goto out;
		pos++;
		/* fall through */
	}

2676 2677 2678
	/* f_version caches the tgid value that the last readdir call couldn't
	 * return. lseek aka telldir automagically resets f_version to 0.
	 */
2679
	tid = (int)filp->f_version;
2680 2681 2682 2683 2684
	filp->f_version = 0;
	for (task = first_tid(leader, tid, pos - 2);
	     task;
	     task = next_tid(task), pos++) {
		tid = task->pid;
2685
		if (proc_task_fill_cache(filp, dirent, filldir, task, tid) < 0) {
2686 2687
			/* returning this tgid failed, save it as the first
			 * pid for the next readir call */
2688
			filp->f_version = (u64)tid;
2689
			put_task_struct(task);
L
Linus Torvalds 已提交
2690
			break;
2691
		}
L
Linus Torvalds 已提交
2692 2693 2694
	}
out:
	filp->f_pos = pos;
2695 2696
	put_task_struct(leader);
out_no_task:
L
Linus Torvalds 已提交
2697 2698
	return retval;
}
2699 2700 2701 2702

static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
{
	struct inode *inode = dentry->d_inode;
2703
	struct task_struct *p = get_proc_task(inode);
2704 2705
	generic_fillattr(inode, stat);

2706 2707 2708 2709 2710
	if (p) {
		rcu_read_lock();
		stat->nlink += get_nr_threads(p);
		rcu_read_unlock();
		put_task_struct(p);
2711 2712 2713 2714
	}

	return 0;
}
2715

2716
static const struct inode_operations proc_task_inode_operations = {
2717 2718 2719 2720 2721
	.lookup		= proc_task_lookup,
	.getattr	= proc_task_getattr,
	.setattr	= proc_setattr,
};

2722
static const struct file_operations proc_task_operations = {
2723 2724 2725
	.read		= generic_read_dir,
	.readdir	= proc_task_readdir,
};