[linux-2.6-block.git] / fs / proc / fd.c

#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/dcache.h>
#include <linux/path.h>
#include <linux/fdtable.h>
#include <linux/namei.h>
#include <linux/pid.h>
#include <linux/security.h>
#include <linux/file.h>
#include <linux/seq_file.h>
#include <linux/fs.h>

#include <linux/proc_fs.h>

#include "../mount.h"
#include "internal.h"
#include "fd.h"

static int seq_show(struct seq_file *m, void *v)
{
	struct files_struct *files = NULL;
	int f_flags = 0, ret = -ENOENT;
	struct file *file = NULL;
	struct task_struct *task;

	task = get_proc_task(m->private);
	if (!task)
		return -ENOENT;

	files = get_files_struct(task);
	put_task_struct(task);

	if (files) {
		int fd = proc_fd(m->private);

		spin_lock(&files->file_lock);
		file = fcheck_files(files, fd);
		if (file) {
			struct fdtable *fdt = files_fdtable(files);

			f_flags = file->f_flags;
			if (close_on_exec(fd, fdt))
				f_flags |= O_CLOEXEC;

			get_file(file);
			ret = 0;
		}
		spin_unlock(&files->file_lock);
		put_files_struct(files);
	}

	if (ret)
		return ret;

	seq_printf(m, "pos:\t%lli\nflags:\t0%o\nmnt_id:\t%i\n",
		   (long long)file->f_pos, f_flags,
		   real_mount(file->f_path.mnt)->mnt_id);

	show_fd_locks(m, file, files);
	if (seq_has_overflowed(m))
		goto out;

	if (file->f_op->show_fdinfo)
		file->f_op->show_fdinfo(m, file);

out:
	fput(file);
	return 0;
}

static int seq_fdinfo_open(struct inode *inode, struct file *file)
{
	return single_open(file, seq_show, inode);
}

static const struct file_operations proc_fdinfo_file_operations = {
	.open		= seq_fdinfo_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static int tid_fd_revalidate(struct dentry *dentry, unsigned int flags)
{
	struct files_struct *files;
	struct task_struct *task;
	const struct cred *cred;
	struct inode *inode;
	int fd;

	if (flags & LOOKUP_RCU)
		return -ECHILD;

	inode = d_inode(dentry);
	task = get_proc_task(inode);
	fd = proc_fd(inode);

	if (task) {
		files = get_files_struct(task);
		if (files) {
			struct file *file;

			rcu_read_lock();
			file = fcheck_files(files, fd);
			if (file) {
				unsigned f_mode = file->f_mode;

				rcu_read_unlock();
				put_files_struct(files);

				if (task_dumpable(task)) {
					rcu_read_lock();
					cred = __task_cred(task);
					inode->i_uid = cred->euid;
					inode->i_gid = cred->egid;
					rcu_read_unlock();
				} else {
					inode->i_uid = GLOBAL_ROOT_UID;
					inode->i_gid = GLOBAL_ROOT_GID;
				}

				if (S_ISLNK(inode->i_mode)) {
					unsigned i_mode = S_IFLNK;
					if (f_mode & FMODE_READ)
						i_mode |= S_IRUSR | S_IXUSR;
					if (f_mode & FMODE_WRITE)
						i_mode |= S_IWUSR | S_IXUSR;
					inode->i_mode = i_mode;
				}

				security_task_to_inode(task, inode);
				put_task_struct(task);
				return 1;
			}
			rcu_read_unlock();
			put_files_struct(files);
		}
		put_task_struct(task);
	}
	return 0;
}

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

static int proc_fd_link(struct dentry *dentry, struct path *path)
{
	struct files_struct *files = NULL;
	struct task_struct *task;
	int ret = -ENOENT;

	task = get_proc_task(d_inode(dentry));
	if (task) {
		files = get_files_struct(task);
		put_task_struct(task);
	}

	if (files) {
		int fd = proc_fd(d_inode(dentry));
		struct file *fd_file;

		spin_lock(&files->file_lock);
		fd_file = fcheck_files(files, fd);
		if (fd_file) {
			*path = fd_file->f_path;
			path_get(&fd_file->f_path);
			ret = 0;
		}
		spin_unlock(&files->file_lock);
		put_files_struct(files);
	}

	return ret;
}

static int
proc_fd_instantiate(struct inode *dir, struct dentry *dentry,
		    struct task_struct *task, const void *ptr)
{
	unsigned fd = (unsigned long)ptr;
	struct proc_inode *ei;
	struct inode *inode;

	inode = proc_pid_make_inode(dir->i_sb, task);
	if (!inode)
		goto out;

	ei = PROC_I(inode);
	ei->fd = fd;

	inode->i_mode = S_IFLNK;
	inode->i_op = &proc_pid_link_inode_operations;
	inode->i_size = 64;

	ei->op.proc_get_link = proc_fd_link;

	d_set_d_op(dentry, &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, 0))
		return 0;
 out:
	return -ENOENT;
}

static struct dentry *proc_lookupfd_common(struct inode *dir,
					   struct dentry *dentry,
					   instantiate_t instantiate)
{
	struct task_struct *task = get_proc_task(dir);
	int result = -ENOENT;
	unsigned fd = name_to_int(&dentry->d_name);

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

	result = instantiate(dir, dentry, task, (void *)(unsigned long)fd);
out:
	put_task_struct(task);
out_no_task:
	return ERR_PTR(result);
}

static int proc_readfd_common(struct file *file, struct dir_context *ctx,
			      instantiate_t instantiate)
{
	struct task_struct *p = get_proc_task(file_inode(file));
	struct files_struct *files;
	unsigned int fd;

	if (!p)
		return -ENOENT;

	if (!dir_emit_dots(file, ctx))
		goto out;
	files = get_files_struct(p);
	if (!files)
		goto out;

	rcu_read_lock();
	for (fd = ctx->pos - 2;
	     fd < files_fdtable(files)->max_fds;
	     fd++, ctx->pos++) {
		char name[PROC_NUMBUF];
		int len;

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

		len = snprintf(name, sizeof(name), "%d", fd);
		if (!proc_fill_cache(file, ctx,
				     name, len, instantiate, p,
				     (void *)(unsigned long)fd))
			goto out_fd_loop;
		cond_resched();
		rcu_read_lock();
	}
	rcu_read_unlock();
out_fd_loop:
	put_files_struct(files);
out:
	put_task_struct(p);
	return 0;
}

static int proc_readfd(struct file *file, struct dir_context *ctx)
{
	return proc_readfd_common(file, ctx, proc_fd_instantiate);
}

const struct file_operations proc_fd_operations = {
	.read		= generic_read_dir,
	.iterate_shared	= proc_readfd,
	.llseek		= generic_file_llseek,
};

static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry,
				    unsigned int flags)
{
	return proc_lookupfd_common(dir, dentry, proc_fd_instantiate);
}

/*
 * /proc/pid/fd needs a special permission handler so that a process can still
 * access /proc/self/fd after it has executed a setuid().
 */
int proc_fd_permission(struct inode *inode, int mask)
{
	struct task_struct *p;
	int rv;

	rv = generic_permission(inode, mask);
	if (rv == 0)
		return rv;

	rcu_read_lock();
	p = pid_task(proc_pid(inode), PIDTYPE_PID);
	if (p && same_thread_group(p, current))
		rv = 0;
	rcu_read_unlock();

	return rv;
}

const struct inode_operations proc_fd_inode_operations = {
	.lookup		= proc_lookupfd,
	.permission	= proc_fd_permission,
	.setattr	= proc_setattr,
};

static int
proc_fdinfo_instantiate(struct inode *dir, struct dentry *dentry,
			struct task_struct *task, const void *ptr)
{
	unsigned fd = (unsigned long)ptr;
	struct proc_inode *ei;
	struct inode *inode;

	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;

	d_set_d_op(dentry, &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, 0))
		return 0;
 out:
	return -ENOENT;
}

static struct dentry *
proc_lookupfdinfo(struct inode *dir, struct dentry *dentry, unsigned int flags)
{
	return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate);
}

static int proc_readfdinfo(struct file *file, struct dir_context *ctx)
{
	return proc_readfd_common(file, ctx,
				  proc_fdinfo_instantiate);
}

const struct inode_operations proc_fdinfo_inode_operations = {
	.lookup		= proc_lookupfdinfo,
	.setattr	= proc_setattr,
};

const struct file_operations proc_fdinfo_operations = {
	.read		= generic_read_dir,
	.iterate_shared	= proc_readfdinfo,
	.llseek		= generic_file_llseek,
};
Commit	Line	Data
	1	#include <linux/sched.h>
	2	#include <linux/errno.h>
	3	#include <linux/dcache.h>
	4	#include <linux/path.h>
	5	#include <linux/fdtable.h>
	6	#include <linux/namei.h>
	7	#include <linux/pid.h>
	8	#include <linux/security.h>
	9	#include <linux/file.h>
	10	#include <linux/seq_file.h>
	11	#include <linux/fs.h>
	12
	13	#include <linux/proc_fs.h>
	14
	15	#include "../mount.h"
	16	#include "internal.h"
	17	#include "fd.h"
	18
	19	static int seq_show(struct seq_file m, void v)
	20	{
	21	struct files_struct *files = NULL;
	22	int f_flags = 0, ret = -ENOENT;
	23	struct file *file = NULL;
	24	struct task_struct *task;
	25
	26	task = get_proc_task(m->private);
	27	if (!task)
	28	return -ENOENT;
	29
	30	files = get_files_struct(task);
	31	put_task_struct(task);
	32
	33	if (files) {
	34	int fd = proc_fd(m->private);
	35
	36	spin_lock(&files->file_lock);
	37	file = fcheck_files(files, fd);
	38	if (file) {
	39	struct fdtable *fdt = files_fdtable(files);
	40
	41	f_flags = file->f_flags;
	42	if (close_on_exec(fd, fdt))
	43	f_flags \|= O_CLOEXEC;
	44
	45	get_file(file);
	46	ret = 0;
	47	}
	48	spin_unlock(&files->file_lock);
	49	put_files_struct(files);
	50	}
	51
	52	if (ret)
	53	return ret;
	54
	55	seq_printf(m, "pos:\t%lli\nflags:\t0%o\nmnt_id:\t%i\n",
	56	(long long)file->f_pos, f_flags,
	57	real_mount(file->f_path.mnt)->mnt_id);
	58
	59	show_fd_locks(m, file, files);
	60	if (seq_has_overflowed(m))
	61	goto out;
	62
	63	if (file->f_op->show_fdinfo)
	64	file->f_op->show_fdinfo(m, file);
	65
	66	out:
	67	fput(file);
	68	return 0;
	69	}
	70
	71	static int seq_fdinfo_open(struct inode inode, struct file file)
	72	{
	73	return single_open(file, seq_show, inode);
	74	}
	75
	76	static const struct file_operations proc_fdinfo_file_operations = {
	77	.open = seq_fdinfo_open,
	78	.read = seq_read,
	79	.llseek = seq_lseek,
	80	.release = single_release,
	81	};
	82
	83	static int tid_fd_revalidate(struct dentry *dentry, unsigned int flags)
	84	{
	85	struct files_struct *files;
	86	struct task_struct *task;
	87	const struct cred *cred;
	88	struct inode *inode;
	89	int fd;
	90
	91	if (flags & LOOKUP_RCU)
	92	return -ECHILD;
	93
	94	inode = d_inode(dentry);
	95	task = get_proc_task(inode);
	96	fd = proc_fd(inode);
	97
	98	if (task) {
	99	files = get_files_struct(task);
	100	if (files) {
	101	struct file *file;
	102
	103	rcu_read_lock();
	104	file = fcheck_files(files, fd);
	105	if (file) {
	106	unsigned f_mode = file->f_mode;
	107
	108	rcu_read_unlock();
	109	put_files_struct(files);
	110
	111	if (task_dumpable(task)) {
	112	rcu_read_lock();
	113	cred = __task_cred(task);
	114	inode->i_uid = cred->euid;
	115	inode->i_gid = cred->egid;
	116	rcu_read_unlock();
	117	} else {
	118	inode->i_uid = GLOBAL_ROOT_UID;
	119	inode->i_gid = GLOBAL_ROOT_GID;
	120	}
	121
	122	if (S_ISLNK(inode->i_mode)) {
	123	unsigned i_mode = S_IFLNK;
	124	if (f_mode & FMODE_READ)
	125	i_mode \|= S_IRUSR \| S_IXUSR;
	126	if (f_mode & FMODE_WRITE)
	127	i_mode \|= S_IWUSR \| S_IXUSR;
	128	inode->i_mode = i_mode;
	129	}
	130
	131	security_task_to_inode(task, inode);
	132	put_task_struct(task);
	133	return 1;
	134	}
	135	rcu_read_unlock();
	136	put_files_struct(files);
	137	}
	138	put_task_struct(task);
	139	}
	140	return 0;
	141	}
	142
	143	static const struct dentry_operations tid_fd_dentry_operations = {
	144	.d_revalidate = tid_fd_revalidate,
	145	.d_delete = pid_delete_dentry,
	146	};
	147
	148	static int proc_fd_link(struct dentry dentry, struct path path)
	149	{
	150	struct files_struct *files = NULL;
	151	struct task_struct *task;
	152	int ret = -ENOENT;
	153
	154	task = get_proc_task(d_inode(dentry));
	155	if (task) {
	156	files = get_files_struct(task);
	157	put_task_struct(task);
	158	}
	159
	160	if (files) {
	161	int fd = proc_fd(d_inode(dentry));
	162	struct file *fd_file;
	163
	164	spin_lock(&files->file_lock);
	165	fd_file = fcheck_files(files, fd);
	166	if (fd_file) {
	167	*path = fd_file->f_path;
	168	path_get(&fd_file->f_path);
	169	ret = 0;
	170	}
	171	spin_unlock(&files->file_lock);
	172	put_files_struct(files);
	173	}
	174
	175	return ret;
	176	}
	177
	178	static int
	179	proc_fd_instantiate(struct inode dir, struct dentry dentry,
	180	struct task_struct task, const void ptr)
	181	{
	182	unsigned fd = (unsigned long)ptr;
	183	struct proc_inode *ei;
	184	struct inode *inode;
	185
	186	inode = proc_pid_make_inode(dir->i_sb, task);
	187	if (!inode)
	188	goto out;
	189
	190	ei = PROC_I(inode);
	191	ei->fd = fd;
	192
	193	inode->i_mode = S_IFLNK;
	194	inode->i_op = &proc_pid_link_inode_operations;
	195	inode->i_size = 64;
	196
	197	ei->op.proc_get_link = proc_fd_link;
	198
	199	d_set_d_op(dentry, &tid_fd_dentry_operations);
	200	d_add(dentry, inode);
	201
	202	/* Close the race of the process dying before we return the dentry */
	203	if (tid_fd_revalidate(dentry, 0))
	204	return 0;
	205	out:
	206	return -ENOENT;
	207	}
	208
	209	static struct dentry proc_lookupfd_common(struct inode dir,
	210	struct dentry *dentry,
	211	instantiate_t instantiate)
	212	{
	213	struct task_struct *task = get_proc_task(dir);
	214	int result = -ENOENT;
	215	unsigned fd = name_to_int(&dentry->d_name);
	216
	217	if (!task)
	218	goto out_no_task;
	219	if (fd == ~0U)
	220	goto out;
	221
	222	result = instantiate(dir, dentry, task, (void *)(unsigned long)fd);
	223	out:
	224	put_task_struct(task);
	225	out_no_task:
	226	return ERR_PTR(result);
	227	}
	228
	229	static int proc_readfd_common(struct file file, struct dir_context ctx,
	230	instantiate_t instantiate)
	231	{
	232	struct task_struct *p = get_proc_task(file_inode(file));
	233	struct files_struct *files;
	234	unsigned int fd;
	235
	236	if (!p)
	237	return -ENOENT;
	238
	239	if (!dir_emit_dots(file, ctx))
	240	goto out;
	241	files = get_files_struct(p);
	242	if (!files)
	243	goto out;
	244
	245	rcu_read_lock();
	246	for (fd = ctx->pos - 2;
	247	fd < files_fdtable(files)->max_fds;
	248	fd++, ctx->pos++) {
	249	char name[PROC_NUMBUF];
	250	int len;
	251
	252	if (!fcheck_files(files, fd))
	253	continue;
	254	rcu_read_unlock();
	255
	256	len = snprintf(name, sizeof(name), "%d", fd);
	257	if (!proc_fill_cache(file, ctx,
	258	name, len, instantiate, p,
	259	(void *)(unsigned long)fd))
	260	goto out_fd_loop;
	261	cond_resched();
	262	rcu_read_lock();
	263	}
	264	rcu_read_unlock();
	265	out_fd_loop:
	266	put_files_struct(files);
	267	out:
	268	put_task_struct(p);
	269	return 0;
	270	}
	271
	272	static int proc_readfd(struct file file, struct dir_context ctx)
	273	{
	274	return proc_readfd_common(file, ctx, proc_fd_instantiate);
	275	}
	276
	277	const struct file_operations proc_fd_operations = {
	278	.read = generic_read_dir,
	279	.iterate_shared = proc_readfd,
	280	.llseek = generic_file_llseek,
	281	};
	282
	283	static struct dentry proc_lookupfd(struct inode dir, struct dentry *dentry,
	284	unsigned int flags)
	285	{
	286	return proc_lookupfd_common(dir, dentry, proc_fd_instantiate);
	287	}
	288
	289	/*
	290	* /proc/pid/fd needs a special permission handler so that a process can still
	291	* access /proc/self/fd after it has executed a setuid().
	292	*/
	293	int proc_fd_permission(struct inode *inode, int mask)
	294	{
	295	struct task_struct *p;
	296	int rv;
	297
	298	rv = generic_permission(inode, mask);
	299	if (rv == 0)
	300	return rv;
	301
	302	rcu_read_lock();
	303	p = pid_task(proc_pid(inode), PIDTYPE_PID);
	304	if (p && same_thread_group(p, current))
	305	rv = 0;
	306	rcu_read_unlock();
	307
	308	return rv;
	309	}
	310
	311	const struct inode_operations proc_fd_inode_operations = {
	312	.lookup = proc_lookupfd,
	313	.permission = proc_fd_permission,
	314	.setattr = proc_setattr,
	315	};
	316
	317	static int
	318	proc_fdinfo_instantiate(struct inode dir, struct dentry dentry,
	319	struct task_struct task, const void ptr)
	320	{
	321	unsigned fd = (unsigned long)ptr;
	322	struct proc_inode *ei;
	323	struct inode *inode;
	324
	325	inode = proc_pid_make_inode(dir->i_sb, task);
	326	if (!inode)
	327	goto out;
	328
	329	ei = PROC_I(inode);
	330	ei->fd = fd;
	331
	332	inode->i_mode = S_IFREG \| S_IRUSR;
	333	inode->i_fop = &proc_fdinfo_file_operations;
	334
	335	d_set_d_op(dentry, &tid_fd_dentry_operations);
	336	d_add(dentry, inode);
	337
	338	/* Close the race of the process dying before we return the dentry */
	339	if (tid_fd_revalidate(dentry, 0))
	340	return 0;
	341	out:
	342	return -ENOENT;
	343	}
	344
	345	static struct dentry *
	346	proc_lookupfdinfo(struct inode dir, struct dentry dentry, unsigned int flags)
	347	{
	348	return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate);
	349	}
	350
	351	static int proc_readfdinfo(struct file file, struct dir_context ctx)
	352	{
	353	return proc_readfd_common(file, ctx,
	354	proc_fdinfo_instantiate);
	355	}
	356
	357	const struct inode_operations proc_fdinfo_inode_operations = {
	358	.lookup = proc_lookupfdinfo,
	359	.setattr = proc_setattr,
	360	};
	361
	362	const struct file_operations proc_fdinfo_operations = {
	363	.read = generic_read_dir,
	364	.iterate_shared = proc_readfdinfo,
	365	.llseek = generic_file_llseek,
	366	};