fs/tracefs/inode.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  inode.c - part of tracefs, a pseudo file system for activating tracing
   4  *
   5  * Based on debugfs by: Greg Kroah-Hartman <greg@kroah.com>
   6  *
   7  *  Copyright (C) 2014 Red Hat Inc, author: Steven Rostedt <srostedt@redhat.com>
   8  *
   9  * tracefs is the file system that is used by the tracing infrastructure.
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/fs.h>
  14 #include <linux/mount.h>
  15 #include <linux/kobject.h>
  16 #include <linux/namei.h>
  17 #include <linux/tracefs.h>
  18 #include <linux/fsnotify.h>
  19 #include <linux/security.h>
  20 #include <linux/seq_file.h>
  21 #include <linux/parser.h>
  22 #include <linux/magic.h>
  23 #include <linux/slab.h>
  24 #include "internal.h"
  25
  26 #define TRACEFS_DEFAULT_MODE    0700
  27 static struct kmem_cache *tracefs_inode_cachep __ro_after_init;
  28
  29 static struct vfsmount *tracefs_mount;
  30 static int tracefs_mount_count;
  31 static bool tracefs_registered;
  32
  33 /*
  34  * Keep track of all tracefs_inodes in order to update their
  35  * flags if necessary on a remount.
  36  */
  37 static DEFINE_SPINLOCK(tracefs_inode_lock);
  38 static LIST_HEAD(tracefs_inodes);
  39
  40 static struct inode *tracefs_alloc_inode(struct super_block *sb)
  41 {
  42         struct tracefs_inode *ti;
  43         unsigned long flags;
  44
  45         ti = kmem_cache_alloc(tracefs_inode_cachep, GFP_KERNEL);
  46         if (!ti)
  47                 return NULL;
  48
  49         spin_lock_irqsave(&tracefs_inode_lock, flags);
  50         list_add_rcu(&ti->list, &tracefs_inodes);
  51         spin_unlock_irqrestore(&tracefs_inode_lock, flags);
  52
  53         return &ti->vfs_inode;
  54 }
  55
  56 static void tracefs_free_inode_rcu(struct rcu_head *rcu)
  57 {
  58         struct tracefs_inode *ti;
  59
  60         ti = container_of(rcu, struct tracefs_inode, rcu);
  61         kmem_cache_free(tracefs_inode_cachep, ti);
  62 }
  63
  64 static void tracefs_free_inode(struct inode *inode)
  65 {
  66         struct tracefs_inode *ti = get_tracefs(inode);
  67         unsigned long flags;
  68
  69         spin_lock_irqsave(&tracefs_inode_lock, flags);
  70         list_del_rcu(&ti->list);
  71         spin_unlock_irqrestore(&tracefs_inode_lock, flags);
  72
  73         call_rcu(&ti->rcu, tracefs_free_inode_rcu);
  74 }
  75
  76 static ssize_t default_read_file(struct file *file, char __user *buf,
  77                                  size_t count, loff_t *ppos)
  78 {
  79         return 0;
  80 }
  81
  82 static ssize_t default_write_file(struct file *file, const char __user *buf,
  83                                    size_t count, loff_t *ppos)
  84 {
  85         return count;
  86 }
  87
  88 static const struct file_operations tracefs_file_operations = {
  89         .read =         default_read_file,
  90         .write =        default_write_file,
  91         .open =         simple_open,
  92         .llseek =       noop_llseek,
  93 };
  94
  95 static struct tracefs_dir_ops {
  96         int (*mkdir)(const char *name);
  97         int (*rmdir)(const char *name);
  98 } tracefs_ops __ro_after_init;
  99
 100 static char *get_dname(struct dentry *dentry)
 101 {
 102         const char *dname;
 103         char *name;
 104         int len = dentry->d_name.len;
 105
 106         dname = dentry->d_name.name;
 107         name = kmalloc(len + 1, GFP_KERNEL);
 108         if (!name)
 109                 return NULL;
 110         memcpy(name, dname, len);
 111         name[len] = 0;
 112         return name;
 113 }
 114
 115 static int tracefs_syscall_mkdir(struct mnt_idmap *idmap,
 116                                  struct inode *inode, struct dentry *dentry,
 117                                  umode_t mode)
 118 {
 119         struct tracefs_inode *ti;
 120         char *name;
 121         int ret;
 122
 123         name = get_dname(dentry);
 124         if (!name)
 125                 return -ENOMEM;
 126
 127         /*
 128          * This is a new directory that does not take the default of
 129          * the rootfs. It becomes the default permissions for all the
 130          * files and directories underneath it.
 131          */
 132         ti = get_tracefs(inode);
 133         ti->flags |= TRACEFS_INSTANCE_INODE;
 134         ti->private = inode;
 135
 136         /*
 137          * The mkdir call can call the generic functions that create
 138          * the files within the tracefs system. It is up to the individual
 139          * mkdir routine to handle races.
 140          */
 141         inode_unlock(inode);
 142         ret = tracefs_ops.mkdir(name);
 143         inode_lock(inode);
 144
 145         kfree(name);
 146
 147         return ret;
 148 }
 149
 150 static int tracefs_syscall_rmdir(struct inode *inode, struct dentry *dentry)
 151 {
 152         char *name;
 153         int ret;
 154
 155         name = get_dname(dentry);
 156         if (!name)
 157                 return -ENOMEM;
 158
 159         /*
 160          * The rmdir call can call the generic functions that create
 161          * the files within the tracefs system. It is up to the individual
 162          * rmdir routine to handle races.
 163          * This time we need to unlock not only the parent (inode) but
 164          * also the directory that is being deleted.
 165          */
 166         inode_unlock(inode);
 167         inode_unlock(d_inode(dentry));
 168
 169         ret = tracefs_ops.rmdir(name);
 170
 171         inode_lock_nested(inode, I_MUTEX_PARENT);
 172         inode_lock(d_inode(dentry));
 173
 174         kfree(name);
 175
 176         return ret;
 177 }
 178
 179 static void set_tracefs_inode_owner(struct inode *inode)
 180 {
 181         struct tracefs_inode *ti = get_tracefs(inode);
 182         struct inode *root_inode = ti->private;
 183         kuid_t uid;
 184         kgid_t gid;
 185
 186         uid = root_inode->i_uid;
 187         gid = root_inode->i_gid;
 188
 189         /*
 190          * If the root is not the mount point, then check the root's
 191          * permissions. If it was never set, then default to the
 192          * mount point.
 193          */
 194         if (root_inode != d_inode(root_inode->i_sb->s_root)) {
 195                 struct tracefs_inode *rti;
 196
 197                 rti = get_tracefs(root_inode);
 198                 root_inode = d_inode(root_inode->i_sb->s_root);
 199
 200                 if (!(rti->flags & TRACEFS_UID_PERM_SET))
 201                         uid = root_inode->i_uid;
 202
 203                 if (!(rti->flags & TRACEFS_GID_PERM_SET))
 204                         gid = root_inode->i_gid;
 205         }
 206
 207         /*
 208          * If this inode has never been referenced, then update
 209          * the permissions to the superblock.
 210          */
 211         if (!(ti->flags & TRACEFS_UID_PERM_SET))
 212                 inode->i_uid = uid;
 213
 214         if (!(ti->flags & TRACEFS_GID_PERM_SET))
 215                 inode->i_gid = gid;
 216 }
 217
 218 static int tracefs_permission(struct mnt_idmap *idmap,
 219                               struct inode *inode, int mask)
 220 {
 221         set_tracefs_inode_owner(inode);
 222         return generic_permission(idmap, inode, mask);
 223 }
 224
 225 static int tracefs_getattr(struct mnt_idmap *idmap,
 226                            const struct path *path, struct kstat *stat,
 227                            u32 request_mask, unsigned int flags)
 228 {
 229         struct inode *inode = d_backing_inode(path->dentry);
 230
 231         set_tracefs_inode_owner(inode);
 232         generic_fillattr(idmap, request_mask, inode, stat);
 233         return 0;
 234 }
 235
 236 static int tracefs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
 237                            struct iattr *attr)
 238 {
 239         unsigned int ia_valid = attr->ia_valid;
 240         struct inode *inode = d_inode(dentry);
 241         struct tracefs_inode *ti = get_tracefs(inode);
 242
 243         if (ia_valid & ATTR_UID)
 244                 ti->flags |= TRACEFS_UID_PERM_SET;
 245
 246         if (ia_valid & ATTR_GID)
 247                 ti->flags |= TRACEFS_GID_PERM_SET;
 248
 249         return simple_setattr(idmap, dentry, attr);
 250 }
 251
 252 static const struct inode_operations tracefs_instance_dir_inode_operations = {
 253         .lookup         = simple_lookup,
 254         .mkdir          = tracefs_syscall_mkdir,
 255         .rmdir          = tracefs_syscall_rmdir,
 256         .permission     = tracefs_permission,
 257         .getattr        = tracefs_getattr,
 258         .setattr        = tracefs_setattr,
 259 };
 260
 261 static const struct inode_operations tracefs_dir_inode_operations = {
 262         .lookup         = simple_lookup,
 263         .permission     = tracefs_permission,
 264         .getattr        = tracefs_getattr,
 265         .setattr        = tracefs_setattr,
 266 };
 267
 268 static const struct inode_operations tracefs_file_inode_operations = {
 269         .permission     = tracefs_permission,
 270         .getattr        = tracefs_getattr,
 271         .setattr        = tracefs_setattr,
 272 };
 273
 274 struct inode *tracefs_get_inode(struct super_block *sb)
 275 {
 276         struct inode *inode = new_inode(sb);
 277         if (inode) {
 278                 inode->i_ino = get_next_ino();
 279                 simple_inode_init_ts(inode);
 280         }
 281         return inode;
 282 }
 283
 284 struct tracefs_mount_opts {
 285         kuid_t uid;
 286         kgid_t gid;
 287         umode_t mode;
 288         /* Opt_* bitfield. */
 289         unsigned int opts;
 290 };
 291
 292 enum {
 293         Opt_uid,
 294         Opt_gid,
 295         Opt_mode,
 296         Opt_err
 297 };
 298
 299 static const match_table_t tokens = {
 300         {Opt_uid, "uid=%u"},
 301         {Opt_gid, "gid=%u"},
 302         {Opt_mode, "mode=%o"},
 303         {Opt_err, NULL}
 304 };
 305
 306 struct tracefs_fs_info {
 307         struct tracefs_mount_opts mount_opts;
 308 };
 309
 310 static int tracefs_parse_options(char *data, struct tracefs_mount_opts *opts)
 311 {
 312         substring_t args[MAX_OPT_ARGS];
 313         int option;
 314         int token;
 315         kuid_t uid;
 316         kgid_t gid;
 317         char *p;
 318
 319         opts->opts = 0;
 320         opts->mode = TRACEFS_DEFAULT_MODE;
 321
 322         while ((p = strsep(&data, ",")) != NULL) {
 323                 if (!*p)
 324                         continue;
 325
 326                 token = match_token(p, tokens, args);
 327                 switch (token) {
 328                 case Opt_uid:
 329                         if (match_int(&args[0], &option))
 330                                 return -EINVAL;
 331                         uid = make_kuid(current_user_ns(), option);
 332                         if (!uid_valid(uid))
 333                                 return -EINVAL;
 334                         opts->uid = uid;
 335                         break;
 336                 case Opt_gid:
 337                         if (match_int(&args[0], &option))
 338                                 return -EINVAL;
 339                         gid = make_kgid(current_user_ns(), option);
 340                         if (!gid_valid(gid))
 341                                 return -EINVAL;
 342                         opts->gid = gid;
 343                         break;
 344                 case Opt_mode:
 345                         if (match_octal(&args[0], &option))
 346                                 return -EINVAL;
 347                         opts->mode = option & S_IALLUGO;
 348                         break;
 349                 /*
 350                  * We might like to report bad mount options here;
 351                  * but traditionally tracefs has ignored all mount options
 352                  */
 353                 }
 354
 355                 opts->opts |= BIT(token);
 356         }
 357
 358         return 0;
 359 }
 360
 361 static int tracefs_apply_options(struct super_block *sb, bool remount)
 362 {
 363         struct tracefs_fs_info *fsi = sb->s_fs_info;
 364         struct inode *inode = d_inode(sb->s_root);
 365         struct tracefs_mount_opts *opts = &fsi->mount_opts;
 366         struct tracefs_inode *ti;
 367         bool update_uid, update_gid;
 368         umode_t tmp_mode;
 369
 370         /*
 371          * On remount, only reset mode/uid/gid if they were provided as mount
 372          * options.
 373          */
 374
 375         if (!remount || opts->opts & BIT(Opt_mode)) {
 376                 tmp_mode = READ_ONCE(inode->i_mode) & ~S_IALLUGO;
 377                 tmp_mode |= opts->mode;
 378                 WRITE_ONCE(inode->i_mode, tmp_mode);
 379         }
 380
 381         if (!remount || opts->opts & BIT(Opt_uid))
 382                 inode->i_uid = opts->uid;
 383
 384         if (!remount || opts->opts & BIT(Opt_gid))
 385                 inode->i_gid = opts->gid;
 386
 387         if (remount && (opts->opts & BIT(Opt_uid) || opts->opts & BIT(Opt_gid))) {
 388
 389                 update_uid = opts->opts & BIT(Opt_uid);
 390                 update_gid = opts->opts & BIT(Opt_gid);
 391
 392                 rcu_read_lock();
 393                 list_for_each_entry_rcu(ti, &tracefs_inodes, list) {
 394                         if (update_uid)
 395                                 ti->flags &= ~TRACEFS_UID_PERM_SET;
 396
 397                         if (update_gid)
 398                                 ti->flags &= ~TRACEFS_GID_PERM_SET;
 399
 400                         if (ti->flags & TRACEFS_EVENT_INODE)
 401                                 eventfs_remount(ti, update_uid, update_gid);
 402                 }
 403                 rcu_read_unlock();
 404         }
 405
 406         return 0;
 407 }
 408
 409 static int tracefs_remount(struct super_block *sb, int *flags, char *data)
 410 {
 411         int err;
 412         struct tracefs_fs_info *fsi = sb->s_fs_info;
 413
 414         sync_filesystem(sb);
 415         err = tracefs_parse_options(data, &fsi->mount_opts);
 416         if (err)
 417                 goto fail;
 418
 419         tracefs_apply_options(sb, true);
 420
 421 fail:
 422         return err;
 423 }
 424
 425 static int tracefs_show_options(struct seq_file *m, struct dentry *root)
 426 {
 427         struct tracefs_fs_info *fsi = root->d_sb->s_fs_info;
 428         struct tracefs_mount_opts *opts = &fsi->mount_opts;
 429
 430         if (!uid_eq(opts->uid, GLOBAL_ROOT_UID))
 431                 seq_printf(m, ",uid=%u",
 432                            from_kuid_munged(&init_user_ns, opts->uid));
 433         if (!gid_eq(opts->gid, GLOBAL_ROOT_GID))
 434                 seq_printf(m, ",gid=%u",
 435                            from_kgid_munged(&init_user_ns, opts->gid));
 436         if (opts->mode != TRACEFS_DEFAULT_MODE)
 437                 seq_printf(m, ",mode=%o", opts->mode);
 438
 439         return 0;
 440 }
 441
 442 static const struct super_operations tracefs_super_operations = {
 443         .alloc_inode    = tracefs_alloc_inode,
 444         .free_inode     = tracefs_free_inode,
 445         .drop_inode     = generic_delete_inode,
 446         .statfs         = simple_statfs,
 447         .remount_fs     = tracefs_remount,
 448         .show_options   = tracefs_show_options,
 449 };
 450
 451 /*
 452  * It would be cleaner if eventfs had its own dentry ops.
 453  *
 454  * Note that d_revalidate is called potentially under RCU,
 455  * so it can't take the eventfs mutex etc. It's fine - if
 456  * we open a file just as it's marked dead, things will
 457  * still work just fine, and just see the old stale case.
 458  */
 459 static void tracefs_d_release(struct dentry *dentry)
 460 {
 461         if (dentry->d_fsdata)
 462                 eventfs_d_release(dentry);
 463 }
 464
 465 static int tracefs_d_revalidate(struct dentry *dentry, unsigned int flags)
 466 {
 467         struct eventfs_inode *ei = dentry->d_fsdata;
 468
 469         return !(ei && ei->is_freed);
 470 }
 471
 472 static void tracefs_d_iput(struct dentry *dentry, struct inode *inode)
 473 {
 474         struct tracefs_inode *ti = get_tracefs(inode);
 475
 476         /*
 477          * This inode is being freed and cannot be used for
 478          * eventfs. Clear the flag so that it doesn't call into
 479          * eventfs during the remount flag updates. The eventfs_inode
 480          * gets freed after an RCU cycle, so the content will still
 481          * be safe if the iteration is going on now.
 482          */
 483         ti->flags &= ~TRACEFS_EVENT_INODE;
 484 }
 485
 486 static const struct dentry_operations tracefs_dentry_operations = {
 487         .d_iput = tracefs_d_iput,
 488         .d_revalidate = tracefs_d_revalidate,
 489         .d_release = tracefs_d_release,
 490 };
 491
 492 static int trace_fill_super(struct super_block *sb, void *data, int silent)
 493 {
 494         static const struct tree_descr trace_files[] = {{""}};
 495         struct tracefs_fs_info *fsi;
 496         int err;
 497
 498         fsi = kzalloc(sizeof(struct tracefs_fs_info), GFP_KERNEL);
 499         sb->s_fs_info = fsi;
 500         if (!fsi) {
 501                 err = -ENOMEM;
 502                 goto fail;
 503         }
 504
 505         err = tracefs_parse_options(data, &fsi->mount_opts);
 506         if (err)
 507                 goto fail;
 508
 509         err  =  simple_fill_super(sb, TRACEFS_MAGIC, trace_files);
 510         if (err)
 511                 goto fail;
 512
 513         sb->s_op = &tracefs_super_operations;
 514         sb->s_d_op = &tracefs_dentry_operations;
 515
 516         tracefs_apply_options(sb, false);
 517
 518         return 0;
 519
 520 fail:
 521         kfree(fsi);
 522         sb->s_fs_info = NULL;
 523         return err;
 524 }
 525
 526 static struct dentry *trace_mount(struct file_system_type *fs_type,
 527                         int flags, const char *dev_name,
 528                         void *data)
 529 {
 530         return mount_single(fs_type, flags, data, trace_fill_super);
 531 }
 532
 533 static struct file_system_type trace_fs_type = {
 534         .owner =        THIS_MODULE,
 535         .name =         "tracefs",
 536         .mount =        trace_mount,
 537         .kill_sb =      kill_litter_super,
 538 };
 539 MODULE_ALIAS_FS("tracefs");
 540
 541 struct dentry *tracefs_start_creating(const char *name, struct dentry *parent)
 542 {
 543         struct dentry *dentry;
 544         int error;
 545
 546         pr_debug("tracefs: creating file '%s'\n",name);
 547
 548         error = simple_pin_fs(&trace_fs_type, &tracefs_mount,
 549                               &tracefs_mount_count);
 550         if (error)
 551                 return ERR_PTR(error);
 552
 553         /* If the parent is not specified, we create it in the root.
 554          * We need the root dentry to do this, which is in the super
 555          * block. A pointer to that is in the struct vfsmount that we
 556          * have around.
 557          */
 558         if (!parent)
 559                 parent = tracefs_mount->mnt_root;
 560
 561         inode_lock(d_inode(parent));
 562         if (unlikely(IS_DEADDIR(d_inode(parent))))
 563                 dentry = ERR_PTR(-ENOENT);
 564         else
 565                 dentry = lookup_one_len(name, parent, strlen(name));
 566         if (!IS_ERR(dentry) && d_inode(dentry)) {
 567                 dput(dentry);
 568                 dentry = ERR_PTR(-EEXIST);
 569         }
 570
 571         if (IS_ERR(dentry)) {
 572                 inode_unlock(d_inode(parent));
 573                 simple_release_fs(&tracefs_mount, &tracefs_mount_count);
 574         }
 575
 576         return dentry;
 577 }
 578
 579 struct dentry *tracefs_failed_creating(struct dentry *dentry)
 580 {
 581         inode_unlock(d_inode(dentry->d_parent));
 582         dput(dentry);
 583         simple_release_fs(&tracefs_mount, &tracefs_mount_count);
 584         return NULL;
 585 }
 586
 587 struct dentry *tracefs_end_creating(struct dentry *dentry)
 588 {
 589         inode_unlock(d_inode(dentry->d_parent));
 590         return dentry;
 591 }
 592
 593 /* Find the inode that this will use for default */
 594 static struct inode *instance_inode(struct dentry *parent, struct inode *inode)
 595 {
 596         struct tracefs_inode *ti;
 597
 598         /* If parent is NULL then use root inode */
 599         if (!parent)
 600                 return d_inode(inode->i_sb->s_root);
 601
 602         /* Find the inode that is flagged as an instance or the root inode */
 603         while (!IS_ROOT(parent)) {
 604                 ti = get_tracefs(d_inode(parent));
 605                 if (ti->flags & TRACEFS_INSTANCE_INODE)
 606                         break;
 607                 parent = parent->d_parent;
 608         }
 609
 610         return d_inode(parent);
 611 }
 612
 613 /**
 614  * tracefs_create_file - create a file in the tracefs filesystem
 615  * @name: a pointer to a string containing the name of the file to create.
 616  * @mode: the permission that the file should have.
 617  * @parent: a pointer to the parent dentry for this file.  This should be a
 618  *          directory dentry if set.  If this parameter is NULL, then the
 619  *          file will be created in the root of the tracefs filesystem.
 620  * @data: a pointer to something that the caller will want to get to later
 621  *        on.  The inode.i_private pointer will point to this value on
 622  *        the open() call.
 623  * @fops: a pointer to a struct file_operations that should be used for
 624  *        this file.
 625  *
 626  * This is the basic "create a file" function for tracefs.  It allows for a
 627  * wide range of flexibility in creating a file, or a directory (if you want
 628  * to create a directory, the tracefs_create_dir() function is
 629  * recommended to be used instead.)
 630  *
 631  * This function will return a pointer to a dentry if it succeeds.  This
 632  * pointer must be passed to the tracefs_remove() function when the file is
 633  * to be removed (no automatic cleanup happens if your module is unloaded,
 634  * you are responsible here.)  If an error occurs, %NULL will be returned.
 635  *
 636  * If tracefs is not enabled in the kernel, the value -%ENODEV will be
 637  * returned.
 638  */
 639 struct dentry *tracefs_create_file(const char *name, umode_t mode,
 640                                    struct dentry *parent, void *data,
 641                                    const struct file_operations *fops)
 642 {
 643         struct tracefs_inode *ti;
 644         struct dentry *dentry;
 645         struct inode *inode;
 646
 647         if (security_locked_down(LOCKDOWN_TRACEFS))
 648                 return NULL;
 649
 650         if (!(mode & S_IFMT))
 651                 mode |= S_IFREG;
 652         BUG_ON(!S_ISREG(mode));
 653         dentry = tracefs_start_creating(name, parent);
 654
 655         if (IS_ERR(dentry))
 656                 return NULL;
 657
 658         inode = tracefs_get_inode(dentry->d_sb);
 659         if (unlikely(!inode))
 660                 return tracefs_failed_creating(dentry);
 661
 662         ti = get_tracefs(inode);
 663         ti->private = instance_inode(parent, inode);
 664
 665         inode->i_mode = mode;
 666         inode->i_op = &tracefs_file_inode_operations;
 667         inode->i_fop = fops ? fops : &tracefs_file_operations;
 668         inode->i_private = data;
 669         inode->i_uid = d_inode(dentry->d_parent)->i_uid;
 670         inode->i_gid = d_inode(dentry->d_parent)->i_gid;
 671         d_instantiate(dentry, inode);
 672         fsnotify_create(d_inode(dentry->d_parent), dentry);
 673         return tracefs_end_creating(dentry);
 674 }
 675
 676 static struct dentry *__create_dir(const char *name, struct dentry *parent,
 677                                    const struct inode_operations *ops)
 678 {
 679         struct tracefs_inode *ti;
 680         struct dentry *dentry = tracefs_start_creating(name, parent);
 681         struct inode *inode;
 682
 683         if (IS_ERR(dentry))
 684                 return NULL;
 685
 686         inode = tracefs_get_inode(dentry->d_sb);
 687         if (unlikely(!inode))
 688                 return tracefs_failed_creating(dentry);
 689
 690         /* Do not set bits for OTH */
 691         inode->i_mode = S_IFDIR | S_IRWXU | S_IRUSR| S_IRGRP | S_IXUSR | S_IXGRP;
 692         inode->i_op = ops;
 693         inode->i_fop = &simple_dir_operations;
 694         inode->i_uid = d_inode(dentry->d_parent)->i_uid;
 695         inode->i_gid = d_inode(dentry->d_parent)->i_gid;
 696
 697         ti = get_tracefs(inode);
 698         ti->private = instance_inode(parent, inode);
 699
 700         /* directory inodes start off with i_nlink == 2 (for "." entry) */
 701         inc_nlink(inode);
 702         d_instantiate(dentry, inode);
 703         inc_nlink(d_inode(dentry->d_parent));
 704         fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
 705         return tracefs_end_creating(dentry);
 706 }
 707
 708 /**
 709  * tracefs_create_dir - create a directory in the tracefs filesystem
 710  * @name: a pointer to a string containing the name of the directory to
 711  *        create.
 712  * @parent: a pointer to the parent dentry for this file.  This should be a
 713  *          directory dentry if set.  If this parameter is NULL, then the
 714  *          directory will be created in the root of the tracefs filesystem.
 715  *
 716  * This function creates a directory in tracefs with the given name.
 717  *
 718  * This function will return a pointer to a dentry if it succeeds.  This
 719  * pointer must be passed to the tracefs_remove() function when the file is
 720  * to be removed. If an error occurs, %NULL will be returned.
 721  *
 722  * If tracing is not enabled in the kernel, the value -%ENODEV will be
 723  * returned.
 724  */
 725 struct dentry *tracefs_create_dir(const char *name, struct dentry *parent)
 726 {
 727         if (security_locked_down(LOCKDOWN_TRACEFS))
 728                 return NULL;
 729
 730         return __create_dir(name, parent, &tracefs_dir_inode_operations);
 731 }
 732
 733 /**
 734  * tracefs_create_instance_dir - create the tracing instances directory
 735  * @name: The name of the instances directory to create
 736  * @parent: The parent directory that the instances directory will exist
 737  * @mkdir: The function to call when a mkdir is performed.
 738  * @rmdir: The function to call when a rmdir is performed.
 739  *
 740  * Only one instances directory is allowed.
 741  *
 742  * The instances directory is special as it allows for mkdir and rmdir
 743  * to be done by userspace. When a mkdir or rmdir is performed, the inode
 744  * locks are released and the methods passed in (@mkdir and @rmdir) are
 745  * called without locks and with the name of the directory being created
 746  * within the instances directory.
 747  *
 748  * Returns the dentry of the instances directory.
 749  */
 750 __init struct dentry *tracefs_create_instance_dir(const char *name,
 751                                           struct dentry *parent,
 752                                           int (*mkdir)(const char *name),
 753                                           int (*rmdir)(const char *name))
 754 {
 755         struct dentry *dentry;
 756
 757         /* Only allow one instance of the instances directory. */
 758         if (WARN_ON(tracefs_ops.mkdir || tracefs_ops.rmdir))
 759                 return NULL;
 760
 761         dentry = __create_dir(name, parent, &tracefs_instance_dir_inode_operations);
 762         if (!dentry)
 763                 return NULL;
 764
 765         tracefs_ops.mkdir = mkdir;
 766         tracefs_ops.rmdir = rmdir;
 767
 768         return dentry;
 769 }
 770
 771 static void remove_one(struct dentry *victim)
 772 {
 773         simple_release_fs(&tracefs_mount, &tracefs_mount_count);
 774 }
 775
 776 /**
 777  * tracefs_remove - recursively removes a directory
 778  * @dentry: a pointer to a the dentry of the directory to be removed.
 779  *
 780  * This function recursively removes a directory tree in tracefs that
 781  * was previously created with a call to another tracefs function
 782  * (like tracefs_create_file() or variants thereof.)
 783  */
 784 void tracefs_remove(struct dentry *dentry)
 785 {
 786         if (IS_ERR_OR_NULL(dentry))
 787                 return;
 788
 789         simple_pin_fs(&trace_fs_type, &tracefs_mount, &tracefs_mount_count);
 790         simple_recursive_removal(dentry, remove_one);
 791         simple_release_fs(&tracefs_mount, &tracefs_mount_count);
 792 }
 793
 794 /**
 795  * tracefs_initialized - Tells whether tracefs has been registered
 796  */
 797 bool tracefs_initialized(void)
 798 {
 799         return tracefs_registered;
 800 }
 801
 802 static void init_once(void *foo)
 803 {
 804         struct tracefs_inode *ti = (struct tracefs_inode *) foo;
 805
 806         /* inode_init_once() calls memset() on the vfs_inode portion */
 807         inode_init_once(&ti->vfs_inode);
 808
 809         /* Zero out the rest */
 810         memset_after(ti, 0, vfs_inode);
 811 }
 812
 813 static int __init tracefs_init(void)
 814 {
 815         int retval;
 816
 817         tracefs_inode_cachep = kmem_cache_create("tracefs_inode_cache",
 818                                                  sizeof(struct tracefs_inode),
 819                                                  0, (SLAB_RECLAIM_ACCOUNT|
 820                                                      SLAB_ACCOUNT),
 821                                                  init_once);
 822         if (!tracefs_inode_cachep)
 823                 return -ENOMEM;
 824
 825         retval = sysfs_create_mount_point(kernel_kobj, "tracing");
 826         if (retval)
 827                 return -EINVAL;
 828
 829         retval = register_filesystem(&trace_fs_type);
 830         if (!retval)
 831                 tracefs_registered = true;
 832
 833         return retval;
 834 }
 835 core_initcall(tracefs_init);