xref: /openbmc/linux/fs/proc/generic.c (revision 5bdd5fbb) 
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 #include <linux/seq_file.h>
29 
30 #include "internal.h"
31 
32 static DEFINE_RWLOCK(proc_subdir_lock);
33 
34 struct kmem_cache *proc_dir_entry_cache __ro_after_init;
35 
36 void pde_free(struct proc_dir_entry *pde)
37 {
38 	if (S_ISLNK(pde->mode))
39 		kfree(pde->data);
40 	if (pde->name != pde->inline_name)
41 		kfree(pde->name);
42 	kmem_cache_free(proc_dir_entry_cache, pde);
43 }
44 
45 static int proc_match(const char *name, struct proc_dir_entry *de, unsigned int len)
46 {
47 	if (len < de->namelen)
48 		return -1;
49 	if (len > de->namelen)
50 		return 1;
51 
52 	return memcmp(name, de->name, len);
53 }
54 
55 static struct proc_dir_entry *pde_subdir_first(struct proc_dir_entry *dir)
56 {
57 	return rb_entry_safe(rb_first(&dir->subdir), struct proc_dir_entry,
58 			     subdir_node);
59 }
60 
61 static struct proc_dir_entry *pde_subdir_next(struct proc_dir_entry *dir)
62 {
63 	return rb_entry_safe(rb_next(&dir->subdir_node), struct proc_dir_entry,
64 			     subdir_node);
65 }
66 
67 static struct proc_dir_entry *pde_subdir_find(struct proc_dir_entry *dir,
68 					      const char *name,
69 					      unsigned int len)
70 {
71 	struct rb_node *node = dir->subdir.rb_node;
72 
73 	while (node) {
74 		struct proc_dir_entry *de = rb_entry(node,
75 						     struct proc_dir_entry,
76 						     subdir_node);
77 		int result = proc_match(name, de, len);
78 
79 		if (result < 0)
80 			node = node->rb_left;
81 		else if (result > 0)
82 			node = node->rb_right;
83 		else
84 			return de;
85 	}
86 	return NULL;
87 }
88 
89 static bool pde_subdir_insert(struct proc_dir_entry *dir,
90 			      struct proc_dir_entry *de)
91 {
92 	struct rb_root *root = &dir->subdir;
93 	struct rb_node **new = &root->rb_node, *parent = NULL;
94 
95 	/* Figure out where to put new node */
96 	while (*new) {
97 		struct proc_dir_entry *this = rb_entry(*new,
98 						       struct proc_dir_entry,
99 						       subdir_node);
100 		int result = proc_match(de->name, this, de->namelen);
101 
102 		parent = *new;
103 		if (result < 0)
104 			new = &(*new)->rb_left;
105 		else if (result > 0)
106 			new = &(*new)->rb_right;
107 		else
108 			return false;
109 	}
110 
111 	/* Add new node and rebalance tree. */
112 	rb_link_node(&de->subdir_node, parent, new);
113 	rb_insert_color(&de->subdir_node, root);
114 	return true;
115 }
116 
117 static int proc_notify_change(struct dentry *dentry, struct iattr *iattr)
118 {
119 	struct inode *inode = d_inode(dentry);
120 	struct proc_dir_entry *de = PDE(inode);
121 	int error;
122 
123 	error = setattr_prepare(dentry, iattr);
124 	if (error)
125 		return error;
126 
127 	setattr_copy(inode, iattr);
128 	mark_inode_dirty(inode);
129 
130 	proc_set_user(de, inode->i_uid, inode->i_gid);
131 	de->mode = inode->i_mode;
132 	return 0;
133 }
134 
135 static int proc_getattr(const struct path *path, struct kstat *stat,
136 			u32 request_mask, unsigned int query_flags)
137 {
138 	struct inode *inode = d_inode(path->dentry);
139 	struct proc_dir_entry *de = PDE(inode);
140 	if (de && de->nlink)
141 		set_nlink(inode, de->nlink);
142 
143 	generic_fillattr(inode, stat);
144 	return 0;
145 }
146 
147 static const struct inode_operations proc_file_inode_operations = {
148 	.setattr	= proc_notify_change,
149 };
150 
151 /*
152  * This function parses a name such as "tty/driver/serial", and
153  * returns the struct proc_dir_entry for "/proc/tty/driver", and
154  * returns "serial" in residual.
155  */
156 static int __xlate_proc_name(const char *name, struct proc_dir_entry **ret,
157 			     const char **residual)
158 {
159 	const char     		*cp = name, *next;
160 	struct proc_dir_entry	*de;
161 	unsigned int		len;
162 
163 	de = *ret;
164 	if (!de)
165 		de = &proc_root;
166 
167 	while (1) {
168 		next = strchr(cp, '/');
169 		if (!next)
170 			break;
171 
172 		len = next - cp;
173 		de = pde_subdir_find(de, cp, len);
174 		if (!de) {
175 			WARN(1, "name '%s'\n", name);
176 			return -ENOENT;
177 		}
178 		cp += len + 1;
179 	}
180 	*residual = cp;
181 	*ret = de;
182 	return 0;
183 }
184 
185 static int xlate_proc_name(const char *name, struct proc_dir_entry **ret,
186 			   const char **residual)
187 {
188 	int rv;
189 
190 	read_lock(&proc_subdir_lock);
191 	rv = __xlate_proc_name(name, ret, residual);
192 	read_unlock(&proc_subdir_lock);
193 	return rv;
194 }
195 
196 static DEFINE_IDA(proc_inum_ida);
197 
198 #define PROC_DYNAMIC_FIRST 0xF0000000U
199 
200 /*
201  * Return an inode number between PROC_DYNAMIC_FIRST and
202  * 0xffffffff, or zero on failure.
203  */
204 int proc_alloc_inum(unsigned int *inum)
205 {
206 	int i;
207 
208 	i = ida_simple_get(&proc_inum_ida, 0, UINT_MAX - PROC_DYNAMIC_FIRST + 1,
209 			   GFP_KERNEL);
210 	if (i < 0)
211 		return i;
212 
213 	*inum = PROC_DYNAMIC_FIRST + (unsigned int)i;
214 	return 0;
215 }
216 
217 void proc_free_inum(unsigned int inum)
218 {
219 	ida_simple_remove(&proc_inum_ida, inum - PROC_DYNAMIC_FIRST);
220 }
221 
222 static int proc_misc_d_revalidate(struct dentry *dentry, unsigned int flags)
223 {
224 	if (flags & LOOKUP_RCU)
225 		return -ECHILD;
226 
227 	if (atomic_read(&PDE(d_inode(dentry))->in_use) < 0)
228 		return 0; /* revalidate */
229 	return 1;
230 }
231 
232 static int proc_misc_d_delete(const struct dentry *dentry)
233 {
234 	return atomic_read(&PDE(d_inode(dentry))->in_use) < 0;
235 }
236 
237 static const struct dentry_operations proc_misc_dentry_ops = {
238 	.d_revalidate	= proc_misc_d_revalidate,
239 	.d_delete	= proc_misc_d_delete,
240 };
241 
242 /*
243  * Don't create negative dentries here, return -ENOENT by hand
244  * instead.
245  */
246 struct dentry *proc_lookup_de(struct inode *dir, struct dentry *dentry,
247 			      struct proc_dir_entry *de)
248 {
249 	struct inode *inode;
250 
251 	read_lock(&proc_subdir_lock);
252 	de = pde_subdir_find(de, dentry->d_name.name, dentry->d_name.len);
253 	if (de) {
254 		pde_get(de);
255 		read_unlock(&proc_subdir_lock);
256 		inode = proc_get_inode(dir->i_sb, de);
257 		if (!inode)
258 			return ERR_PTR(-ENOMEM);
259 		d_set_d_op(dentry, &proc_misc_dentry_ops);
260 		return d_splice_alias(inode, dentry);
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 /* returns the registered entry, or frees dp and returns NULL on failure */
350 struct proc_dir_entry *proc_register(struct proc_dir_entry *dir,
351 		struct proc_dir_entry *dp)
352 {
353 	if (proc_alloc_inum(&dp->low_ino))
354 		goto out_free_entry;
355 
356 	write_lock(&proc_subdir_lock);
357 	dp->parent = dir;
358 	if (pde_subdir_insert(dir, dp) == false) {
359 		WARN(1, "proc_dir_entry '%s/%s' already registered\n",
360 		     dir->name, dp->name);
361 		write_unlock(&proc_subdir_lock);
362 		goto out_free_inum;
363 	}
364 	write_unlock(&proc_subdir_lock);
365 
366 	return dp;
367 out_free_inum:
368 	proc_free_inum(dp->low_ino);
369 out_free_entry:
370 	pde_free(dp);
371 	return NULL;
372 }
373 
374 static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,
375 					  const char *name,
376 					  umode_t mode,
377 					  nlink_t nlink)
378 {
379 	struct proc_dir_entry *ent = NULL;
380 	const char *fn;
381 	struct qstr qstr;
382 
383 	if (xlate_proc_name(name, parent, &fn) != 0)
384 		goto out;
385 	qstr.name = fn;
386 	qstr.len = strlen(fn);
387 	if (qstr.len == 0 || qstr.len >= 256) {
388 		WARN(1, "name len %u\n", qstr.len);
389 		return NULL;
390 	}
391 	if (qstr.len == 1 && fn[0] == '.') {
392 		WARN(1, "name '.'\n");
393 		return NULL;
394 	}
395 	if (qstr.len == 2 && fn[0] == '.' && fn[1] == '.') {
396 		WARN(1, "name '..'\n");
397 		return NULL;
398 	}
399 	if (*parent == &proc_root && name_to_int(&qstr) != ~0U) {
400 		WARN(1, "create '/proc/%s' by hand\n", qstr.name);
401 		return NULL;
402 	}
403 	if (is_empty_pde(*parent)) {
404 		WARN(1, "attempt to add to permanently empty directory");
405 		return NULL;
406 	}
407 
408 	ent = kmem_cache_zalloc(proc_dir_entry_cache, GFP_KERNEL);
409 	if (!ent)
410 		goto out;
411 
412 	if (qstr.len + 1 <= SIZEOF_PDE_INLINE_NAME) {
413 		ent->name = ent->inline_name;
414 	} else {
415 		ent->name = kmalloc(qstr.len + 1, GFP_KERNEL);
416 		if (!ent->name) {
417 			pde_free(ent);
418 			return NULL;
419 		}
420 	}
421 
422 	memcpy(ent->name, fn, qstr.len + 1);
423 	ent->namelen = qstr.len;
424 	ent->mode = mode;
425 	ent->nlink = nlink;
426 	ent->subdir = RB_ROOT;
427 	refcount_set(&ent->refcnt, 1);
428 	spin_lock_init(&ent->pde_unload_lock);
429 	INIT_LIST_HEAD(&ent->pde_openers);
430 	proc_set_user(ent, (*parent)->uid, (*parent)->gid);
431 
432 out:
433 	return ent;
434 }
435 
436 struct proc_dir_entry *proc_symlink(const char *name,
437 		struct proc_dir_entry *parent, const char *dest)
438 {
439 	struct proc_dir_entry *ent;
440 
441 	ent = __proc_create(&parent, name,
442 			  (S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1);
443 
444 	if (ent) {
445 		ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL);
446 		if (ent->data) {
447 			strcpy((char*)ent->data,dest);
448 			ent->proc_iops = &proc_link_inode_operations;
449 			ent = proc_register(parent, ent);
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 		ent = proc_register(parent, ent);
474 		if (!ent)
475 			parent->nlink--;
476 	}
477 	return ent;
478 }
479 EXPORT_SYMBOL_GPL(proc_mkdir_data);
480 
481 struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode,
482 				       struct proc_dir_entry *parent)
483 {
484 	return proc_mkdir_data(name, mode, parent, NULL);
485 }
486 EXPORT_SYMBOL(proc_mkdir_mode);
487 
488 struct proc_dir_entry *proc_mkdir(const char *name,
489 		struct proc_dir_entry *parent)
490 {
491 	return proc_mkdir_data(name, 0, parent, NULL);
492 }
493 EXPORT_SYMBOL(proc_mkdir);
494 
495 struct proc_dir_entry *proc_create_mount_point(const char *name)
496 {
497 	umode_t mode = S_IFDIR | S_IRUGO | S_IXUGO;
498 	struct proc_dir_entry *ent, *parent = NULL;
499 
500 	ent = __proc_create(&parent, name, mode, 2);
501 	if (ent) {
502 		ent->data = NULL;
503 		ent->proc_fops = NULL;
504 		ent->proc_iops = NULL;
505 		parent->nlink++;
506 		ent = proc_register(parent, ent);
507 		if (!ent)
508 			parent->nlink--;
509 	}
510 	return ent;
511 }
512 EXPORT_SYMBOL(proc_create_mount_point);
513 
514 struct proc_dir_entry *proc_create_reg(const char *name, umode_t mode,
515 		struct proc_dir_entry **parent, void *data)
516 {
517 	struct proc_dir_entry *p;
518 
519 	if ((mode & S_IFMT) == 0)
520 		mode |= S_IFREG;
521 	if ((mode & S_IALLUGO) == 0)
522 		mode |= S_IRUGO;
523 	if (WARN_ON_ONCE(!S_ISREG(mode)))
524 		return NULL;
525 
526 	p = __proc_create(parent, name, mode, 1);
527 	if (p) {
528 		p->proc_iops = &proc_file_inode_operations;
529 		p->data = data;
530 	}
531 	return p;
532 }
533 
534 struct proc_dir_entry *proc_create_data(const char *name, umode_t mode,
535 		struct proc_dir_entry *parent,
536 		const struct file_operations *proc_fops, void *data)
537 {
538 	struct proc_dir_entry *p;
539 
540 	BUG_ON(proc_fops == NULL);
541 
542 	p = proc_create_reg(name, mode, &parent, data);
543 	if (!p)
544 		return NULL;
545 	p->proc_fops = proc_fops;
546 	return proc_register(parent, p);
547 }
548 EXPORT_SYMBOL(proc_create_data);
549 
550 struct proc_dir_entry *proc_create(const char *name, umode_t mode,
551 				   struct proc_dir_entry *parent,
552 				   const struct file_operations *proc_fops)
553 {
554 	return proc_create_data(name, mode, parent, proc_fops, NULL);
555 }
556 EXPORT_SYMBOL(proc_create);
557 
558 static int proc_seq_open(struct inode *inode, struct file *file)
559 {
560 	struct proc_dir_entry *de = PDE(inode);
561 
562 	if (de->state_size)
563 		return seq_open_private(file, de->seq_ops, de->state_size);
564 	return seq_open(file, de->seq_ops);
565 }
566 
567 static const struct file_operations proc_seq_fops = {
568 	.open		= proc_seq_open,
569 	.read		= seq_read,
570 	.llseek		= seq_lseek,
571 	.release	= seq_release,
572 };
573 
574 struct proc_dir_entry *proc_create_seq_private(const char *name, umode_t mode,
575 		struct proc_dir_entry *parent, const struct seq_operations *ops,
576 		unsigned int state_size, void *data)
577 {
578 	struct proc_dir_entry *p;
579 
580 	p = proc_create_reg(name, mode, &parent, data);
581 	if (!p)
582 		return NULL;
583 	p->proc_fops = &proc_seq_fops;
584 	p->seq_ops = ops;
585 	p->state_size = state_size;
586 	return proc_register(parent, p);
587 }
588 EXPORT_SYMBOL(proc_create_seq_private);
589 
590 static int proc_single_open(struct inode *inode, struct file *file)
591 {
592 	struct proc_dir_entry *de = PDE(inode);
593 
594 	return single_open(file, de->single_show, de->data);
595 }
596 
597 static const struct file_operations proc_single_fops = {
598 	.open		= proc_single_open,
599 	.read		= seq_read,
600 	.llseek		= seq_lseek,
601 	.release	= single_release,
602 };
603 
604 struct proc_dir_entry *proc_create_single_data(const char *name, umode_t mode,
605 		struct proc_dir_entry *parent,
606 		int (*show)(struct seq_file *, void *), void *data)
607 {
608 	struct proc_dir_entry *p;
609 
610 	p = proc_create_reg(name, mode, &parent, data);
611 	if (!p)
612 		return NULL;
613 	p->proc_fops = &proc_single_fops;
614 	p->single_show = show;
615 	return proc_register(parent, p);
616 }
617 EXPORT_SYMBOL(proc_create_single_data);
618 
619 void proc_set_size(struct proc_dir_entry *de, loff_t size)
620 {
621 	de->size = size;
622 }
623 EXPORT_SYMBOL(proc_set_size);
624 
625 void proc_set_user(struct proc_dir_entry *de, kuid_t uid, kgid_t gid)
626 {
627 	de->uid = uid;
628 	de->gid = gid;
629 }
630 EXPORT_SYMBOL(proc_set_user);
631 
632 void pde_put(struct proc_dir_entry *pde)
633 {
634 	if (refcount_dec_and_test(&pde->refcnt)) {
635 		proc_free_inum(pde->low_ino);
636 		pde_free(pde);
637 	}
638 }
639 
640 /*
641  * Remove a /proc entry and free it if it's not currently in use.
642  */
643 void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
644 {
645 	struct proc_dir_entry *de = NULL;
646 	const char *fn = name;
647 	unsigned int len;
648 
649 	write_lock(&proc_subdir_lock);
650 	if (__xlate_proc_name(name, &parent, &fn) != 0) {
651 		write_unlock(&proc_subdir_lock);
652 		return;
653 	}
654 	len = strlen(fn);
655 
656 	de = pde_subdir_find(parent, fn, len);
657 	if (de)
658 		rb_erase(&de->subdir_node, &parent->subdir);
659 	write_unlock(&proc_subdir_lock);
660 	if (!de) {
661 		WARN(1, "name '%s'\n", name);
662 		return;
663 	}
664 
665 	proc_entry_rundown(de);
666 
667 	if (S_ISDIR(de->mode))
668 		parent->nlink--;
669 	de->nlink = 0;
670 	WARN(pde_subdir_first(de),
671 	     "%s: removing non-empty directory '%s/%s', leaking at least '%s'\n",
672 	     __func__, de->parent->name, de->name, pde_subdir_first(de)->name);
673 	pde_put(de);
674 }
675 EXPORT_SYMBOL(remove_proc_entry);
676 
677 int remove_proc_subtree(const char *name, struct proc_dir_entry *parent)
678 {
679 	struct proc_dir_entry *root = NULL, *de, *next;
680 	const char *fn = name;
681 	unsigned int len;
682 
683 	write_lock(&proc_subdir_lock);
684 	if (__xlate_proc_name(name, &parent, &fn) != 0) {
685 		write_unlock(&proc_subdir_lock);
686 		return -ENOENT;
687 	}
688 	len = strlen(fn);
689 
690 	root = pde_subdir_find(parent, fn, len);
691 	if (!root) {
692 		write_unlock(&proc_subdir_lock);
693 		return -ENOENT;
694 	}
695 	rb_erase(&root->subdir_node, &parent->subdir);
696 
697 	de = root;
698 	while (1) {
699 		next = pde_subdir_first(de);
700 		if (next) {
701 			rb_erase(&next->subdir_node, &de->subdir);
702 			de = next;
703 			continue;
704 		}
705 		write_unlock(&proc_subdir_lock);
706 
707 		proc_entry_rundown(de);
708 		next = de->parent;
709 		if (S_ISDIR(de->mode))
710 			next->nlink--;
711 		de->nlink = 0;
712 		if (de == root)
713 			break;
714 		pde_put(de);
715 
716 		write_lock(&proc_subdir_lock);
717 		de = next;
718 	}
719 	pde_put(root);
720 	return 0;
721 }
722 EXPORT_SYMBOL(remove_proc_subtree);
723 
724 void *proc_get_parent_data(const struct inode *inode)
725 {
726 	struct proc_dir_entry *de = PDE(inode);
727 	return de->parent->data;
728 }
729 EXPORT_SYMBOL_GPL(proc_get_parent_data);
730 
731 void proc_remove(struct proc_dir_entry *de)
732 {
733 	if (de)
734 		remove_proc_subtree(de->name, de->parent);
735 }
736 EXPORT_SYMBOL(proc_remove);
737 
738 void *PDE_DATA(const struct inode *inode)
739 {
740 	return __PDE_DATA(inode);
741 }
742 EXPORT_SYMBOL(PDE_DATA);
743 
744 /*
745  * Pull a user buffer into memory and pass it to the file's write handler if
746  * one is supplied.  The ->write() method is permitted to modify the
747  * kernel-side buffer.
748  */
749 ssize_t proc_simple_write(struct file *f, const char __user *ubuf, size_t size,
750 			  loff_t *_pos)
751 {
752 	struct proc_dir_entry *pde = PDE(file_inode(f));
753 	char *buf;
754 	int ret;
755 
756 	if (!pde->write)
757 		return -EACCES;
758 	if (size == 0 || size > PAGE_SIZE - 1)
759 		return -EINVAL;
760 	buf = memdup_user_nul(ubuf, size);
761 	if (IS_ERR(buf))
762 		return PTR_ERR(buf);
763 	ret = pde->write(f, buf, size);
764 	kfree(buf);
765 	return ret == 0 ? size : ret;
766 }
767