GNU Linux-libre 4.19.211-gnu1
[releases.git] / fs / proc / generic.c
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) {
141                 nlink_t nlink = READ_ONCE(de->nlink);
142                 if (nlink > 0) {
143                         set_nlink(inode, nlink);
144                 }
145         }
146
147         generic_fillattr(inode, stat);
148         return 0;
149 }
150
151 static const struct inode_operations proc_file_inode_operations = {
152         .setattr        = proc_notify_change,
153 };
154
155 /*
156  * This function parses a name such as "tty/driver/serial", and
157  * returns the struct proc_dir_entry for "/proc/tty/driver", and
158  * returns "serial" in residual.
159  */
160 static int __xlate_proc_name(const char *name, struct proc_dir_entry **ret,
161                              const char **residual)
162 {
163         const char              *cp = name, *next;
164         struct proc_dir_entry   *de;
165         unsigned int            len;
166
167         de = *ret;
168         if (!de)
169                 de = &proc_root;
170
171         while (1) {
172                 next = strchr(cp, '/');
173                 if (!next)
174                         break;
175
176                 len = next - cp;
177                 de = pde_subdir_find(de, cp, len);
178                 if (!de) {
179                         WARN(1, "name '%s'\n", name);
180                         return -ENOENT;
181                 }
182                 cp += len + 1;
183         }
184         *residual = cp;
185         *ret = de;
186         return 0;
187 }
188
189 static int xlate_proc_name(const char *name, struct proc_dir_entry **ret,
190                            const char **residual)
191 {
192         int rv;
193
194         read_lock(&proc_subdir_lock);
195         rv = __xlate_proc_name(name, ret, residual);
196         read_unlock(&proc_subdir_lock);
197         return rv;
198 }
199
200 static DEFINE_IDA(proc_inum_ida);
201
202 #define PROC_DYNAMIC_FIRST 0xF0000000U
203
204 /*
205  * Return an inode number between PROC_DYNAMIC_FIRST and
206  * 0xffffffff, or zero on failure.
207  */
208 int proc_alloc_inum(unsigned int *inum)
209 {
210         int i;
211
212         i = ida_simple_get(&proc_inum_ida, 0, UINT_MAX - PROC_DYNAMIC_FIRST + 1,
213                            GFP_KERNEL);
214         if (i < 0)
215                 return i;
216
217         *inum = PROC_DYNAMIC_FIRST + (unsigned int)i;
218         return 0;
219 }
220
221 void proc_free_inum(unsigned int inum)
222 {
223         ida_simple_remove(&proc_inum_ida, inum - PROC_DYNAMIC_FIRST);
224 }
225
226 static int proc_misc_d_revalidate(struct dentry *dentry, unsigned int flags)
227 {
228         if (flags & LOOKUP_RCU)
229                 return -ECHILD;
230
231         if (atomic_read(&PDE(d_inode(dentry))->in_use) < 0)
232                 return 0; /* revalidate */
233         return 1;
234 }
235
236 static int proc_misc_d_delete(const struct dentry *dentry)
237 {
238         return atomic_read(&PDE(d_inode(dentry))->in_use) < 0;
239 }
240
241 static const struct dentry_operations proc_misc_dentry_ops = {
242         .d_revalidate   = proc_misc_d_revalidate,
243         .d_delete       = proc_misc_d_delete,
244 };
245
246 /*
247  * Don't create negative dentries here, return -ENOENT by hand
248  * instead.
249  */
250 struct dentry *proc_lookup_de(struct inode *dir, struct dentry *dentry,
251                               struct proc_dir_entry *de)
252 {
253         struct inode *inode;
254
255         read_lock(&proc_subdir_lock);
256         de = pde_subdir_find(de, dentry->d_name.name, dentry->d_name.len);
257         if (de) {
258                 pde_get(de);
259                 read_unlock(&proc_subdir_lock);
260                 inode = proc_get_inode(dir->i_sb, de);
261                 if (!inode)
262                         return ERR_PTR(-ENOMEM);
263                 d_set_d_op(dentry, de->proc_dops);
264                 return d_splice_alias(inode, dentry);
265         }
266         read_unlock(&proc_subdir_lock);
267         return ERR_PTR(-ENOENT);
268 }
269
270 struct dentry *proc_lookup(struct inode *dir, struct dentry *dentry,
271                 unsigned int flags)
272 {
273         return proc_lookup_de(dir, dentry, PDE(dir));
274 }
275
276 /*
277  * This returns non-zero if at EOF, so that the /proc
278  * root directory can use this and check if it should
279  * continue with the <pid> entries..
280  *
281  * Note that the VFS-layer doesn't care about the return
282  * value of the readdir() call, as long as it's non-negative
283  * for success..
284  */
285 int proc_readdir_de(struct file *file, struct dir_context *ctx,
286                     struct proc_dir_entry *de)
287 {
288         int i;
289
290         if (!dir_emit_dots(file, ctx))
291                 return 0;
292
293         i = ctx->pos - 2;
294         read_lock(&proc_subdir_lock);
295         de = pde_subdir_first(de);
296         for (;;) {
297                 if (!de) {
298                         read_unlock(&proc_subdir_lock);
299                         return 0;
300                 }
301                 if (!i)
302                         break;
303                 de = pde_subdir_next(de);
304                 i--;
305         }
306
307         do {
308                 struct proc_dir_entry *next;
309                 pde_get(de);
310                 read_unlock(&proc_subdir_lock);
311                 if (!dir_emit(ctx, de->name, de->namelen,
312                             de->low_ino, de->mode >> 12)) {
313                         pde_put(de);
314                         return 0;
315                 }
316                 ctx->pos++;
317                 read_lock(&proc_subdir_lock);
318                 next = pde_subdir_next(de);
319                 pde_put(de);
320                 de = next;
321         } while (de);
322         read_unlock(&proc_subdir_lock);
323         return 1;
324 }
325
326 int proc_readdir(struct file *file, struct dir_context *ctx)
327 {
328         struct inode *inode = file_inode(file);
329
330         return proc_readdir_de(file, ctx, PDE(inode));
331 }
332
333 /*
334  * These are the generic /proc directory operations. They
335  * use the in-memory "struct proc_dir_entry" tree to parse
336  * the /proc directory.
337  */
338 static const struct file_operations proc_dir_operations = {
339         .llseek                 = generic_file_llseek,
340         .read                   = generic_read_dir,
341         .iterate_shared         = proc_readdir,
342 };
343
344 static int proc_net_d_revalidate(struct dentry *dentry, unsigned int flags)
345 {
346         return 0;
347 }
348
349 const struct dentry_operations proc_net_dentry_ops = {
350         .d_revalidate   = proc_net_d_revalidate,
351         .d_delete       = always_delete_dentry,
352 };
353
354 /*
355  * proc directories can do almost nothing..
356  */
357 static const struct inode_operations proc_dir_inode_operations = {
358         .lookup         = proc_lookup,
359         .getattr        = proc_getattr,
360         .setattr        = proc_notify_change,
361 };
362
363 /* returns the registered entry, or frees dp and returns NULL on failure */
364 struct proc_dir_entry *proc_register(struct proc_dir_entry *dir,
365                 struct proc_dir_entry *dp)
366 {
367         if (proc_alloc_inum(&dp->low_ino))
368                 goto out_free_entry;
369
370         write_lock(&proc_subdir_lock);
371         dp->parent = dir;
372         if (pde_subdir_insert(dir, dp) == false) {
373                 WARN(1, "proc_dir_entry '%s/%s' already registered\n",
374                      dir->name, dp->name);
375                 write_unlock(&proc_subdir_lock);
376                 goto out_free_inum;
377         }
378         dir->nlink++;
379         write_unlock(&proc_subdir_lock);
380
381         return dp;
382 out_free_inum:
383         proc_free_inum(dp->low_ino);
384 out_free_entry:
385         pde_free(dp);
386         return NULL;
387 }
388
389 static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,
390                                           const char *name,
391                                           umode_t mode,
392                                           nlink_t nlink)
393 {
394         struct proc_dir_entry *ent = NULL;
395         const char *fn;
396         struct qstr qstr;
397
398         if (xlate_proc_name(name, parent, &fn) != 0)
399                 goto out;
400         qstr.name = fn;
401         qstr.len = strlen(fn);
402         if (qstr.len == 0 || qstr.len >= 256) {
403                 WARN(1, "name len %u\n", qstr.len);
404                 return NULL;
405         }
406         if (qstr.len == 1 && fn[0] == '.') {
407                 WARN(1, "name '.'\n");
408                 return NULL;
409         }
410         if (qstr.len == 2 && fn[0] == '.' && fn[1] == '.') {
411                 WARN(1, "name '..'\n");
412                 return NULL;
413         }
414         if (*parent == &proc_root && name_to_int(&qstr) != ~0U) {
415                 WARN(1, "create '/proc/%s' by hand\n", qstr.name);
416                 return NULL;
417         }
418         if (is_empty_pde(*parent)) {
419                 WARN(1, "attempt to add to permanently empty directory");
420                 return NULL;
421         }
422
423         ent = kmem_cache_zalloc(proc_dir_entry_cache, GFP_KERNEL);
424         if (!ent)
425                 goto out;
426
427         if (qstr.len + 1 <= SIZEOF_PDE_INLINE_NAME) {
428                 ent->name = ent->inline_name;
429         } else {
430                 ent->name = kmalloc(qstr.len + 1, GFP_KERNEL);
431                 if (!ent->name) {
432                         pde_free(ent);
433                         return NULL;
434                 }
435         }
436
437         memcpy(ent->name, fn, qstr.len + 1);
438         ent->namelen = qstr.len;
439         ent->mode = mode;
440         ent->nlink = nlink;
441         ent->subdir = RB_ROOT;
442         refcount_set(&ent->refcnt, 1);
443         spin_lock_init(&ent->pde_unload_lock);
444         INIT_LIST_HEAD(&ent->pde_openers);
445         proc_set_user(ent, (*parent)->uid, (*parent)->gid);
446
447         ent->proc_dops = &proc_misc_dentry_ops;
448
449 out:
450         return ent;
451 }
452
453 struct proc_dir_entry *proc_symlink(const char *name,
454                 struct proc_dir_entry *parent, const char *dest)
455 {
456         struct proc_dir_entry *ent;
457
458         ent = __proc_create(&parent, name,
459                           (S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1);
460
461         if (ent) {
462                 ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL);
463                 if (ent->data) {
464                         strcpy((char*)ent->data,dest);
465                         ent->proc_iops = &proc_link_inode_operations;
466                         ent = proc_register(parent, ent);
467                 } else {
468                         pde_free(ent);
469                         ent = NULL;
470                 }
471         }
472         return ent;
473 }
474 EXPORT_SYMBOL(proc_symlink);
475
476 struct proc_dir_entry *_proc_mkdir(const char *name, umode_t mode,
477                 struct proc_dir_entry *parent, void *data, bool force_lookup)
478 {
479         struct proc_dir_entry *ent;
480
481         if (mode == 0)
482                 mode = S_IRUGO | S_IXUGO;
483
484         ent = __proc_create(&parent, name, S_IFDIR | mode, 2);
485         if (ent) {
486                 ent->data = data;
487                 ent->proc_fops = &proc_dir_operations;
488                 ent->proc_iops = &proc_dir_inode_operations;
489                 if (force_lookup) {
490                         pde_force_lookup(ent);
491                 }
492                 ent = proc_register(parent, ent);
493         }
494         return ent;
495 }
496 EXPORT_SYMBOL_GPL(_proc_mkdir);
497
498 struct proc_dir_entry *proc_mkdir_data(const char *name, umode_t mode,
499                 struct proc_dir_entry *parent, void *data)
500 {
501         return _proc_mkdir(name, mode, parent, data, false);
502 }
503 EXPORT_SYMBOL_GPL(proc_mkdir_data);
504
505 struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode,
506                                        struct proc_dir_entry *parent)
507 {
508         return proc_mkdir_data(name, mode, parent, NULL);
509 }
510 EXPORT_SYMBOL(proc_mkdir_mode);
511
512 struct proc_dir_entry *proc_mkdir(const char *name,
513                 struct proc_dir_entry *parent)
514 {
515         return proc_mkdir_data(name, 0, parent, NULL);
516 }
517 EXPORT_SYMBOL(proc_mkdir);
518
519 struct proc_dir_entry *proc_create_mount_point(const char *name)
520 {
521         umode_t mode = S_IFDIR | S_IRUGO | S_IXUGO;
522         struct proc_dir_entry *ent, *parent = NULL;
523
524         ent = __proc_create(&parent, name, mode, 2);
525         if (ent) {
526                 ent->data = NULL;
527                 ent->proc_fops = NULL;
528                 ent->proc_iops = NULL;
529                 ent = proc_register(parent, ent);
530         }
531         return ent;
532 }
533 EXPORT_SYMBOL(proc_create_mount_point);
534
535 struct proc_dir_entry *proc_create_reg(const char *name, umode_t mode,
536                 struct proc_dir_entry **parent, void *data)
537 {
538         struct proc_dir_entry *p;
539
540         if ((mode & S_IFMT) == 0)
541                 mode |= S_IFREG;
542         if ((mode & S_IALLUGO) == 0)
543                 mode |= S_IRUGO;
544         if (WARN_ON_ONCE(!S_ISREG(mode)))
545                 return NULL;
546
547         p = __proc_create(parent, name, mode, 1);
548         if (p) {
549                 p->proc_iops = &proc_file_inode_operations;
550                 p->data = data;
551         }
552         return p;
553 }
554
555 struct proc_dir_entry *proc_create_data(const char *name, umode_t mode,
556                 struct proc_dir_entry *parent,
557                 const struct file_operations *proc_fops, void *data)
558 {
559         struct proc_dir_entry *p;
560
561         BUG_ON(proc_fops == NULL);
562
563         p = proc_create_reg(name, mode, &parent, data);
564         if (!p)
565                 return NULL;
566         p->proc_fops = proc_fops;
567         return proc_register(parent, p);
568 }
569 EXPORT_SYMBOL(proc_create_data);
570  
571 struct proc_dir_entry *proc_create(const char *name, umode_t mode,
572                                    struct proc_dir_entry *parent,
573                                    const struct file_operations *proc_fops)
574 {
575         return proc_create_data(name, mode, parent, proc_fops, NULL);
576 }
577 EXPORT_SYMBOL(proc_create);
578
579 static int proc_seq_open(struct inode *inode, struct file *file)
580 {
581         struct proc_dir_entry *de = PDE(inode);
582
583         if (de->state_size)
584                 return seq_open_private(file, de->seq_ops, de->state_size);
585         return seq_open(file, de->seq_ops);
586 }
587
588 static int proc_seq_release(struct inode *inode, struct file *file)
589 {
590         struct proc_dir_entry *de = PDE(inode);
591
592         if (de->state_size)
593                 return seq_release_private(inode, file);
594         return seq_release(inode, file);
595 }
596
597 static const struct file_operations proc_seq_fops = {
598         .open           = proc_seq_open,
599         .read           = seq_read,
600         .llseek         = seq_lseek,
601         .release        = proc_seq_release,
602 };
603
604 struct proc_dir_entry *proc_create_seq_private(const char *name, umode_t mode,
605                 struct proc_dir_entry *parent, const struct seq_operations *ops,
606                 unsigned int state_size, 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_seq_fops;
614         p->seq_ops = ops;
615         p->state_size = state_size;
616         return proc_register(parent, p);
617 }
618 EXPORT_SYMBOL(proc_create_seq_private);
619
620 static int proc_single_open(struct inode *inode, struct file *file)
621 {
622         struct proc_dir_entry *de = PDE(inode);
623
624         return single_open(file, de->single_show, de->data);
625 }
626
627 static const struct file_operations proc_single_fops = {
628         .open           = proc_single_open,
629         .read           = seq_read,
630         .llseek         = seq_lseek,
631         .release        = single_release,
632 };
633
634 struct proc_dir_entry *proc_create_single_data(const char *name, umode_t mode,
635                 struct proc_dir_entry *parent,
636                 int (*show)(struct seq_file *, void *), void *data)
637 {
638         struct proc_dir_entry *p;
639
640         p = proc_create_reg(name, mode, &parent, data);
641         if (!p)
642                 return NULL;
643         p->proc_fops = &proc_single_fops;
644         p->single_show = show;
645         return proc_register(parent, p);
646 }
647 EXPORT_SYMBOL(proc_create_single_data);
648
649 void proc_set_size(struct proc_dir_entry *de, loff_t size)
650 {
651         de->size = size;
652 }
653 EXPORT_SYMBOL(proc_set_size);
654
655 void proc_set_user(struct proc_dir_entry *de, kuid_t uid, kgid_t gid)
656 {
657         de->uid = uid;
658         de->gid = gid;
659 }
660 EXPORT_SYMBOL(proc_set_user);
661
662 void pde_put(struct proc_dir_entry *pde)
663 {
664         if (refcount_dec_and_test(&pde->refcnt)) {
665                 proc_free_inum(pde->low_ino);
666                 pde_free(pde);
667         }
668 }
669
670 /*
671  * Remove a /proc entry and free it if it's not currently in use.
672  */
673 void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
674 {
675         struct proc_dir_entry *de = NULL;
676         const char *fn = name;
677         unsigned int len;
678
679         write_lock(&proc_subdir_lock);
680         if (__xlate_proc_name(name, &parent, &fn) != 0) {
681                 write_unlock(&proc_subdir_lock);
682                 return;
683         }
684         len = strlen(fn);
685
686         de = pde_subdir_find(parent, fn, len);
687         if (de) {
688                 rb_erase(&de->subdir_node, &parent->subdir);
689                 if (S_ISDIR(de->mode)) {
690                         parent->nlink--;
691                 }
692         }
693         write_unlock(&proc_subdir_lock);
694         if (!de) {
695                 WARN(1, "name '%s'\n", name);
696                 return;
697         }
698
699         proc_entry_rundown(de);
700
701         WARN(pde_subdir_first(de),
702              "%s: removing non-empty directory '%s/%s', leaking at least '%s'\n",
703              __func__, de->parent->name, de->name, pde_subdir_first(de)->name);
704         pde_put(de);
705 }
706 EXPORT_SYMBOL(remove_proc_entry);
707
708 int remove_proc_subtree(const char *name, struct proc_dir_entry *parent)
709 {
710         struct proc_dir_entry *root = NULL, *de, *next;
711         const char *fn = name;
712         unsigned int len;
713
714         write_lock(&proc_subdir_lock);
715         if (__xlate_proc_name(name, &parent, &fn) != 0) {
716                 write_unlock(&proc_subdir_lock);
717                 return -ENOENT;
718         }
719         len = strlen(fn);
720
721         root = pde_subdir_find(parent, fn, len);
722         if (!root) {
723                 write_unlock(&proc_subdir_lock);
724                 return -ENOENT;
725         }
726         rb_erase(&root->subdir_node, &parent->subdir);
727
728         de = root;
729         while (1) {
730                 next = pde_subdir_first(de);
731                 if (next) {
732                         rb_erase(&next->subdir_node, &de->subdir);
733                         de = next;
734                         continue;
735                 }
736                 next = de->parent;
737                 if (S_ISDIR(de->mode))
738                         next->nlink--;
739                 write_unlock(&proc_subdir_lock);
740
741                 proc_entry_rundown(de);
742                 if (de == root)
743                         break;
744                 pde_put(de);
745
746                 write_lock(&proc_subdir_lock);
747                 de = next;
748         }
749         pde_put(root);
750         return 0;
751 }
752 EXPORT_SYMBOL(remove_proc_subtree);
753
754 void *proc_get_parent_data(const struct inode *inode)
755 {
756         struct proc_dir_entry *de = PDE(inode);
757         return de->parent->data;
758 }
759 EXPORT_SYMBOL_GPL(proc_get_parent_data);
760
761 void proc_remove(struct proc_dir_entry *de)
762 {
763         if (de)
764                 remove_proc_subtree(de->name, de->parent);
765 }
766 EXPORT_SYMBOL(proc_remove);
767
768 void *PDE_DATA(const struct inode *inode)
769 {
770         return __PDE_DATA(inode);
771 }
772 EXPORT_SYMBOL(PDE_DATA);
773
774 /*
775  * Pull a user buffer into memory and pass it to the file's write handler if
776  * one is supplied.  The ->write() method is permitted to modify the
777  * kernel-side buffer.
778  */
779 ssize_t proc_simple_write(struct file *f, const char __user *ubuf, size_t size,
780                           loff_t *_pos)
781 {
782         struct proc_dir_entry *pde = PDE(file_inode(f));
783         char *buf;
784         int ret;
785
786         if (!pde->write)
787                 return -EACCES;
788         if (size == 0 || size > PAGE_SIZE - 1)
789                 return -EINVAL;
790         buf = memdup_user_nul(ubuf, size);
791         if (IS_ERR(buf))
792                 return PTR_ERR(buf);
793         ret = pde->write(f, buf, size);
794         kfree(buf);
795         return ret == 0 ? size : ret;
796 }