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