inode.c 12.0 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9
/*
 *  linux/fs/proc/inode.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

#include <linux/time.h>
#include <linux/proc_fs.h>
#include <linux/kernel.h>
V
Vasiliy Kulikov 已提交
10
#include <linux/pid_namespace.h>
L
Linus Torvalds 已提交
11 12 13
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/stat.h>
14
#include <linux/completion.h>
15
#include <linux/poll.h>
A
Andrew Morton 已提交
16
#include <linux/printk.h>
L
Linus Torvalds 已提交
17 18 19 20
#include <linux/file.h>
#include <linux/limits.h>
#include <linux/init.h>
#include <linux/module.h>
A
Al Viro 已提交
21
#include <linux/sysctl.h>
V
Vasiliy Kulikov 已提交
22
#include <linux/seq_file.h>
23
#include <linux/slab.h>
V
Vasiliy Kulikov 已提交
24
#include <linux/mount.h>
L
Linus Torvalds 已提交
25 26 27

#include <asm/uaccess.h>

28
#include "internal.h"
L
Linus Torvalds 已提交
29

A
Al Viro 已提交
30
static void proc_evict_inode(struct inode *inode)
L
Linus Torvalds 已提交
31 32
{
	struct proc_dir_entry *de;
A
Al Viro 已提交
33
	struct ctl_table_header *head;
34
	const struct proc_ns_operations *ns_ops;
35
	void *ns;
L
Linus Torvalds 已提交
36

37
	truncate_inode_pages(&inode->i_data, 0);
38
	clear_inode(inode);
39

40
	/* Stop tracking associated processes */
41
	put_pid(PROC_I(inode)->pid);
L
Linus Torvalds 已提交
42 43 44

	/* Let go of any associated proc directory entry */
	de = PROC_I(inode)->pde;
45
	if (de)
46
		pde_put(de);
A
Al Viro 已提交
47 48 49 50 51
	head = PROC_I(inode)->sysctl;
	if (head) {
		rcu_assign_pointer(PROC_I(inode)->sysctl, NULL);
		sysctl_head_put(head);
	}
52 53
	/* Release any associated namespace */
	ns_ops = PROC_I(inode)->ns_ops;
54 55 56
	ns = PROC_I(inode)->ns;
	if (ns_ops && ns)
		ns_ops->put(ns);
L
Linus Torvalds 已提交
57 58
}

59
static struct kmem_cache * proc_inode_cachep;
L
Linus Torvalds 已提交
60 61 62 63 64 65

static struct inode *proc_alloc_inode(struct super_block *sb)
{
	struct proc_inode *ei;
	struct inode *inode;

66
	ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);
L
Linus Torvalds 已提交
67 68
	if (!ei)
		return NULL;
69
	ei->pid = NULL;
70
	ei->fd = 0;
L
Linus Torvalds 已提交
71 72
	ei->op.proc_get_link = NULL;
	ei->pde = NULL;
A
Al Viro 已提交
73 74
	ei->sysctl = NULL;
	ei->sysctl_entry = NULL;
75 76
	ei->ns = NULL;
	ei->ns_ops = NULL;
L
Linus Torvalds 已提交
77 78 79 80 81
	inode = &ei->vfs_inode;
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	return inode;
}

N
Nick Piggin 已提交
82
static void proc_i_callback(struct rcu_head *head)
L
Linus Torvalds 已提交
83
{
N
Nick Piggin 已提交
84
	struct inode *inode = container_of(head, struct inode, i_rcu);
L
Linus Torvalds 已提交
85 86 87
	kmem_cache_free(proc_inode_cachep, PROC_I(inode));
}

N
Nick Piggin 已提交
88 89 90 91 92
static void proc_destroy_inode(struct inode *inode)
{
	call_rcu(&inode->i_rcu, proc_i_callback);
}

93
static void init_once(void *foo)
L
Linus Torvalds 已提交
94 95 96
{
	struct proc_inode *ei = (struct proc_inode *) foo;

C
Christoph Lameter 已提交
97
	inode_init_once(&ei->vfs_inode);
L
Linus Torvalds 已提交
98
}
99

100
void __init proc_init_inodecache(void)
L
Linus Torvalds 已提交
101 102 103
{
	proc_inode_cachep = kmem_cache_create("proc_inode_cache",
					     sizeof(struct proc_inode),
104
					     0, (SLAB_RECLAIM_ACCOUNT|
105
						SLAB_MEM_SPREAD|SLAB_PANIC),
106
					     init_once);
L
Linus Torvalds 已提交
107 108
}

V
Vasiliy Kulikov 已提交
109 110
static int proc_show_options(struct seq_file *seq, struct dentry *root)
{
111 112 113
	struct super_block *sb = root->d_sb;
	struct pid_namespace *pid = sb->s_fs_info;

114 115
	if (!gid_eq(pid->pid_gid, GLOBAL_ROOT_GID))
		seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, pid->pid_gid));
116 117 118
	if (pid->hide_pid != 0)
		seq_printf(seq, ",hidepid=%u", pid->hide_pid);

V
Vasiliy Kulikov 已提交
119 120 121
	return 0;
}

122
static const struct super_operations proc_sops = {
L
Linus Torvalds 已提交
123 124 125
	.alloc_inode	= proc_alloc_inode,
	.destroy_inode	= proc_destroy_inode,
	.drop_inode	= generic_delete_inode,
A
Al Viro 已提交
126
	.evict_inode	= proc_evict_inode,
L
Linus Torvalds 已提交
127
	.statfs		= simple_statfs,
V
Vasiliy Kulikov 已提交
128 129
	.remount_fs	= proc_remount,
	.show_options	= proc_show_options,
L
Linus Torvalds 已提交
130 131
};

A
Alexey Dobriyan 已提交
132
static void __pde_users_dec(struct proc_dir_entry *pde)
133 134 135 136
{
	pde->pde_users--;
	if (pde->pde_unload_completion && pde->pde_users == 0)
		complete(pde->pde_unload_completion);
A
Alexey Dobriyan 已提交
137 138
}

139
void pde_users_dec(struct proc_dir_entry *pde)
A
Alexey Dobriyan 已提交
140 141 142
{
	spin_lock(&pde->pde_unload_lock);
	__pde_users_dec(pde);
143 144 145 146 147
	spin_unlock(&pde->pde_unload_lock);
}

static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
{
A
Al Viro 已提交
148
	struct proc_dir_entry *pde = PDE(file_inode(file));
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
	loff_t rv = -EINVAL;
	loff_t (*llseek)(struct file *, loff_t, int);

	spin_lock(&pde->pde_unload_lock);
	/*
	 * remove_proc_entry() is going to delete PDE (as part of module
	 * cleanup sequence). No new callers into module allowed.
	 */
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	/*
	 * Bump refcount so that remove_proc_entry will wail for ->llseek to
	 * complete.
	 */
	pde->pde_users++;
	/*
	 * Save function pointer under lock, to protect against ->proc_fops
	 * NULL'ifying right after ->pde_unload_lock is dropped.
	 */
	llseek = pde->proc_fops->llseek;
	spin_unlock(&pde->pde_unload_lock);

	if (!llseek)
		llseek = default_llseek;
	rv = llseek(file, offset, whence);

	pde_users_dec(pde);
	return rv;
}

static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
A
Al Viro 已提交
183
	struct proc_dir_entry *pde = PDE(file_inode(file));
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
	ssize_t rv = -EIO;
	ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);

	spin_lock(&pde->pde_unload_lock);
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	pde->pde_users++;
	read = pde->proc_fops->read;
	spin_unlock(&pde->pde_unload_lock);

	if (read)
		rv = read(file, buf, count, ppos);

	pde_users_dec(pde);
	return rv;
}

static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
A
Al Viro 已提交
205
	struct proc_dir_entry *pde = PDE(file_inode(file));
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
	ssize_t rv = -EIO;
	ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);

	spin_lock(&pde->pde_unload_lock);
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	pde->pde_users++;
	write = pde->proc_fops->write;
	spin_unlock(&pde->pde_unload_lock);

	if (write)
		rv = write(file, buf, count, ppos);

	pde_users_dec(pde);
	return rv;
}

static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *pts)
{
A
Al Viro 已提交
227
	struct proc_dir_entry *pde = PDE(file_inode(file));
228
	unsigned int rv = DEFAULT_POLLMASK;
229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
	unsigned int (*poll)(struct file *, struct poll_table_struct *);

	spin_lock(&pde->pde_unload_lock);
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	pde->pde_users++;
	poll = pde->proc_fops->poll;
	spin_unlock(&pde->pde_unload_lock);

	if (poll)
		rv = poll(file, pts);

	pde_users_dec(pde);
	return rv;
}

static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
A
Al Viro 已提交
249
	struct proc_dir_entry *pde = PDE(file_inode(file));
250
	long rv = -ENOTTY;
251
	long (*ioctl)(struct file *, unsigned int, unsigned long);
252 253 254 255 256 257 258

	spin_lock(&pde->pde_unload_lock);
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	pde->pde_users++;
259
	ioctl = pde->proc_fops->unlocked_ioctl;
260 261
	spin_unlock(&pde->pde_unload_lock);

262 263
	if (ioctl)
		rv = ioctl(file, cmd, arg);
264 265 266 267 268 269 270 271

	pde_users_dec(pde);
	return rv;
}

#ifdef CONFIG_COMPAT
static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
A
Al Viro 已提交
272
	struct proc_dir_entry *pde = PDE(file_inode(file));
273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294
	long rv = -ENOTTY;
	long (*compat_ioctl)(struct file *, unsigned int, unsigned long);

	spin_lock(&pde->pde_unload_lock);
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	pde->pde_users++;
	compat_ioctl = pde->proc_fops->compat_ioctl;
	spin_unlock(&pde->pde_unload_lock);

	if (compat_ioctl)
		rv = compat_ioctl(file, cmd, arg);

	pde_users_dec(pde);
	return rv;
}
#endif

static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma)
{
A
Al Viro 已提交
295
	struct proc_dir_entry *pde = PDE(file_inode(file));
296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
	int rv = -EIO;
	int (*mmap)(struct file *, struct vm_area_struct *);

	spin_lock(&pde->pde_unload_lock);
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	pde->pde_users++;
	mmap = pde->proc_fops->mmap;
	spin_unlock(&pde->pde_unload_lock);

	if (mmap)
		rv = mmap(file, vma);

	pde_users_dec(pde);
	return rv;
}

static int proc_reg_open(struct inode *inode, struct file *file)
{
	struct proc_dir_entry *pde = PDE(inode);
	int rv = 0;
	int (*open)(struct inode *, struct file *);
A
Alexey Dobriyan 已提交
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
	int (*release)(struct inode *, struct file *);
	struct pde_opener *pdeo;

	/*
	 * What for, you ask? Well, we can have open, rmmod, remove_proc_entry
	 * sequence. ->release won't be called because ->proc_fops will be
	 * cleared. Depending on complexity of ->release, consequences vary.
	 *
	 * We can't wait for mercy when close will be done for real, it's
	 * deadlockable: rmmod foo </proc/foo . So, we're going to do ->release
	 * by hand in remove_proc_entry(). For this, save opener's credentials
	 * for later.
	 */
	pdeo = kmalloc(sizeof(struct pde_opener), GFP_KERNEL);
	if (!pdeo)
		return -ENOMEM;
336 337 338 339

	spin_lock(&pde->pde_unload_lock);
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
A
Alexey Dobriyan 已提交
340
		kfree(pdeo);
341
		return -ENOENT;
342 343 344
	}
	pde->pde_users++;
	open = pde->proc_fops->open;
A
Alexey Dobriyan 已提交
345
	release = pde->proc_fops->release;
346 347 348 349 350
	spin_unlock(&pde->pde_unload_lock);

	if (open)
		rv = open(inode, file);

A
Alexey Dobriyan 已提交
351 352 353 354 355 356 357 358 359 360 361 362
	spin_lock(&pde->pde_unload_lock);
	if (rv == 0 && release) {
		/* To know what to release. */
		pdeo->inode = inode;
		pdeo->file = file;
		/* Strictly for "too late" ->release in proc_reg_release(). */
		pdeo->release = release;
		list_add(&pdeo->lh, &pde->pde_openers);
	} else
		kfree(pdeo);
	__pde_users_dec(pde);
	spin_unlock(&pde->pde_unload_lock);
363 364 365
	return rv;
}

A
Alexey Dobriyan 已提交
366 367 368 369 370 371 372 373 374 375 376 377
static struct pde_opener *find_pde_opener(struct proc_dir_entry *pde,
					struct inode *inode, struct file *file)
{
	struct pde_opener *pdeo;

	list_for_each_entry(pdeo, &pde->pde_openers, lh) {
		if (pdeo->inode == inode && pdeo->file == file)
			return pdeo;
	}
	return NULL;
}

378 379 380 381 382
static int proc_reg_release(struct inode *inode, struct file *file)
{
	struct proc_dir_entry *pde = PDE(inode);
	int rv = 0;
	int (*release)(struct inode *, struct file *);
A
Alexey Dobriyan 已提交
383
	struct pde_opener *pdeo;
384 385

	spin_lock(&pde->pde_unload_lock);
A
Alexey Dobriyan 已提交
386
	pdeo = find_pde_opener(pde, inode, file);
387
	if (!pde->proc_fops) {
A
Alexey Dobriyan 已提交
388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
		/*
		 * Can't simply exit, __fput() will think that everything is OK,
		 * and move on to freeing struct file. remove_proc_entry() will
		 * find slacker in opener's list and will try to do non-trivial
		 * things with struct file. Therefore, remove opener from list.
		 *
		 * But if opener is removed from list, who will ->release it?
		 */
		if (pdeo) {
			list_del(&pdeo->lh);
			spin_unlock(&pde->pde_unload_lock);
			rv = pdeo->release(inode, file);
			kfree(pdeo);
		} else
			spin_unlock(&pde->pde_unload_lock);
403 404 405 406
		return rv;
	}
	pde->pde_users++;
	release = pde->proc_fops->release;
A
Alexey Dobriyan 已提交
407 408 409 410
	if (pdeo) {
		list_del(&pdeo->lh);
		kfree(pdeo);
	}
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
	spin_unlock(&pde->pde_unload_lock);

	if (release)
		rv = release(inode, file);

	pde_users_dec(pde);
	return rv;
}

static const struct file_operations proc_reg_file_ops = {
	.llseek		= proc_reg_llseek,
	.read		= proc_reg_read,
	.write		= proc_reg_write,
	.poll		= proc_reg_poll,
	.unlocked_ioctl	= proc_reg_unlocked_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= proc_reg_compat_ioctl,
#endif
	.mmap		= proc_reg_mmap,
	.open		= proc_reg_open,
	.release	= proc_reg_release,
};

434 435 436 437 438 439 440 441 442 443 444 445 446
#ifdef CONFIG_COMPAT
static const struct file_operations proc_reg_file_ops_no_compat = {
	.llseek		= proc_reg_llseek,
	.read		= proc_reg_read,
	.write		= proc_reg_write,
	.poll		= proc_reg_poll,
	.unlocked_ioctl	= proc_reg_unlocked_ioctl,
	.mmap		= proc_reg_mmap,
	.open		= proc_reg_open,
	.release	= proc_reg_release,
};
#endif

A
Alexey Dobriyan 已提交
447
struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de)
L
Linus Torvalds 已提交
448
{
449
	struct inode *inode = new_inode_pseudo(sb);
L
Linus Torvalds 已提交
450

451 452
	if (inode) {
		inode->i_ino = de->low_ino;
453 454
		inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
		PROC_I(inode)->pde = de;
455 456 457 458 459 460 461 462 463

		if (de->mode) {
			inode->i_mode = de->mode;
			inode->i_uid = de->uid;
			inode->i_gid = de->gid;
		}
		if (de->size)
			inode->i_size = de->size;
		if (de->nlink)
M
Miklos Szeredi 已提交
464
			set_nlink(inode, de->nlink);
465 466 467 468
		if (de->proc_iops)
			inode->i_op = de->proc_iops;
		if (de->proc_fops) {
			if (S_ISREG(inode->i_mode)) {
469
#ifdef CONFIG_COMPAT
470 471 472 473
				if (!de->proc_fops->compat_ioctl)
					inode->i_fop =
						&proc_reg_file_ops_no_compat;
				else
474
#endif
475 476 477
					inode->i_fop = &proc_reg_file_ops;
			} else {
				inode->i_fop = de->proc_fops;
478
			}
479
		}
480
	} else
481
	       pde_put(de);
L
Linus Torvalds 已提交
482
	return inode;
483
}
L
Linus Torvalds 已提交
484

485
int proc_fill_super(struct super_block *s)
L
Linus Torvalds 已提交
486
{
487 488
	struct inode *root_inode;

489
	s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
L
Linus Torvalds 已提交
490 491 492 493 494 495
	s->s_blocksize = 1024;
	s->s_blocksize_bits = 10;
	s->s_magic = PROC_SUPER_MAGIC;
	s->s_op = &proc_sops;
	s->s_time_gran = 1;
	
496
	pde_get(&proc_root);
497 498
	root_inode = proc_get_inode(s, &proc_root);
	if (!root_inode) {
A
Andrew Morton 已提交
499
		pr_err("proc_fill_super: get root inode failed\n");
500 501
		return -ENOMEM;
	}
L
Linus Torvalds 已提交
502

503 504
	s->s_root = d_make_root(root_inode);
	if (!s->s_root) {
A
Andrew Morton 已提交
505
		pr_err("proc_fill_super: allocate dentry failed\n");
506 507 508
		return -ENOMEM;
	}

509
	return proc_setup_self(s);
L
Linus Torvalds 已提交
510
}