1
2
3
4
5
6
7
8
9
10
11
12#include <linux/module.h>
13#include <linux/fs.h>
14#include <linux/mount.h>
15#include <linux/pagemap.h>
16#include <linux/init.h>
17#include <linux/kobject.h>
18#include <linux/namei.h>
19#include <linux/debugfs.h>
20#include <linux/fsnotify.h>
21#include <linux/string.h>
22#include <linux/seq_file.h>
23#include <linux/parser.h>
24#include <linux/magic.h>
25#include <linux/slab.h>
26
27#include "internal.h"
28
29#define DEBUGFS_DEFAULT_MODE 0700
30
31static struct vfsmount *debugfs_mount;
32static int debugfs_mount_count;
33static bool debugfs_registered;
34
35static struct inode *debugfs_get_inode(struct super_block *sb)
36{
37 struct inode *inode = new_inode(sb);
38 if (inode) {
39 inode->i_ino = get_next_ino();
40 inode->i_atime = inode->i_mtime =
41 inode->i_ctime = current_time(inode);
42 }
43 return inode;
44}
45
46struct debugfs_mount_opts {
47 kuid_t uid;
48 kgid_t gid;
49 umode_t mode;
50};
51
52enum {
53 Opt_uid,
54 Opt_gid,
55 Opt_mode,
56 Opt_err
57};
58
59static const match_table_t tokens = {
60 {Opt_uid, "uid=%u"},
61 {Opt_gid, "gid=%u"},
62 {Opt_mode, "mode=%o"},
63 {Opt_err, NULL}
64};
65
66struct debugfs_fs_info {
67 struct debugfs_mount_opts mount_opts;
68};
69
70static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts)
71{
72 substring_t args[MAX_OPT_ARGS];
73 int option;
74 int token;
75 kuid_t uid;
76 kgid_t gid;
77 char *p;
78
79 opts->mode = DEBUGFS_DEFAULT_MODE;
80
81 while ((p = strsep(&data, ",")) != NULL) {
82 if (!*p)
83 continue;
84
85 token = match_token(p, tokens, args);
86 switch (token) {
87 case Opt_uid:
88 if (match_int(&args[0], &option))
89 return -EINVAL;
90 uid = make_kuid(current_user_ns(), option);
91 if (!uid_valid(uid))
92 return -EINVAL;
93 opts->uid = uid;
94 break;
95 case Opt_gid:
96 if (match_int(&args[0], &option))
97 return -EINVAL;
98 gid = make_kgid(current_user_ns(), option);
99 if (!gid_valid(gid))
100 return -EINVAL;
101 opts->gid = gid;
102 break;
103 case Opt_mode:
104 if (match_octal(&args[0], &option))
105 return -EINVAL;
106 opts->mode = option & S_IALLUGO;
107 break;
108
109
110
111
112 }
113 }
114
115 return 0;
116}
117
118static int debugfs_apply_options(struct super_block *sb)
119{
120 struct debugfs_fs_info *fsi = sb->s_fs_info;
121 struct inode *inode = d_inode(sb->s_root);
122 struct debugfs_mount_opts *opts = &fsi->mount_opts;
123
124 inode->i_mode &= ~S_IALLUGO;
125 inode->i_mode |= opts->mode;
126
127 inode->i_uid = opts->uid;
128 inode->i_gid = opts->gid;
129
130 return 0;
131}
132
133static int debugfs_remount(struct super_block *sb, int *flags, char *data)
134{
135 int err;
136 struct debugfs_fs_info *fsi = sb->s_fs_info;
137
138 sync_filesystem(sb);
139 err = debugfs_parse_options(data, &fsi->mount_opts);
140 if (err)
141 goto fail;
142
143 debugfs_apply_options(sb);
144
145fail:
146 return err;
147}
148
149static int debugfs_show_options(struct seq_file *m, struct dentry *root)
150{
151 struct debugfs_fs_info *fsi = root->d_sb->s_fs_info;
152 struct debugfs_mount_opts *opts = &fsi->mount_opts;
153
154 if (!uid_eq(opts->uid, GLOBAL_ROOT_UID))
155 seq_printf(m, ",uid=%u",
156 from_kuid_munged(&init_user_ns, opts->uid));
157 if (!gid_eq(opts->gid, GLOBAL_ROOT_GID))
158 seq_printf(m, ",gid=%u",
159 from_kgid_munged(&init_user_ns, opts->gid));
160 if (opts->mode != DEBUGFS_DEFAULT_MODE)
161 seq_printf(m, ",mode=%o", opts->mode);
162
163 return 0;
164}
165
166static void debugfs_free_inode(struct inode *inode)
167{
168 if (S_ISLNK(inode->i_mode))
169 kfree(inode->i_link);
170 free_inode_nonrcu(inode);
171}
172
173static const struct super_operations debugfs_super_operations = {
174 .statfs = simple_statfs,
175 .remount_fs = debugfs_remount,
176 .show_options = debugfs_show_options,
177 .free_inode = debugfs_free_inode,
178};
179
180static void debugfs_release_dentry(struct dentry *dentry)
181{
182 void *fsd = dentry->d_fsdata;
183
184 if (!((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT))
185 kfree(dentry->d_fsdata);
186}
187
188static struct vfsmount *debugfs_automount(struct path *path)
189{
190 debugfs_automount_t f;
191 f = (debugfs_automount_t)path->dentry->d_fsdata;
192 return f(path->dentry, d_inode(path->dentry)->i_private);
193}
194
195static const struct dentry_operations debugfs_dops = {
196 .d_delete = always_delete_dentry,
197 .d_release = debugfs_release_dentry,
198 .d_automount = debugfs_automount,
199};
200
201static int debug_fill_super(struct super_block *sb, void *data, int silent)
202{
203 static const struct tree_descr debug_files[] = {{""}};
204 struct debugfs_fs_info *fsi;
205 int err;
206
207 fsi = kzalloc(sizeof(struct debugfs_fs_info), GFP_KERNEL);
208 sb->s_fs_info = fsi;
209 if (!fsi) {
210 err = -ENOMEM;
211 goto fail;
212 }
213
214 err = debugfs_parse_options(data, &fsi->mount_opts);
215 if (err)
216 goto fail;
217
218 err = simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
219 if (err)
220 goto fail;
221
222 sb->s_op = &debugfs_super_operations;
223 sb->s_d_op = &debugfs_dops;
224
225 debugfs_apply_options(sb);
226
227 return 0;
228
229fail:
230 kfree(fsi);
231 sb->s_fs_info = NULL;
232 return err;
233}
234
235static struct dentry *debug_mount(struct file_system_type *fs_type,
236 int flags, const char *dev_name,
237 void *data)
238{
239 return mount_single(fs_type, flags, data, debug_fill_super);
240}
241
242static struct file_system_type debug_fs_type = {
243 .owner = THIS_MODULE,
244 .name = "debugfs",
245 .mount = debug_mount,
246 .kill_sb = kill_litter_super,
247};
248MODULE_ALIAS_FS("debugfs");
249
250
251
252
253
254
255
256
257
258
259
260
261
262struct dentry *debugfs_lookup(const char *name, struct dentry *parent)
263{
264 struct dentry *dentry;
265
266 if (IS_ERR(parent))
267 return NULL;
268
269 if (!parent)
270 parent = debugfs_mount->mnt_root;
271
272 dentry = lookup_one_len_unlocked(name, parent, strlen(name));
273 if (IS_ERR(dentry))
274 return NULL;
275 if (!d_really_is_positive(dentry)) {
276 dput(dentry);
277 return NULL;
278 }
279 return dentry;
280}
281EXPORT_SYMBOL_GPL(debugfs_lookup);
282
283static struct dentry *start_creating(const char *name, struct dentry *parent)
284{
285 struct dentry *dentry;
286 int error;
287
288 pr_debug("debugfs: creating file '%s'\n",name);
289
290 if (IS_ERR(parent))
291 return parent;
292
293 error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
294 &debugfs_mount_count);
295 if (error)
296 return ERR_PTR(error);
297
298
299
300
301
302
303 if (!parent)
304 parent = debugfs_mount->mnt_root;
305
306 inode_lock(d_inode(parent));
307 dentry = lookup_one_len(name, parent, strlen(name));
308 if (!IS_ERR(dentry) && d_really_is_positive(dentry)) {
309 dput(dentry);
310 dentry = ERR_PTR(-EEXIST);
311 }
312
313 if (IS_ERR(dentry)) {
314 inode_unlock(d_inode(parent));
315 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
316 }
317
318 return dentry;
319}
320
321static struct dentry *failed_creating(struct dentry *dentry)
322{
323 inode_unlock(d_inode(dentry->d_parent));
324 dput(dentry);
325 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
326 return ERR_PTR(-ENOMEM);
327}
328
329static struct dentry *end_creating(struct dentry *dentry)
330{
331 inode_unlock(d_inode(dentry->d_parent));
332 return dentry;
333}
334
335static struct dentry *__debugfs_create_file(const char *name, umode_t mode,
336 struct dentry *parent, void *data,
337 const struct file_operations *proxy_fops,
338 const struct file_operations *real_fops)
339{
340 struct dentry *dentry;
341 struct inode *inode;
342
343 if (!(mode & S_IFMT))
344 mode |= S_IFREG;
345 BUG_ON(!S_ISREG(mode));
346 dentry = start_creating(name, parent);
347
348 if (IS_ERR(dentry))
349 return dentry;
350
351 inode = debugfs_get_inode(dentry->d_sb);
352 if (unlikely(!inode))
353 return failed_creating(dentry);
354
355 inode->i_mode = mode;
356 inode->i_private = data;
357
358 inode->i_fop = proxy_fops;
359 dentry->d_fsdata = (void *)((unsigned long)real_fops |
360 DEBUGFS_FSDATA_IS_REAL_FOPS_BIT);
361
362 d_instantiate(dentry, inode);
363 fsnotify_create(d_inode(dentry->d_parent), dentry);
364 return end_creating(dentry);
365}
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394struct dentry *debugfs_create_file(const char *name, umode_t mode,
395 struct dentry *parent, void *data,
396 const struct file_operations *fops)
397{
398
399 return __debugfs_create_file(name, mode, parent, data,
400 fops ? &debugfs_full_proxy_file_operations :
401 &debugfs_noop_file_operations,
402 fops);
403}
404EXPORT_SYMBOL_GPL(debugfs_create_file);
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433struct dentry *debugfs_create_file_unsafe(const char *name, umode_t mode,
434 struct dentry *parent, void *data,
435 const struct file_operations *fops)
436{
437
438 return __debugfs_create_file(name, mode, parent, data,
439 fops ? &debugfs_open_proxy_file_operations :
440 &debugfs_noop_file_operations,
441 fops);
442}
443EXPORT_SYMBOL_GPL(debugfs_create_file_unsafe);
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473struct dentry *debugfs_create_file_size(const char *name, umode_t mode,
474 struct dentry *parent, void *data,
475 const struct file_operations *fops,
476 loff_t file_size)
477{
478 struct dentry *de = debugfs_create_file(name, mode, parent, data, fops);
479
480 if (de)
481 d_inode(de)->i_size = file_size;
482 return de;
483}
484EXPORT_SYMBOL_GPL(debugfs_create_file_size);
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
506{
507 struct dentry *dentry = start_creating(name, parent);
508 struct inode *inode;
509
510 if (IS_ERR(dentry))
511 return dentry;
512
513 inode = debugfs_get_inode(dentry->d_sb);
514 if (unlikely(!inode))
515 return failed_creating(dentry);
516
517 inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
518 inode->i_op = &simple_dir_inode_operations;
519 inode->i_fop = &simple_dir_operations;
520
521
522 inc_nlink(inode);
523 d_instantiate(dentry, inode);
524 inc_nlink(d_inode(dentry->d_parent));
525 fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
526 return end_creating(dentry);
527}
528EXPORT_SYMBOL_GPL(debugfs_create_dir);
529
530
531
532
533
534
535
536
537
538
539
540
541struct dentry *debugfs_create_automount(const char *name,
542 struct dentry *parent,
543 debugfs_automount_t f,
544 void *data)
545{
546 struct dentry *dentry = start_creating(name, parent);
547 struct inode *inode;
548
549 if (IS_ERR(dentry))
550 return dentry;
551
552 inode = debugfs_get_inode(dentry->d_sb);
553 if (unlikely(!inode))
554 return failed_creating(dentry);
555
556 make_empty_dir_inode(inode);
557 inode->i_flags |= S_AUTOMOUNT;
558 inode->i_private = data;
559 dentry->d_fsdata = (void *)f;
560
561 inc_nlink(inode);
562 d_instantiate(dentry, inode);
563 inc_nlink(d_inode(dentry->d_parent));
564 fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
565 return end_creating(dentry);
566}
567EXPORT_SYMBOL(debugfs_create_automount);
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
593 const char *target)
594{
595 struct dentry *dentry;
596 struct inode *inode;
597 char *link = kstrdup(target, GFP_KERNEL);
598 if (!link)
599 return ERR_PTR(-ENOMEM);
600
601 dentry = start_creating(name, parent);
602 if (IS_ERR(dentry)) {
603 kfree(link);
604 return dentry;
605 }
606
607 inode = debugfs_get_inode(dentry->d_sb);
608 if (unlikely(!inode)) {
609 kfree(link);
610 return failed_creating(dentry);
611 }
612 inode->i_mode = S_IFLNK | S_IRWXUGO;
613 inode->i_op = &simple_symlink_inode_operations;
614 inode->i_link = link;
615 d_instantiate(dentry, inode);
616 return end_creating(dentry);
617}
618EXPORT_SYMBOL_GPL(debugfs_create_symlink);
619
620static void __debugfs_remove_file(struct dentry *dentry, struct dentry *parent)
621{
622 struct debugfs_fsdata *fsd;
623
624 simple_unlink(d_inode(parent), dentry);
625 d_delete(dentry);
626
627
628
629
630
631
632
633 smp_mb();
634 fsd = READ_ONCE(dentry->d_fsdata);
635 if ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)
636 return;
637 if (!refcount_dec_and_test(&fsd->active_users))
638 wait_for_completion(&fsd->active_users_drained);
639}
640
641static int __debugfs_remove(struct dentry *dentry, struct dentry *parent)
642{
643 int ret = 0;
644
645 if (simple_positive(dentry)) {
646 dget(dentry);
647 if (!d_is_reg(dentry)) {
648 if (d_is_dir(dentry))
649 ret = simple_rmdir(d_inode(parent), dentry);
650 else
651 simple_unlink(d_inode(parent), dentry);
652 if (!ret)
653 d_delete(dentry);
654 } else {
655 __debugfs_remove_file(dentry, parent);
656 }
657 dput(dentry);
658 }
659 return ret;
660}
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676void debugfs_remove(struct dentry *dentry)
677{
678 struct dentry *parent;
679 int ret;
680
681 if (IS_ERR_OR_NULL(dentry))
682 return;
683
684 parent = dentry->d_parent;
685 inode_lock(d_inode(parent));
686 ret = __debugfs_remove(dentry, parent);
687 inode_unlock(d_inode(parent));
688 if (!ret)
689 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
690}
691EXPORT_SYMBOL_GPL(debugfs_remove);
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706void debugfs_remove_recursive(struct dentry *dentry)
707{
708 struct dentry *child, *parent;
709
710 if (IS_ERR_OR_NULL(dentry))
711 return;
712
713 parent = dentry;
714 down:
715 inode_lock(d_inode(parent));
716 loop:
717
718
719
720
721
722 spin_lock(&parent->d_lock);
723 list_for_each_entry(child, &parent->d_subdirs, d_child) {
724 if (!simple_positive(child))
725 continue;
726
727
728 if (!list_empty(&child->d_subdirs)) {
729 spin_unlock(&parent->d_lock);
730 inode_unlock(d_inode(parent));
731 parent = child;
732 goto down;
733 }
734
735 spin_unlock(&parent->d_lock);
736
737 if (!__debugfs_remove(child, parent))
738 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
739
740
741
742
743
744
745
746
747 goto loop;
748 }
749 spin_unlock(&parent->d_lock);
750
751 inode_unlock(d_inode(parent));
752 child = parent;
753 parent = parent->d_parent;
754 inode_lock(d_inode(parent));
755
756 if (child != dentry)
757
758 goto loop;
759
760 if (!__debugfs_remove(child, parent))
761 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
762 inode_unlock(d_inode(parent));
763}
764EXPORT_SYMBOL_GPL(debugfs_remove_recursive);
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
786 struct dentry *new_dir, const char *new_name)
787{
788 int error;
789 struct dentry *dentry = NULL, *trap;
790 struct name_snapshot old_name;
791
792 if (IS_ERR(old_dir))
793 return old_dir;
794 if (IS_ERR(new_dir))
795 return new_dir;
796 if (IS_ERR_OR_NULL(old_dentry))
797 return old_dentry;
798
799 trap = lock_rename(new_dir, old_dir);
800
801 if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir))
802 goto exit;
803
804 if (d_really_is_negative(old_dentry) || old_dentry == trap ||
805 d_mountpoint(old_dentry))
806 goto exit;
807 dentry = lookup_one_len(new_name, new_dir, strlen(new_name));
808
809 if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry))
810 goto exit;
811
812 take_dentry_name_snapshot(&old_name, old_dentry);
813
814 error = simple_rename(d_inode(old_dir), old_dentry, d_inode(new_dir),
815 dentry, 0);
816 if (error) {
817 release_dentry_name_snapshot(&old_name);
818 goto exit;
819 }
820 d_move(old_dentry, dentry);
821 fsnotify_move(d_inode(old_dir), d_inode(new_dir), &old_name.name,
822 d_is_dir(old_dentry),
823 NULL, old_dentry);
824 release_dentry_name_snapshot(&old_name);
825 unlock_rename(new_dir, old_dir);
826 dput(dentry);
827 return old_dentry;
828exit:
829 if (dentry && !IS_ERR(dentry))
830 dput(dentry);
831 unlock_rename(new_dir, old_dir);
832 if (IS_ERR(dentry))
833 return dentry;
834 return ERR_PTR(-EINVAL);
835}
836EXPORT_SYMBOL_GPL(debugfs_rename);
837
838
839
840
841bool debugfs_initialized(void)
842{
843 return debugfs_registered;
844}
845EXPORT_SYMBOL_GPL(debugfs_initialized);
846
847static int __init debugfs_init(void)
848{
849 int retval;
850
851 retval = sysfs_create_mount_point(kernel_kobj, "debug");
852 if (retval)
853 return retval;
854
855 retval = register_filesystem(&debug_fs_type);
856 if (retval)
857 sysfs_remove_mount_point(kernel_kobj, "debug");
858 else
859 debugfs_registered = true;
860
861 return retval;
862}
863core_initcall(debugfs_init);
864
865