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