proc: reject "." and ".." as filenames
[muen/linux.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/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_cached(&dir->subdir),
56                              struct proc_dir_entry, 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_root.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_cached *root = &dir->subdir;
91         struct rb_node **new = &root->rb_root.rb_node, *parent = NULL;
92         bool leftmost = true;
93
94         /* Figure out where to put new node */
95         while (*new) {
96                 struct proc_dir_entry *this = rb_entry(*new,
97                                                        struct proc_dir_entry,
98                                                        subdir_node);
99                 int result = proc_match(de->name, this, de->namelen);
100
101                 parent = *new;
102                 if (result < 0)
103                         new = &(*new)->rb_left;
104                 else if (result > 0) {
105                         new = &(*new)->rb_right;
106                         leftmost = false;
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_cached(&de->subdir_node, root, leftmost);
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 /*
223  * Don't create negative dentries here, return -ENOENT by hand
224  * instead.
225  */
226 struct dentry *proc_lookup_de(struct inode *dir, struct dentry *dentry,
227                               struct proc_dir_entry *de)
228 {
229         struct inode *inode;
230
231         read_lock(&proc_subdir_lock);
232         de = pde_subdir_find(de, dentry->d_name.name, dentry->d_name.len);
233         if (de) {
234                 pde_get(de);
235                 read_unlock(&proc_subdir_lock);
236                 inode = proc_get_inode(dir->i_sb, de);
237                 if (!inode)
238                         return ERR_PTR(-ENOMEM);
239                 d_set_d_op(dentry, &simple_dentry_operations);
240                 d_add(dentry, inode);
241                 return NULL;
242         }
243         read_unlock(&proc_subdir_lock);
244         return ERR_PTR(-ENOENT);
245 }
246
247 struct dentry *proc_lookup(struct inode *dir, struct dentry *dentry,
248                 unsigned int flags)
249 {
250         return proc_lookup_de(dir, dentry, PDE(dir));
251 }
252
253 /*
254  * This returns non-zero if at EOF, so that the /proc
255  * root directory can use this and check if it should
256  * continue with the <pid> entries..
257  *
258  * Note that the VFS-layer doesn't care about the return
259  * value of the readdir() call, as long as it's non-negative
260  * for success..
261  */
262 int proc_readdir_de(struct file *file, struct dir_context *ctx,
263                     struct proc_dir_entry *de)
264 {
265         int i;
266
267         if (!dir_emit_dots(file, ctx))
268                 return 0;
269
270         read_lock(&proc_subdir_lock);
271         de = pde_subdir_first(de);
272         i = ctx->pos - 2;
273         for (;;) {
274                 if (!de) {
275                         read_unlock(&proc_subdir_lock);
276                         return 0;
277                 }
278                 if (!i)
279                         break;
280                 de = pde_subdir_next(de);
281                 i--;
282         }
283
284         do {
285                 struct proc_dir_entry *next;
286                 pde_get(de);
287                 read_unlock(&proc_subdir_lock);
288                 if (!dir_emit(ctx, de->name, de->namelen,
289                             de->low_ino, de->mode >> 12)) {
290                         pde_put(de);
291                         return 0;
292                 }
293                 read_lock(&proc_subdir_lock);
294                 ctx->pos++;
295                 next = pde_subdir_next(de);
296                 pde_put(de);
297                 de = next;
298         } while (de);
299         read_unlock(&proc_subdir_lock);
300         return 1;
301 }
302
303 int proc_readdir(struct file *file, struct dir_context *ctx)
304 {
305         struct inode *inode = file_inode(file);
306
307         return proc_readdir_de(file, ctx, PDE(inode));
308 }
309
310 /*
311  * These are the generic /proc directory operations. They
312  * use the in-memory "struct proc_dir_entry" tree to parse
313  * the /proc directory.
314  */
315 static const struct file_operations proc_dir_operations = {
316         .llseek                 = generic_file_llseek,
317         .read                   = generic_read_dir,
318         .iterate_shared         = proc_readdir,
319 };
320
321 /*
322  * proc directories can do almost nothing..
323  */
324 static const struct inode_operations proc_dir_inode_operations = {
325         .lookup         = proc_lookup,
326         .getattr        = proc_getattr,
327         .setattr        = proc_notify_change,
328 };
329
330 static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)
331 {
332         int ret;
333
334         ret = proc_alloc_inum(&dp->low_ino);
335         if (ret)
336                 return ret;
337
338         write_lock(&proc_subdir_lock);
339         dp->parent = dir;
340         if (pde_subdir_insert(dir, dp) == false) {
341                 WARN(1, "proc_dir_entry '%s/%s' already registered\n",
342                      dir->name, dp->name);
343                 write_unlock(&proc_subdir_lock);
344                 proc_free_inum(dp->low_ino);
345                 return -EEXIST;
346         }
347         write_unlock(&proc_subdir_lock);
348
349         return 0;
350 }
351
352 static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,
353                                           const char *name,
354                                           umode_t mode,
355                                           nlink_t nlink)
356 {
357         struct proc_dir_entry *ent = NULL;
358         const char *fn;
359         struct qstr qstr;
360
361         if (xlate_proc_name(name, parent, &fn) != 0)
362                 goto out;
363         qstr.name = fn;
364         qstr.len = strlen(fn);
365         if (qstr.len == 0 || qstr.len >= 256) {
366                 WARN(1, "name len %u\n", qstr.len);
367                 return NULL;
368         }
369         if (qstr.len == 1 && fn[0] == '.') {
370                 WARN(1, "name '.'\n");
371                 return NULL;
372         }
373         if (qstr.len == 2 && fn[0] == '.' && fn[1] == '.') {
374                 WARN(1, "name '..'\n");
375                 return NULL;
376         }
377         if (*parent == &proc_root && name_to_int(&qstr) != ~0U) {
378                 WARN(1, "create '/proc/%s' by hand\n", qstr.name);
379                 return NULL;
380         }
381         if (is_empty_pde(*parent)) {
382                 WARN(1, "attempt to add to permanently empty directory");
383                 return NULL;
384         }
385
386         ent = kmem_cache_zalloc(proc_dir_entry_cache, GFP_KERNEL);
387         if (!ent)
388                 goto out;
389
390         if (qstr.len + 1 <= sizeof(ent->inline_name)) {
391                 ent->name = ent->inline_name;
392         } else {
393                 ent->name = kmalloc(qstr.len + 1, GFP_KERNEL);
394                 if (!ent->name) {
395                         pde_free(ent);
396                         return NULL;
397                 }
398         }
399
400         memcpy(ent->name, fn, qstr.len + 1);
401         ent->namelen = qstr.len;
402         ent->mode = mode;
403         ent->nlink = nlink;
404         ent->subdir = RB_ROOT_CACHED;
405         atomic_set(&ent->count, 1);
406         spin_lock_init(&ent->pde_unload_lock);
407         INIT_LIST_HEAD(&ent->pde_openers);
408         proc_set_user(ent, (*parent)->uid, (*parent)->gid);
409
410 out:
411         return ent;
412 }
413
414 struct proc_dir_entry *proc_symlink(const char *name,
415                 struct proc_dir_entry *parent, const char *dest)
416 {
417         struct proc_dir_entry *ent;
418
419         ent = __proc_create(&parent, name,
420                           (S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1);
421
422         if (ent) {
423                 ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL);
424                 if (ent->data) {
425                         strcpy((char*)ent->data,dest);
426                         ent->proc_iops = &proc_link_inode_operations;
427                         if (proc_register(parent, ent) < 0) {
428                                 pde_free(ent);
429                                 ent = NULL;
430                         }
431                 } else {
432                         pde_free(ent);
433                         ent = NULL;
434                 }
435         }
436         return ent;
437 }
438 EXPORT_SYMBOL(proc_symlink);
439
440 struct proc_dir_entry *proc_mkdir_data(const char *name, umode_t mode,
441                 struct proc_dir_entry *parent, void *data)
442 {
443         struct proc_dir_entry *ent;
444
445         if (mode == 0)
446                 mode = S_IRUGO | S_IXUGO;
447
448         ent = __proc_create(&parent, name, S_IFDIR | mode, 2);
449         if (ent) {
450                 ent->data = data;
451                 ent->proc_fops = &proc_dir_operations;
452                 ent->proc_iops = &proc_dir_inode_operations;
453                 parent->nlink++;
454                 if (proc_register(parent, ent) < 0) {
455                         pde_free(ent);
456                         parent->nlink--;
457                         ent = NULL;
458                 }
459         }
460         return ent;
461 }
462 EXPORT_SYMBOL_GPL(proc_mkdir_data);
463
464 struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode,
465                                        struct proc_dir_entry *parent)
466 {
467         return proc_mkdir_data(name, mode, parent, NULL);
468 }
469 EXPORT_SYMBOL(proc_mkdir_mode);
470
471 struct proc_dir_entry *proc_mkdir(const char *name,
472                 struct proc_dir_entry *parent)
473 {
474         return proc_mkdir_data(name, 0, parent, NULL);
475 }
476 EXPORT_SYMBOL(proc_mkdir);
477
478 struct proc_dir_entry *proc_create_mount_point(const char *name)
479 {
480         umode_t mode = S_IFDIR | S_IRUGO | S_IXUGO;
481         struct proc_dir_entry *ent, *parent = NULL;
482
483         ent = __proc_create(&parent, name, mode, 2);
484         if (ent) {
485                 ent->data = NULL;
486                 ent->proc_fops = NULL;
487                 ent->proc_iops = NULL;
488                 parent->nlink++;
489                 if (proc_register(parent, ent) < 0) {
490                         pde_free(ent);
491                         parent->nlink--;
492                         ent = NULL;
493                 }
494         }
495         return ent;
496 }
497 EXPORT_SYMBOL(proc_create_mount_point);
498
499 struct proc_dir_entry *proc_create_data(const char *name, umode_t mode,
500                                         struct proc_dir_entry *parent,
501                                         const struct file_operations *proc_fops,
502                                         void *data)
503 {
504         struct proc_dir_entry *pde;
505         if ((mode & S_IFMT) == 0)
506                 mode |= S_IFREG;
507
508         if (!S_ISREG(mode)) {
509                 WARN_ON(1);     /* use proc_mkdir() */
510                 return NULL;
511         }
512
513         BUG_ON(proc_fops == NULL);
514
515         if ((mode & S_IALLUGO) == 0)
516                 mode |= S_IRUGO;
517         pde = __proc_create(&parent, name, mode, 1);
518         if (!pde)
519                 goto out;
520         pde->proc_fops = proc_fops;
521         pde->data = data;
522         pde->proc_iops = &proc_file_inode_operations;
523         if (proc_register(parent, pde) < 0)
524                 goto out_free;
525         return pde;
526 out_free:
527         pde_free(pde);
528 out:
529         return NULL;
530 }
531 EXPORT_SYMBOL(proc_create_data);
532  
533 struct proc_dir_entry *proc_create(const char *name, umode_t mode,
534                                    struct proc_dir_entry *parent,
535                                    const struct file_operations *proc_fops)
536 {
537         return proc_create_data(name, mode, parent, proc_fops, NULL);
538 }
539 EXPORT_SYMBOL(proc_create);
540
541 void proc_set_size(struct proc_dir_entry *de, loff_t size)
542 {
543         de->size = size;
544 }
545 EXPORT_SYMBOL(proc_set_size);
546
547 void proc_set_user(struct proc_dir_entry *de, kuid_t uid, kgid_t gid)
548 {
549         de->uid = uid;
550         de->gid = gid;
551 }
552 EXPORT_SYMBOL(proc_set_user);
553
554 void pde_put(struct proc_dir_entry *pde)
555 {
556         if (atomic_dec_and_test(&pde->count)) {
557                 proc_free_inum(pde->low_ino);
558                 pde_free(pde);
559         }
560 }
561
562 /*
563  * Remove a /proc entry and free it if it's not currently in use.
564  */
565 void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
566 {
567         struct proc_dir_entry *de = NULL;
568         const char *fn = name;
569         unsigned int len;
570
571         write_lock(&proc_subdir_lock);
572         if (__xlate_proc_name(name, &parent, &fn) != 0) {
573                 write_unlock(&proc_subdir_lock);
574                 return;
575         }
576         len = strlen(fn);
577
578         de = pde_subdir_find(parent, fn, len);
579         if (de)
580                 rb_erase_cached(&de->subdir_node, &parent->subdir);
581         write_unlock(&proc_subdir_lock);
582         if (!de) {
583                 WARN(1, "name '%s'\n", name);
584                 return;
585         }
586
587         proc_entry_rundown(de);
588
589         if (S_ISDIR(de->mode))
590                 parent->nlink--;
591         de->nlink = 0;
592         WARN(pde_subdir_first(de),
593              "%s: removing non-empty directory '%s/%s', leaking at least '%s'\n",
594              __func__, de->parent->name, de->name, pde_subdir_first(de)->name);
595         pde_put(de);
596 }
597 EXPORT_SYMBOL(remove_proc_entry);
598
599 int remove_proc_subtree(const char *name, struct proc_dir_entry *parent)
600 {
601         struct proc_dir_entry *root = NULL, *de, *next;
602         const char *fn = name;
603         unsigned int len;
604
605         write_lock(&proc_subdir_lock);
606         if (__xlate_proc_name(name, &parent, &fn) != 0) {
607                 write_unlock(&proc_subdir_lock);
608                 return -ENOENT;
609         }
610         len = strlen(fn);
611
612         root = pde_subdir_find(parent, fn, len);
613         if (!root) {
614                 write_unlock(&proc_subdir_lock);
615                 return -ENOENT;
616         }
617         rb_erase_cached(&root->subdir_node, &parent->subdir);
618
619         de = root;
620         while (1) {
621                 next = pde_subdir_first(de);
622                 if (next) {
623                         rb_erase_cached(&next->subdir_node, &de->subdir);
624                         de = next;
625                         continue;
626                 }
627                 write_unlock(&proc_subdir_lock);
628
629                 proc_entry_rundown(de);
630                 next = de->parent;
631                 if (S_ISDIR(de->mode))
632                         next->nlink--;
633                 de->nlink = 0;
634                 if (de == root)
635                         break;
636                 pde_put(de);
637
638                 write_lock(&proc_subdir_lock);
639                 de = next;
640         }
641         pde_put(root);
642         return 0;
643 }
644 EXPORT_SYMBOL(remove_proc_subtree);
645
646 void *proc_get_parent_data(const struct inode *inode)
647 {
648         struct proc_dir_entry *de = PDE(inode);
649         return de->parent->data;
650 }
651 EXPORT_SYMBOL_GPL(proc_get_parent_data);
652
653 void proc_remove(struct proc_dir_entry *de)
654 {
655         if (de)
656                 remove_proc_subtree(de->name, de->parent);
657 }
658 EXPORT_SYMBOL(proc_remove);
659
660 void *PDE_DATA(const struct inode *inode)
661 {
662         return __PDE_DATA(inode);
663 }
664 EXPORT_SYMBOL(PDE_DATA);