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