xref: /linux/fs/proc/generic.c (revision 80d443e8876602be2c130f79c4de81e12e2a700d) 
1 /*
2  * proc/fs/generic.c --- generic routines for the proc-fs
3  *
4  * This file contains generic proc-fs routines for handling
5  * directories and files.
6  *
7  * Copyright (C) 1991, 1992 Linus Torvalds.
8  * Copyright (C) 1997 Theodore Ts'o
9  */
10 
11 #include <linux/errno.h>
12 #include <linux/time.h>
13 #include <linux/proc_fs.h>
14 #include <linux/stat.h>
15 #include <linux/mm.h>
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/printk.h>
19 #include <linux/mount.h>
20 #include <linux/init.h>
21 #include <linux/idr.h>
22 #include <linux/bitops.h>
23 #include <linux/spinlock.h>
24 #include <linux/completion.h>
25 #include <linux/uaccess.h>
26 
27 #include "internal.h"
28 
29 static DEFINE_RWLOCK(proc_subdir_lock);
30 
31 static int proc_match(unsigned int len, const char *name, struct proc_dir_entry *de)
32 {
33 	if (len < de->namelen)
34 		return -1;
35 	if (len > de->namelen)
36 		return 1;
37 
38 	return memcmp(name, de->name, len);
39 }
40 
41 static struct proc_dir_entry *pde_subdir_first(struct proc_dir_entry *dir)
42 {
43 	return rb_entry_safe(rb_first(&dir->subdir), struct proc_dir_entry,
44 			     subdir_node);
45 }
46 
47 static struct proc_dir_entry *pde_subdir_next(struct proc_dir_entry *dir)
48 {
49 	return rb_entry_safe(rb_next(&dir->subdir_node), struct proc_dir_entry,
50 			     subdir_node);
51 }
52 
53 static struct proc_dir_entry *pde_subdir_find(struct proc_dir_entry *dir,
54 					      const char *name,
55 					      unsigned int len)
56 {
57 	struct rb_node *node = dir->subdir.rb_node;
58 
59 	while (node) {
60 		struct proc_dir_entry *de = container_of(node,
61 							 struct proc_dir_entry,
62 							 subdir_node);
63 		int result = proc_match(len, name, de);
64 
65 		if (result < 0)
66 			node = node->rb_left;
67 		else if (result > 0)
68 			node = node->rb_right;
69 		else
70 			return de;
71 	}
72 	return NULL;
73 }
74 
75 static bool pde_subdir_insert(struct proc_dir_entry *dir,
76 			      struct proc_dir_entry *de)
77 {
78 	struct rb_root *root = &dir->subdir;
79 	struct rb_node **new = &root->rb_node, *parent = NULL;
80 
81 	/* Figure out where to put new node */
82 	while (*new) {
83 		struct proc_dir_entry *this =
84 			container_of(*new, struct proc_dir_entry, subdir_node);
85 		int result = proc_match(de->namelen, de->name, this);
86 
87 		parent = *new;
88 		if (result < 0)
89 			new = &(*new)->rb_left;
90 		else if (result > 0)
91 			new = &(*new)->rb_right;
92 		else
93 			return false;
94 	}
95 
96 	/* Add new node and rebalance tree. */
97 	rb_link_node(&de->subdir_node, parent, new);
98 	rb_insert_color(&de->subdir_node, root);
99 	return true;
100 }
101 
102 static int proc_notify_change(struct dentry *dentry, struct iattr *iattr)
103 {
104 	struct inode *inode = d_inode(dentry);
105 	struct proc_dir_entry *de = PDE(inode);
106 	int error;
107 
108 	error = setattr_prepare(dentry, iattr);
109 	if (error)
110 		return error;
111 
112 	setattr_copy(inode, iattr);
113 	mark_inode_dirty(inode);
114 
115 	proc_set_user(de, inode->i_uid, inode->i_gid);
116 	de->mode = inode->i_mode;
117 	return 0;
118 }
119 
120 static int proc_getattr(struct vfsmount *mnt, struct dentry *dentry,
121 			struct kstat *stat)
122 {
123 	struct inode *inode = d_inode(dentry);
124 	struct proc_dir_entry *de = PDE(inode);
125 	if (de && de->nlink)
126 		set_nlink(inode, de->nlink);
127 
128 	generic_fillattr(inode, stat);
129 	return 0;
130 }
131 
132 static const struct inode_operations proc_file_inode_operations = {
133 	.setattr	= proc_notify_change,
134 };
135 
136 /*
137  * This function parses a name such as "tty/driver/serial", and
138  * returns the struct proc_dir_entry for "/proc/tty/driver", and
139  * returns "serial" in residual.
140  */
141 static int __xlate_proc_name(const char *name, struct proc_dir_entry **ret,
142 			     const char **residual)
143 {
144 	const char     		*cp = name, *next;
145 	struct proc_dir_entry	*de;
146 	unsigned int		len;
147 
148 	de = *ret;
149 	if (!de)
150 		de = &proc_root;
151 
152 	while (1) {
153 		next = strchr(cp, '/');
154 		if (!next)
155 			break;
156 
157 		len = next - cp;
158 		de = pde_subdir_find(de, cp, len);
159 		if (!de) {
160 			WARN(1, "name '%s'\n", name);
161 			return -ENOENT;
162 		}
163 		cp += len + 1;
164 	}
165 	*residual = cp;
166 	*ret = de;
167 	return 0;
168 }
169 
170 static int xlate_proc_name(const char *name, struct proc_dir_entry **ret,
171 			   const char **residual)
172 {
173 	int rv;
174 
175 	read_lock(&proc_subdir_lock);
176 	rv = __xlate_proc_name(name, ret, residual);
177 	read_unlock(&proc_subdir_lock);
178 	return rv;
179 }
180 
181 static DEFINE_IDA(proc_inum_ida);
182 static DEFINE_SPINLOCK(proc_inum_lock); /* protects the above */
183 
184 #define PROC_DYNAMIC_FIRST 0xF0000000U
185 
186 /*
187  * Return an inode number between PROC_DYNAMIC_FIRST and
188  * 0xffffffff, or zero on failure.
189  */
190 int proc_alloc_inum(unsigned int *inum)
191 {
192 	unsigned int i;
193 	int error;
194 
195 retry:
196 	if (!ida_pre_get(&proc_inum_ida, GFP_KERNEL))
197 		return -ENOMEM;
198 
199 	spin_lock_irq(&proc_inum_lock);
200 	error = ida_get_new(&proc_inum_ida, &i);
201 	spin_unlock_irq(&proc_inum_lock);
202 	if (error == -EAGAIN)
203 		goto retry;
204 	else if (error)
205 		return error;
206 
207 	if (i > UINT_MAX - PROC_DYNAMIC_FIRST) {
208 		spin_lock_irq(&proc_inum_lock);
209 		ida_remove(&proc_inum_ida, i);
210 		spin_unlock_irq(&proc_inum_lock);
211 		return -ENOSPC;
212 	}
213 	*inum = PROC_DYNAMIC_FIRST + i;
214 	return 0;
215 }
216 
217 void proc_free_inum(unsigned int inum)
218 {
219 	unsigned long flags;
220 	spin_lock_irqsave(&proc_inum_lock, flags);
221 	ida_remove(&proc_inum_ida, inum - PROC_DYNAMIC_FIRST);
222 	spin_unlock_irqrestore(&proc_inum_lock, flags);
223 }
224 
225 /*
226  * Don't create negative dentries here, return -ENOENT by hand
227  * instead.
228  */
229 struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir,
230 		struct dentry *dentry)
231 {
232 	struct inode *inode;
233 
234 	read_lock(&proc_subdir_lock);
235 	de = pde_subdir_find(de, dentry->d_name.name, dentry->d_name.len);
236 	if (de) {
237 		pde_get(de);
238 		read_unlock(&proc_subdir_lock);
239 		inode = proc_get_inode(dir->i_sb, de);
240 		if (!inode)
241 			return ERR_PTR(-ENOMEM);
242 		d_set_d_op(dentry, &simple_dentry_operations);
243 		d_add(dentry, inode);
244 		return NULL;
245 	}
246 	read_unlock(&proc_subdir_lock);
247 	return ERR_PTR(-ENOENT);
248 }
249 
250 struct dentry *proc_lookup(struct inode *dir, struct dentry *dentry,
251 		unsigned int flags)
252 {
253 	return proc_lookup_de(PDE(dir), dir, dentry);
254 }
255 
256 /*
257  * This returns non-zero if at EOF, so that the /proc
258  * root directory can use this and check if it should
259  * continue with the <pid> entries..
260  *
261  * Note that the VFS-layer doesn't care about the return
262  * value of the readdir() call, as long as it's non-negative
263  * for success..
264  */
265 int proc_readdir_de(struct proc_dir_entry *de, struct file *file,
266 		    struct dir_context *ctx)
267 {
268 	int i;
269 
270 	if (!dir_emit_dots(file, ctx))
271 		return 0;
272 
273 	read_lock(&proc_subdir_lock);
274 	de = pde_subdir_first(de);
275 	i = ctx->pos - 2;
276 	for (;;) {
277 		if (!de) {
278 			read_unlock(&proc_subdir_lock);
279 			return 0;
280 		}
281 		if (!i)
282 			break;
283 		de = pde_subdir_next(de);
284 		i--;
285 	}
286 
287 	do {
288 		struct proc_dir_entry *next;
289 		pde_get(de);
290 		read_unlock(&proc_subdir_lock);
291 		if (!dir_emit(ctx, de->name, de->namelen,
292 			    de->low_ino, de->mode >> 12)) {
293 			pde_put(de);
294 			return 0;
295 		}
296 		read_lock(&proc_subdir_lock);
297 		ctx->pos++;
298 		next = pde_subdir_next(de);
299 		pde_put(de);
300 		de = next;
301 	} while (de);
302 	read_unlock(&proc_subdir_lock);
303 	return 1;
304 }
305 
306 int proc_readdir(struct file *file, struct dir_context *ctx)
307 {
308 	struct inode *inode = file_inode(file);
309 
310 	return proc_readdir_de(PDE(inode), file, ctx);
311 }
312 
313 /*
314  * These are the generic /proc directory operations. They
315  * use the in-memory "struct proc_dir_entry" tree to parse
316  * the /proc directory.
317  */
318 static const struct file_operations proc_dir_operations = {
319 	.llseek			= generic_file_llseek,
320 	.read			= generic_read_dir,
321 	.iterate_shared		= proc_readdir,
322 };
323 
324 /*
325  * proc directories can do almost nothing..
326  */
327 static const struct inode_operations proc_dir_inode_operations = {
328 	.lookup		= proc_lookup,
329 	.getattr	= proc_getattr,
330 	.setattr	= proc_notify_change,
331 };
332 
333 static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)
334 {
335 	int ret;
336 
337 	ret = proc_alloc_inum(&dp->low_ino);
338 	if (ret)
339 		return ret;
340 
341 	write_lock(&proc_subdir_lock);
342 	dp->parent = dir;
343 	if (pde_subdir_insert(dir, dp) == false) {
344 		WARN(1, "proc_dir_entry '%s/%s' already registered\n",
345 		     dir->name, dp->name);
346 		write_unlock(&proc_subdir_lock);
347 		proc_free_inum(dp->low_ino);
348 		return -EEXIST;
349 	}
350 	write_unlock(&proc_subdir_lock);
351 
352 	return 0;
353 }
354 
355 static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,
356 					  const char *name,
357 					  umode_t mode,
358 					  nlink_t nlink)
359 {
360 	struct proc_dir_entry *ent = NULL;
361 	const char *fn;
362 	struct qstr qstr;
363 
364 	if (xlate_proc_name(name, parent, &fn) != 0)
365 		goto out;
366 	qstr.name = fn;
367 	qstr.len = strlen(fn);
368 	if (qstr.len == 0 || qstr.len >= 256) {
369 		WARN(1, "name len %u\n", qstr.len);
370 		return NULL;
371 	}
372 	if (*parent == &proc_root && name_to_int(&qstr) != ~0U) {
373 		WARN(1, "create '/proc/%s' by hand\n", qstr.name);
374 		return NULL;
375 	}
376 	if (is_empty_pde(*parent)) {
377 		WARN(1, "attempt to add to permanently empty directory");
378 		return NULL;
379 	}
380 
381 	ent = kzalloc(sizeof(struct proc_dir_entry) + qstr.len + 1, GFP_KERNEL);
382 	if (!ent)
383 		goto out;
384 
385 	memcpy(ent->name, fn, qstr.len + 1);
386 	ent->namelen = qstr.len;
387 	ent->mode = mode;
388 	ent->nlink = nlink;
389 	ent->subdir = RB_ROOT;
390 	atomic_set(&ent->count, 1);
391 	spin_lock_init(&ent->pde_unload_lock);
392 	INIT_LIST_HEAD(&ent->pde_openers);
393 	proc_set_user(ent, (*parent)->uid, (*parent)->gid);
394 
395 out:
396 	return ent;
397 }
398 
399 struct proc_dir_entry *proc_symlink(const char *name,
400 		struct proc_dir_entry *parent, const char *dest)
401 {
402 	struct proc_dir_entry *ent;
403 
404 	ent = __proc_create(&parent, name,
405 			  (S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1);
406 
407 	if (ent) {
408 		ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL);
409 		if (ent->data) {
410 			strcpy((char*)ent->data,dest);
411 			ent->proc_iops = &proc_link_inode_operations;
412 			if (proc_register(parent, ent) < 0) {
413 				kfree(ent->data);
414 				kfree(ent);
415 				ent = NULL;
416 			}
417 		} else {
418 			kfree(ent);
419 			ent = NULL;
420 		}
421 	}
422 	return ent;
423 }
424 EXPORT_SYMBOL(proc_symlink);
425 
426 struct proc_dir_entry *proc_mkdir_data(const char *name, umode_t mode,
427 		struct proc_dir_entry *parent, void *data)
428 {
429 	struct proc_dir_entry *ent;
430 
431 	if (mode == 0)
432 		mode = S_IRUGO | S_IXUGO;
433 
434 	ent = __proc_create(&parent, name, S_IFDIR | mode, 2);
435 	if (ent) {
436 		ent->data = data;
437 		ent->proc_fops = &proc_dir_operations;
438 		ent->proc_iops = &proc_dir_inode_operations;
439 		parent->nlink++;
440 		if (proc_register(parent, ent) < 0) {
441 			kfree(ent);
442 			parent->nlink--;
443 			ent = NULL;
444 		}
445 	}
446 	return ent;
447 }
448 EXPORT_SYMBOL_GPL(proc_mkdir_data);
449 
450 struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode,
451 				       struct proc_dir_entry *parent)
452 {
453 	return proc_mkdir_data(name, mode, parent, NULL);
454 }
455 EXPORT_SYMBOL(proc_mkdir_mode);
456 
457 struct proc_dir_entry *proc_mkdir(const char *name,
458 		struct proc_dir_entry *parent)
459 {
460 	return proc_mkdir_data(name, 0, parent, NULL);
461 }
462 EXPORT_SYMBOL(proc_mkdir);
463 
464 struct proc_dir_entry *proc_create_mount_point(const char *name)
465 {
466 	umode_t mode = S_IFDIR | S_IRUGO | S_IXUGO;
467 	struct proc_dir_entry *ent, *parent = NULL;
468 
469 	ent = __proc_create(&parent, name, mode, 2);
470 	if (ent) {
471 		ent->data = NULL;
472 		ent->proc_fops = NULL;
473 		ent->proc_iops = NULL;
474 		if (proc_register(parent, ent) < 0) {
475 			kfree(ent);
476 			parent->nlink--;
477 			ent = NULL;
478 		}
479 	}
480 	return ent;
481 }
482 EXPORT_SYMBOL(proc_create_mount_point);
483 
484 struct proc_dir_entry *proc_create_data(const char *name, umode_t mode,
485 					struct proc_dir_entry *parent,
486 					const struct file_operations *proc_fops,
487 					void *data)
488 {
489 	struct proc_dir_entry *pde;
490 	if ((mode & S_IFMT) == 0)
491 		mode |= S_IFREG;
492 
493 	if (!S_ISREG(mode)) {
494 		WARN_ON(1);	/* use proc_mkdir() */
495 		return NULL;
496 	}
497 
498 	BUG_ON(proc_fops == NULL);
499 
500 	if ((mode & S_IALLUGO) == 0)
501 		mode |= S_IRUGO;
502 	pde = __proc_create(&parent, name, mode, 1);
503 	if (!pde)
504 		goto out;
505 	pde->proc_fops = proc_fops;
506 	pde->data = data;
507 	pde->proc_iops = &proc_file_inode_operations;
508 	if (proc_register(parent, pde) < 0)
509 		goto out_free;
510 	return pde;
511 out_free:
512 	kfree(pde);
513 out:
514 	return NULL;
515 }
516 EXPORT_SYMBOL(proc_create_data);
517 
518 void proc_set_size(struct proc_dir_entry *de, loff_t size)
519 {
520 	de->size = size;
521 }
522 EXPORT_SYMBOL(proc_set_size);
523 
524 void proc_set_user(struct proc_dir_entry *de, kuid_t uid, kgid_t gid)
525 {
526 	de->uid = uid;
527 	de->gid = gid;
528 }
529 EXPORT_SYMBOL(proc_set_user);
530 
531 static void free_proc_entry(struct proc_dir_entry *de)
532 {
533 	proc_free_inum(de->low_ino);
534 
535 	if (S_ISLNK(de->mode))
536 		kfree(de->data);
537 	kfree(de);
538 }
539 
540 void pde_put(struct proc_dir_entry *pde)
541 {
542 	if (atomic_dec_and_test(&pde->count))
543 		free_proc_entry(pde);
544 }
545 
546 /*
547  * Remove a /proc entry and free it if it's not currently in use.
548  */
549 void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
550 {
551 	struct proc_dir_entry *de = NULL;
552 	const char *fn = name;
553 	unsigned int len;
554 
555 	write_lock(&proc_subdir_lock);
556 	if (__xlate_proc_name(name, &parent, &fn) != 0) {
557 		write_unlock(&proc_subdir_lock);
558 		return;
559 	}
560 	len = strlen(fn);
561 
562 	de = pde_subdir_find(parent, fn, len);
563 	if (de)
564 		rb_erase(&de->subdir_node, &parent->subdir);
565 	write_unlock(&proc_subdir_lock);
566 	if (!de) {
567 		WARN(1, "name '%s'\n", name);
568 		return;
569 	}
570 
571 	proc_entry_rundown(de);
572 
573 	if (S_ISDIR(de->mode))
574 		parent->nlink--;
575 	de->nlink = 0;
576 	WARN(pde_subdir_first(de),
577 	     "%s: removing non-empty directory '%s/%s', leaking at least '%s'\n",
578 	     __func__, de->parent->name, de->name, pde_subdir_first(de)->name);
579 	pde_put(de);
580 }
581 EXPORT_SYMBOL(remove_proc_entry);
582 
583 int remove_proc_subtree(const char *name, struct proc_dir_entry *parent)
584 {
585 	struct proc_dir_entry *root = NULL, *de, *next;
586 	const char *fn = name;
587 	unsigned int len;
588 
589 	write_lock(&proc_subdir_lock);
590 	if (__xlate_proc_name(name, &parent, &fn) != 0) {
591 		write_unlock(&proc_subdir_lock);
592 		return -ENOENT;
593 	}
594 	len = strlen(fn);
595 
596 	root = pde_subdir_find(parent, fn, len);
597 	if (!root) {
598 		write_unlock(&proc_subdir_lock);
599 		return -ENOENT;
600 	}
601 	rb_erase(&root->subdir_node, &parent->subdir);
602 
603 	de = root;
604 	while (1) {
605 		next = pde_subdir_first(de);
606 		if (next) {
607 			rb_erase(&next->subdir_node, &de->subdir);
608 			de = next;
609 			continue;
610 		}
611 		write_unlock(&proc_subdir_lock);
612 
613 		proc_entry_rundown(de);
614 		next = de->parent;
615 		if (S_ISDIR(de->mode))
616 			next->nlink--;
617 		de->nlink = 0;
618 		if (de == root)
619 			break;
620 		pde_put(de);
621 
622 		write_lock(&proc_subdir_lock);
623 		de = next;
624 	}
625 	pde_put(root);
626 	return 0;
627 }
628 EXPORT_SYMBOL(remove_proc_subtree);
629 
630 void *proc_get_parent_data(const struct inode *inode)
631 {
632 	struct proc_dir_entry *de = PDE(inode);
633 	return de->parent->data;
634 }
635 EXPORT_SYMBOL_GPL(proc_get_parent_data);
636 
637 void proc_remove(struct proc_dir_entry *de)
638 {
639 	if (de)
640 		remove_proc_subtree(de->name, de->parent);
641 }
642 EXPORT_SYMBOL(proc_remove);
643 
644 void *PDE_DATA(const struct inode *inode)
645 {
646 	return __PDE_DATA(inode);
647 }
648 EXPORT_SYMBOL(PDE_DATA);
649