xref: /openbmc/linux/fs/proc/generic.c (revision eb3fcf00) 
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 <asm/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 = inode_change_ok(inode, 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		= 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 out:
394 	return ent;
395 }
396 
397 struct proc_dir_entry *proc_symlink(const char *name,
398 		struct proc_dir_entry *parent, const char *dest)
399 {
400 	struct proc_dir_entry *ent;
401 
402 	ent = __proc_create(&parent, name,
403 			  (S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1);
404 
405 	if (ent) {
406 		ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL);
407 		if (ent->data) {
408 			strcpy((char*)ent->data,dest);
409 			ent->proc_iops = &proc_link_inode_operations;
410 			if (proc_register(parent, ent) < 0) {
411 				kfree(ent->data);
412 				kfree(ent);
413 				ent = NULL;
414 			}
415 		} else {
416 			kfree(ent);
417 			ent = NULL;
418 		}
419 	}
420 	return ent;
421 }
422 EXPORT_SYMBOL(proc_symlink);
423 
424 struct proc_dir_entry *proc_mkdir_data(const char *name, umode_t mode,
425 		struct proc_dir_entry *parent, void *data)
426 {
427 	struct proc_dir_entry *ent;
428 
429 	if (mode == 0)
430 		mode = S_IRUGO | S_IXUGO;
431 
432 	ent = __proc_create(&parent, name, S_IFDIR | mode, 2);
433 	if (ent) {
434 		ent->data = data;
435 		ent->proc_fops = &proc_dir_operations;
436 		ent->proc_iops = &proc_dir_inode_operations;
437 		parent->nlink++;
438 		if (proc_register(parent, ent) < 0) {
439 			kfree(ent);
440 			parent->nlink--;
441 			ent = NULL;
442 		}
443 	}
444 	return ent;
445 }
446 EXPORT_SYMBOL_GPL(proc_mkdir_data);
447 
448 struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode,
449 				       struct proc_dir_entry *parent)
450 {
451 	return proc_mkdir_data(name, mode, parent, NULL);
452 }
453 EXPORT_SYMBOL(proc_mkdir_mode);
454 
455 struct proc_dir_entry *proc_mkdir(const char *name,
456 		struct proc_dir_entry *parent)
457 {
458 	return proc_mkdir_data(name, 0, parent, NULL);
459 }
460 EXPORT_SYMBOL(proc_mkdir);
461 
462 struct proc_dir_entry *proc_create_mount_point(const char *name)
463 {
464 	umode_t mode = S_IFDIR | S_IRUGO | S_IXUGO;
465 	struct proc_dir_entry *ent, *parent = NULL;
466 
467 	ent = __proc_create(&parent, name, mode, 2);
468 	if (ent) {
469 		ent->data = NULL;
470 		ent->proc_fops = NULL;
471 		ent->proc_iops = NULL;
472 		if (proc_register(parent, ent) < 0) {
473 			kfree(ent);
474 			parent->nlink--;
475 			ent = NULL;
476 		}
477 	}
478 	return ent;
479 }
480 
481 struct proc_dir_entry *proc_create_data(const char *name, umode_t mode,
482 					struct proc_dir_entry *parent,
483 					const struct file_operations *proc_fops,
484 					void *data)
485 {
486 	struct proc_dir_entry *pde;
487 	if ((mode & S_IFMT) == 0)
488 		mode |= S_IFREG;
489 
490 	if (!S_ISREG(mode)) {
491 		WARN_ON(1);	/* use proc_mkdir() */
492 		return NULL;
493 	}
494 
495 	BUG_ON(proc_fops == NULL);
496 
497 	if ((mode & S_IALLUGO) == 0)
498 		mode |= S_IRUGO;
499 	pde = __proc_create(&parent, name, mode, 1);
500 	if (!pde)
501 		goto out;
502 	pde->proc_fops = proc_fops;
503 	pde->data = data;
504 	pde->proc_iops = &proc_file_inode_operations;
505 	if (proc_register(parent, pde) < 0)
506 		goto out_free;
507 	return pde;
508 out_free:
509 	kfree(pde);
510 out:
511 	return NULL;
512 }
513 EXPORT_SYMBOL(proc_create_data);
514 
515 void proc_set_size(struct proc_dir_entry *de, loff_t size)
516 {
517 	de->size = size;
518 }
519 EXPORT_SYMBOL(proc_set_size);
520 
521 void proc_set_user(struct proc_dir_entry *de, kuid_t uid, kgid_t gid)
522 {
523 	de->uid = uid;
524 	de->gid = gid;
525 }
526 EXPORT_SYMBOL(proc_set_user);
527 
528 static void free_proc_entry(struct proc_dir_entry *de)
529 {
530 	proc_free_inum(de->low_ino);
531 
532 	if (S_ISLNK(de->mode))
533 		kfree(de->data);
534 	kfree(de);
535 }
536 
537 void pde_put(struct proc_dir_entry *pde)
538 {
539 	if (atomic_dec_and_test(&pde->count))
540 		free_proc_entry(pde);
541 }
542 
543 /*
544  * Remove a /proc entry and free it if it's not currently in use.
545  */
546 void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
547 {
548 	struct proc_dir_entry *de = NULL;
549 	const char *fn = name;
550 	unsigned int len;
551 
552 	write_lock(&proc_subdir_lock);
553 	if (__xlate_proc_name(name, &parent, &fn) != 0) {
554 		write_unlock(&proc_subdir_lock);
555 		return;
556 	}
557 	len = strlen(fn);
558 
559 	de = pde_subdir_find(parent, fn, len);
560 	if (de)
561 		rb_erase(&de->subdir_node, &parent->subdir);
562 	write_unlock(&proc_subdir_lock);
563 	if (!de) {
564 		WARN(1, "name '%s'\n", name);
565 		return;
566 	}
567 
568 	proc_entry_rundown(de);
569 
570 	if (S_ISDIR(de->mode))
571 		parent->nlink--;
572 	de->nlink = 0;
573 	WARN(pde_subdir_first(de),
574 	     "%s: removing non-empty directory '%s/%s', leaking at least '%s'\n",
575 	     __func__, de->parent->name, de->name, pde_subdir_first(de)->name);
576 	pde_put(de);
577 }
578 EXPORT_SYMBOL(remove_proc_entry);
579 
580 int remove_proc_subtree(const char *name, struct proc_dir_entry *parent)
581 {
582 	struct proc_dir_entry *root = NULL, *de, *next;
583 	const char *fn = name;
584 	unsigned int len;
585 
586 	write_lock(&proc_subdir_lock);
587 	if (__xlate_proc_name(name, &parent, &fn) != 0) {
588 		write_unlock(&proc_subdir_lock);
589 		return -ENOENT;
590 	}
591 	len = strlen(fn);
592 
593 	root = pde_subdir_find(parent, fn, len);
594 	if (!root) {
595 		write_unlock(&proc_subdir_lock);
596 		return -ENOENT;
597 	}
598 	rb_erase(&root->subdir_node, &parent->subdir);
599 
600 	de = root;
601 	while (1) {
602 		next = pde_subdir_first(de);
603 		if (next) {
604 			rb_erase(&next->subdir_node, &de->subdir);
605 			de = next;
606 			continue;
607 		}
608 		write_unlock(&proc_subdir_lock);
609 
610 		proc_entry_rundown(de);
611 		next = de->parent;
612 		if (S_ISDIR(de->mode))
613 			next->nlink--;
614 		de->nlink = 0;
615 		if (de == root)
616 			break;
617 		pde_put(de);
618 
619 		write_lock(&proc_subdir_lock);
620 		de = next;
621 	}
622 	pde_put(root);
623 	return 0;
624 }
625 EXPORT_SYMBOL(remove_proc_subtree);
626 
627 void *proc_get_parent_data(const struct inode *inode)
628 {
629 	struct proc_dir_entry *de = PDE(inode);
630 	return de->parent->data;
631 }
632 EXPORT_SYMBOL_GPL(proc_get_parent_data);
633 
634 void proc_remove(struct proc_dir_entry *de)
635 {
636 	if (de)
637 		remove_proc_subtree(de->name, de->parent);
638 }
639 EXPORT_SYMBOL(proc_remove);
640 
641 void *PDE_DATA(const struct inode *inode)
642 {
643 	return __PDE_DATA(inode);
644 }
645 EXPORT_SYMBOL(PDE_DATA);
646