LCOV - code coverage report
Current view: top level - fs/tracefs - inode.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 106 200 53.0 %
Date: 2022-03-28 15:32:58 Functions: 11 20 55.0 %
Branches: 27 92 29.3 %

           Branch data     Line data    Source code
       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                 :            : 
      25                 :            : #define TRACEFS_DEFAULT_MODE    0700
      26                 :            : 
      27                 :            : static struct vfsmount *tracefs_mount;
      28                 :            : static int tracefs_mount_count;
      29                 :            : static bool tracefs_registered;
      30                 :            : 
      31                 :          0 : static ssize_t default_read_file(struct file *file, char __user *buf,
      32                 :            :                                  size_t count, loff_t *ppos)
      33                 :            : {
      34                 :          0 :         return 0;
      35                 :            : }
      36                 :            : 
      37                 :          0 : static ssize_t default_write_file(struct file *file, const char __user *buf,
      38                 :            :                                    size_t count, loff_t *ppos)
      39                 :            : {
      40                 :          0 :         return count;
      41                 :            : }
      42                 :            : 
      43                 :            : static const struct file_operations tracefs_file_operations = {
      44                 :            :         .read =         default_read_file,
      45                 :            :         .write =        default_write_file,
      46                 :            :         .open =         simple_open,
      47                 :            :         .llseek =       noop_llseek,
      48                 :            : };
      49                 :            : 
      50                 :            : static struct tracefs_dir_ops {
      51                 :            :         int (*mkdir)(const char *name);
      52                 :            :         int (*rmdir)(const char *name);
      53                 :            : } tracefs_ops __ro_after_init;
      54                 :            : 
      55                 :            : static char *get_dname(struct dentry *dentry)
      56                 :            : {
      57                 :            :         const char *dname;
      58                 :            :         char *name;
      59                 :            :         int len = dentry->d_name.len;
      60                 :            : 
      61                 :            :         dname = dentry->d_name.name;
      62                 :            :         name = kmalloc(len + 1, GFP_KERNEL);
      63                 :            :         if (!name)
      64                 :            :                 return NULL;
      65                 :            :         memcpy(name, dname, len);
      66                 :            :         name[len] = 0;
      67                 :            :         return name;
      68                 :            : }
      69                 :            : 
      70                 :          0 : static int tracefs_syscall_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode)
      71                 :            : {
      72                 :          0 :         char *name;
      73                 :          0 :         int ret;
      74                 :            : 
      75                 :          0 :         name = get_dname(dentry);
      76         [ #  # ]:          0 :         if (!name)
      77                 :            :                 return -ENOMEM;
      78                 :            : 
      79                 :            :         /*
      80                 :            :          * The mkdir call can call the generic functions that create
      81                 :            :          * the files within the tracefs system. It is up to the individual
      82                 :            :          * mkdir routine to handle races.
      83                 :            :          */
      84                 :          0 :         inode_unlock(inode);
      85                 :          0 :         ret = tracefs_ops.mkdir(name);
      86                 :          0 :         inode_lock(inode);
      87                 :            : 
      88                 :          0 :         kfree(name);
      89                 :            : 
      90                 :          0 :         return ret;
      91                 :            : }
      92                 :            : 
      93                 :          0 : static int tracefs_syscall_rmdir(struct inode *inode, struct dentry *dentry)
      94                 :            : {
      95                 :          0 :         char *name;
      96                 :          0 :         int ret;
      97                 :            : 
      98                 :          0 :         name = get_dname(dentry);
      99         [ #  # ]:          0 :         if (!name)
     100                 :            :                 return -ENOMEM;
     101                 :            : 
     102                 :            :         /*
     103                 :            :          * The rmdir call can call the generic functions that create
     104                 :            :          * the files within the tracefs system. It is up to the individual
     105                 :            :          * rmdir routine to handle races.
     106                 :            :          * This time we need to unlock not only the parent (inode) but
     107                 :            :          * also the directory that is being deleted.
     108                 :            :          */
     109                 :          0 :         inode_unlock(inode);
     110                 :          0 :         inode_unlock(dentry->d_inode);
     111                 :            : 
     112                 :          0 :         ret = tracefs_ops.rmdir(name);
     113                 :            : 
     114                 :          0 :         inode_lock_nested(inode, I_MUTEX_PARENT);
     115                 :          0 :         inode_lock(dentry->d_inode);
     116                 :            : 
     117                 :          0 :         kfree(name);
     118                 :            : 
     119                 :          0 :         return ret;
     120                 :            : }
     121                 :            : 
     122                 :            : static const struct inode_operations tracefs_dir_inode_operations = {
     123                 :            :         .lookup         = simple_lookup,
     124                 :            :         .mkdir          = tracefs_syscall_mkdir,
     125                 :            :         .rmdir          = tracefs_syscall_rmdir,
     126                 :            : };
     127                 :            : 
     128                 :     218036 : static struct inode *tracefs_get_inode(struct super_block *sb)
     129                 :            : {
     130                 :     218036 :         struct inode *inode = new_inode(sb);
     131         [ +  - ]:     218036 :         if (inode) {
     132                 :     218036 :                 inode->i_ino = get_next_ino();
     133                 :     218036 :                 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
     134                 :            :         }
     135                 :     218036 :         return inode;
     136                 :            : }
     137                 :            : 
     138                 :            : struct tracefs_mount_opts {
     139                 :            :         kuid_t uid;
     140                 :            :         kgid_t gid;
     141                 :            :         umode_t mode;
     142                 :            : };
     143                 :            : 
     144                 :            : enum {
     145                 :            :         Opt_uid,
     146                 :            :         Opt_gid,
     147                 :            :         Opt_mode,
     148                 :            :         Opt_err
     149                 :            : };
     150                 :            : 
     151                 :            : static const match_table_t tokens = {
     152                 :            :         {Opt_uid, "uid=%u"},
     153                 :            :         {Opt_gid, "gid=%u"},
     154                 :            :         {Opt_mode, "mode=%o"},
     155                 :            :         {Opt_err, NULL}
     156                 :            : };
     157                 :            : 
     158                 :            : struct tracefs_fs_info {
     159                 :            :         struct tracefs_mount_opts mount_opts;
     160                 :            : };
     161                 :            : 
     162                 :         28 : static int tracefs_parse_options(char *data, struct tracefs_mount_opts *opts)
     163                 :            : {
     164                 :         28 :         substring_t args[MAX_OPT_ARGS];
     165                 :         28 :         int option;
     166                 :         28 :         int token;
     167                 :         28 :         kuid_t uid;
     168                 :         28 :         kgid_t gid;
     169                 :         28 :         char *p;
     170                 :            : 
     171                 :         28 :         opts->mode = TRACEFS_DEFAULT_MODE;
     172                 :            : 
     173         [ -  + ]:         28 :         while ((p = strsep(&data, ",")) != NULL) {
     174         [ #  # ]:          0 :                 if (!*p)
     175                 :          0 :                         continue;
     176                 :            : 
     177                 :          0 :                 token = match_token(p, tokens, args);
     178   [ #  #  #  # ]:          0 :                 switch (token) {
     179                 :          0 :                 case Opt_uid:
     180         [ #  # ]:          0 :                         if (match_int(&args[0], &option))
     181                 :            :                                 return -EINVAL;
     182         [ #  # ]:          0 :                         uid = make_kuid(current_user_ns(), option);
     183         [ #  # ]:          0 :                         if (!uid_valid(uid))
     184                 :            :                                 return -EINVAL;
     185                 :          0 :                         opts->uid = uid;
     186                 :          0 :                         break;
     187                 :          0 :                 case Opt_gid:
     188         [ #  # ]:          0 :                         if (match_int(&args[0], &option))
     189                 :            :                                 return -EINVAL;
     190         [ #  # ]:          0 :                         gid = make_kgid(current_user_ns(), option);
     191         [ #  # ]:          0 :                         if (!gid_valid(gid))
     192                 :            :                                 return -EINVAL;
     193                 :          0 :                         opts->gid = gid;
     194                 :          0 :                         break;
     195                 :          0 :                 case Opt_mode:
     196         [ #  # ]:          0 :                         if (match_octal(&args[0], &option))
     197                 :            :                                 return -EINVAL;
     198                 :          0 :                         opts->mode = option & S_IALLUGO;
     199                 :          0 :                         break;
     200                 :            :                 /*
     201                 :            :                  * We might like to report bad mount options here;
     202                 :            :                  * but traditionally tracefs has ignored all mount options
     203                 :            :                  */
     204                 :            :                 }
     205                 :            :         }
     206                 :            : 
     207                 :            :         return 0;
     208                 :            : }
     209                 :            : 
     210                 :         28 : static int tracefs_apply_options(struct super_block *sb)
     211                 :            : {
     212                 :         28 :         struct tracefs_fs_info *fsi = sb->s_fs_info;
     213                 :         28 :         struct inode *inode = sb->s_root->d_inode;
     214                 :         28 :         struct tracefs_mount_opts *opts = &fsi->mount_opts;
     215                 :            : 
     216                 :         28 :         inode->i_mode &= ~S_IALLUGO;
     217                 :         28 :         inode->i_mode |= opts->mode;
     218                 :            : 
     219                 :         28 :         inode->i_uid = opts->uid;
     220                 :         28 :         inode->i_gid = opts->gid;
     221                 :            : 
     222                 :         28 :         return 0;
     223                 :            : }
     224                 :            : 
     225                 :          0 : static int tracefs_remount(struct super_block *sb, int *flags, char *data)
     226                 :            : {
     227                 :          0 :         int err;
     228                 :          0 :         struct tracefs_fs_info *fsi = sb->s_fs_info;
     229                 :            : 
     230                 :          0 :         sync_filesystem(sb);
     231                 :          0 :         err = tracefs_parse_options(data, &fsi->mount_opts);
     232         [ #  # ]:          0 :         if (err)
     233                 :          0 :                 goto fail;
     234                 :            : 
     235                 :          0 :         tracefs_apply_options(sb);
     236                 :            : 
     237                 :          0 : fail:
     238                 :          0 :         return err;
     239                 :            : }
     240                 :            : 
     241                 :          0 : static int tracefs_show_options(struct seq_file *m, struct dentry *root)
     242                 :            : {
     243                 :          0 :         struct tracefs_fs_info *fsi = root->d_sb->s_fs_info;
     244                 :          0 :         struct tracefs_mount_opts *opts = &fsi->mount_opts;
     245                 :            : 
     246         [ #  # ]:          0 :         if (!uid_eq(opts->uid, GLOBAL_ROOT_UID))
     247         [ #  # ]:          0 :                 seq_printf(m, ",uid=%u",
     248                 :            :                            from_kuid_munged(&init_user_ns, opts->uid));
     249         [ #  # ]:          0 :         if (!gid_eq(opts->gid, GLOBAL_ROOT_GID))
     250         [ #  # ]:          0 :                 seq_printf(m, ",gid=%u",
     251                 :            :                            from_kgid_munged(&init_user_ns, opts->gid));
     252         [ #  # ]:          0 :         if (opts->mode != TRACEFS_DEFAULT_MODE)
     253                 :          0 :                 seq_printf(m, ",mode=%o", opts->mode);
     254                 :            : 
     255                 :          0 :         return 0;
     256                 :            : }
     257                 :            : 
     258                 :            : static const struct super_operations tracefs_super_operations = {
     259                 :            :         .statfs         = simple_statfs,
     260                 :            :         .remount_fs     = tracefs_remount,
     261                 :            :         .show_options   = tracefs_show_options,
     262                 :            : };
     263                 :            : 
     264                 :         28 : static int trace_fill_super(struct super_block *sb, void *data, int silent)
     265                 :            : {
     266                 :         28 :         static const struct tree_descr trace_files[] = {{""}};
     267                 :         28 :         struct tracefs_fs_info *fsi;
     268                 :         28 :         int err;
     269                 :            : 
     270                 :         28 :         fsi = kzalloc(sizeof(struct tracefs_fs_info), GFP_KERNEL);
     271                 :         28 :         sb->s_fs_info = fsi;
     272         [ -  + ]:         28 :         if (!fsi) {
     273                 :          0 :                 err = -ENOMEM;
     274                 :          0 :                 goto fail;
     275                 :            :         }
     276                 :            : 
     277                 :         28 :         err = tracefs_parse_options(data, &fsi->mount_opts);
     278         [ -  + ]:         28 :         if (err)
     279                 :          0 :                 goto fail;
     280                 :            : 
     281                 :         28 :         err  =  simple_fill_super(sb, TRACEFS_MAGIC, trace_files);
     282         [ -  + ]:         28 :         if (err)
     283                 :          0 :                 goto fail;
     284                 :            : 
     285                 :         28 :         sb->s_op = &tracefs_super_operations;
     286                 :            : 
     287                 :         28 :         tracefs_apply_options(sb);
     288                 :            : 
     289                 :         28 :         return 0;
     290                 :            : 
     291                 :          0 : fail:
     292                 :          0 :         kfree(fsi);
     293                 :          0 :         sb->s_fs_info = NULL;
     294                 :          0 :         return err;
     295                 :            : }
     296                 :            : 
     297                 :         28 : static struct dentry *trace_mount(struct file_system_type *fs_type,
     298                 :            :                         int flags, const char *dev_name,
     299                 :            :                         void *data)
     300                 :            : {
     301                 :         28 :         return mount_single(fs_type, flags, data, trace_fill_super);
     302                 :            : }
     303                 :            : 
     304                 :            : static struct file_system_type trace_fs_type = {
     305                 :            :         .owner =        THIS_MODULE,
     306                 :            :         .name =         "tracefs",
     307                 :            :         .mount =        trace_mount,
     308                 :            :         .kill_sb =      kill_litter_super,
     309                 :            : };
     310                 :            : MODULE_ALIAS_FS("tracefs");
     311                 :            : 
     312                 :     218036 : static struct dentry *start_creating(const char *name, struct dentry *parent)
     313                 :            : {
     314                 :     218036 :         struct dentry *dentry;
     315                 :     218036 :         int error;
     316                 :            : 
     317                 :     218036 :         pr_debug("tracefs: creating file '%s'\n",name);
     318                 :            : 
     319                 :     218036 :         error = simple_pin_fs(&trace_fs_type, &tracefs_mount,
     320                 :            :                               &tracefs_mount_count);
     321         [ -  + ]:     218036 :         if (error)
     322                 :          0 :                 return ERR_PTR(error);
     323                 :            : 
     324                 :            :         /* If the parent is not specified, we create it in the root.
     325                 :            :          * We need the root dentry to do this, which is in the super
     326                 :            :          * block. A pointer to that is in the struct vfsmount that we
     327                 :            :          * have around.
     328                 :            :          */
     329         [ +  + ]:     218036 :         if (!parent)
     330                 :        952 :                 parent = tracefs_mount->mnt_root;
     331                 :            : 
     332                 :     218036 :         inode_lock(parent->d_inode);
     333         [ +  - ]:     218036 :         if (unlikely(IS_DEADDIR(parent->d_inode)))
     334                 :            :                 dentry = ERR_PTR(-ENOENT);
     335                 :            :         else
     336                 :     218036 :                 dentry = lookup_one_len(name, parent, strlen(name));
     337   [ +  -  -  + ]:     218036 :         if (!IS_ERR(dentry) && dentry->d_inode) {
     338                 :          0 :                 dput(dentry);
     339                 :          0 :                 dentry = ERR_PTR(-EEXIST);
     340                 :            :         }
     341                 :            : 
     342         [ -  + ]:     218036 :         if (IS_ERR(dentry)) {
     343                 :          0 :                 inode_unlock(parent->d_inode);
     344                 :          0 :                 simple_release_fs(&tracefs_mount, &tracefs_mount_count);
     345                 :            :         }
     346                 :            : 
     347                 :            :         return dentry;
     348                 :            : }
     349                 :            : 
     350                 :          0 : static struct dentry *failed_creating(struct dentry *dentry)
     351                 :            : {
     352                 :          0 :         inode_unlock(dentry->d_parent->d_inode);
     353                 :          0 :         dput(dentry);
     354                 :          0 :         simple_release_fs(&tracefs_mount, &tracefs_mount_count);
     355                 :          0 :         return NULL;
     356                 :            : }
     357                 :            : 
     358                 :     218036 : static struct dentry *end_creating(struct dentry *dentry)
     359                 :            : {
     360                 :     218036 :         inode_unlock(dentry->d_parent->d_inode);
     361                 :     218036 :         return dentry;
     362                 :            : }
     363                 :            : 
     364                 :            : /**
     365                 :            :  * tracefs_create_file - create a file in the tracefs filesystem
     366                 :            :  * @name: a pointer to a string containing the name of the file to create.
     367                 :            :  * @mode: the permission that the file should have.
     368                 :            :  * @parent: a pointer to the parent dentry for this file.  This should be a
     369                 :            :  *          directory dentry if set.  If this parameter is NULL, then the
     370                 :            :  *          file will be created in the root of the tracefs filesystem.
     371                 :            :  * @data: a pointer to something that the caller will want to get to later
     372                 :            :  *        on.  The inode.i_private pointer will point to this value on
     373                 :            :  *        the open() call.
     374                 :            :  * @fops: a pointer to a struct file_operations that should be used for
     375                 :            :  *        this file.
     376                 :            :  *
     377                 :            :  * This is the basic "create a file" function for tracefs.  It allows for a
     378                 :            :  * wide range of flexibility in creating a file, or a directory (if you want
     379                 :            :  * to create a directory, the tracefs_create_dir() function is
     380                 :            :  * recommended to be used instead.)
     381                 :            :  *
     382                 :            :  * This function will return a pointer to a dentry if it succeeds.  This
     383                 :            :  * pointer must be passed to the tracefs_remove() function when the file is
     384                 :            :  * to be removed (no automatic cleanup happens if your module is unloaded,
     385                 :            :  * you are responsible here.)  If an error occurs, %NULL will be returned.
     386                 :            :  *
     387                 :            :  * If tracefs is not enabled in the kernel, the value -%ENODEV will be
     388                 :            :  * returned.
     389                 :            :  */
     390                 :     180404 : struct dentry *tracefs_create_file(const char *name, umode_t mode,
     391                 :            :                                    struct dentry *parent, void *data,
     392                 :            :                                    const struct file_operations *fops)
     393                 :            : {
     394                 :     180404 :         struct dentry *dentry;
     395                 :     180404 :         struct inode *inode;
     396                 :            : 
     397         [ +  - ]:     180404 :         if (security_locked_down(LOCKDOWN_TRACEFS))
     398                 :            :                 return NULL;
     399                 :            : 
     400         [ +  - ]:     180404 :         if (!(mode & S_IFMT))
     401                 :     180404 :                 mode |= S_IFREG;
     402         [ -  + ]:     180404 :         BUG_ON(!S_ISREG(mode));
     403                 :     180404 :         dentry = start_creating(name, parent);
     404                 :            : 
     405         [ +  - ]:     180404 :         if (IS_ERR(dentry))
     406                 :            :                 return NULL;
     407                 :            : 
     408                 :     180404 :         inode = tracefs_get_inode(dentry->d_sb);
     409         [ -  + ]:     180404 :         if (unlikely(!inode))
     410                 :          0 :                 return failed_creating(dentry);
     411                 :            : 
     412                 :     180404 :         inode->i_mode = mode;
     413         [ -  + ]:     180404 :         inode->i_fop = fops ? fops : &tracefs_file_operations;
     414                 :     180404 :         inode->i_private = data;
     415                 :     180404 :         d_instantiate(dentry, inode);
     416                 :     180404 :         fsnotify_create(dentry->d_parent->d_inode, dentry);
     417                 :     180404 :         return end_creating(dentry);
     418                 :            : }
     419                 :            : 
     420                 :      37632 : static struct dentry *__create_dir(const char *name, struct dentry *parent,
     421                 :            :                                    const struct inode_operations *ops)
     422                 :            : {
     423                 :      37632 :         struct dentry *dentry = start_creating(name, parent);
     424                 :      37632 :         struct inode *inode;
     425                 :            : 
     426         [ +  - ]:      37632 :         if (IS_ERR(dentry))
     427                 :            :                 return NULL;
     428                 :            : 
     429                 :      37632 :         inode = tracefs_get_inode(dentry->d_sb);
     430         [ -  + ]:      37632 :         if (unlikely(!inode))
     431                 :          0 :                 return failed_creating(dentry);
     432                 :            : 
     433                 :      37632 :         inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
     434                 :      37632 :         inode->i_op = ops;
     435                 :      37632 :         inode->i_fop = &simple_dir_operations;
     436                 :            : 
     437                 :            :         /* directory inodes start off with i_nlink == 2 (for "." entry) */
     438                 :      37632 :         inc_nlink(inode);
     439                 :      37632 :         d_instantiate(dentry, inode);
     440                 :      37632 :         inc_nlink(dentry->d_parent->d_inode);
     441                 :      37632 :         fsnotify_mkdir(dentry->d_parent->d_inode, dentry);
     442                 :      37632 :         return end_creating(dentry);
     443                 :            : }
     444                 :            : 
     445                 :            : /**
     446                 :            :  * tracefs_create_dir - create a directory in the tracefs filesystem
     447                 :            :  * @name: a pointer to a string containing the name of the directory to
     448                 :            :  *        create.
     449                 :            :  * @parent: a pointer to the parent dentry for this file.  This should be a
     450                 :            :  *          directory dentry if set.  If this parameter is NULL, then the
     451                 :            :  *          directory will be created in the root of the tracefs filesystem.
     452                 :            :  *
     453                 :            :  * This function creates a directory in tracefs with the given name.
     454                 :            :  *
     455                 :            :  * This function will return a pointer to a dentry if it succeeds.  This
     456                 :            :  * pointer must be passed to the tracefs_remove() function when the file is
     457                 :            :  * to be removed. If an error occurs, %NULL will be returned.
     458                 :            :  *
     459                 :            :  * If tracing is not enabled in the kernel, the value -%ENODEV will be
     460                 :            :  * returned.
     461                 :            :  */
     462                 :      37604 : struct dentry *tracefs_create_dir(const char *name, struct dentry *parent)
     463                 :            : {
     464                 :      37604 :         return __create_dir(name, parent, &simple_dir_inode_operations);
     465                 :            : }
     466                 :            : 
     467                 :            : /**
     468                 :            :  * tracefs_create_instance_dir - create the tracing instances directory
     469                 :            :  * @name: The name of the instances directory to create
     470                 :            :  * @parent: The parent directory that the instances directory will exist
     471                 :            :  * @mkdir: The function to call when a mkdir is performed.
     472                 :            :  * @rmdir: The function to call when a rmdir is performed.
     473                 :            :  *
     474                 :            :  * Only one instances directory is allowed.
     475                 :            :  *
     476                 :            :  * The instances directory is special as it allows for mkdir and rmdir to
     477                 :            :  * to be done by userspace. When a mkdir or rmdir is performed, the inode
     478                 :            :  * locks are released and the methhods passed in (@mkdir and @rmdir) are
     479                 :            :  * called without locks and with the name of the directory being created
     480                 :            :  * within the instances directory.
     481                 :            :  *
     482                 :            :  * Returns the dentry of the instances directory.
     483                 :            :  */
     484                 :         28 : __init struct dentry *tracefs_create_instance_dir(const char *name,
     485                 :            :                                           struct dentry *parent,
     486                 :            :                                           int (*mkdir)(const char *name),
     487                 :            :                                           int (*rmdir)(const char *name))
     488                 :            : {
     489                 :         28 :         struct dentry *dentry;
     490                 :            : 
     491                 :            :         /* Only allow one instance of the instances directory. */
     492   [ +  -  +  -  :         56 :         if (WARN_ON(tracefs_ops.mkdir || tracefs_ops.rmdir))
             -  +  +  - ]
     493                 :            :                 return NULL;
     494                 :            : 
     495                 :         28 :         dentry = __create_dir(name, parent, &tracefs_dir_inode_operations);
     496         [ +  - ]:         28 :         if (!dentry)
     497                 :            :                 return NULL;
     498                 :            : 
     499                 :         28 :         tracefs_ops.mkdir = mkdir;
     500                 :         28 :         tracefs_ops.rmdir = rmdir;
     501                 :            : 
     502                 :         28 :         return dentry;
     503                 :            : }
     504                 :            : 
     505                 :          0 : static void remove_one(struct dentry *victim)
     506                 :            : {
     507                 :          0 :         simple_release_fs(&tracefs_mount, &tracefs_mount_count);
     508                 :          0 : }
     509                 :            : 
     510                 :            : /**
     511                 :            :  * tracefs_remove - recursively removes a directory
     512                 :            :  * @dentry: a pointer to a the dentry of the directory to be removed.
     513                 :            :  *
     514                 :            :  * This function recursively removes a directory tree in tracefs that
     515                 :            :  * was previously created with a call to another tracefs function
     516                 :            :  * (like tracefs_create_file() or variants thereof.)
     517                 :            :  */
     518                 :          0 : void tracefs_remove(struct dentry *dentry)
     519                 :            : {
     520   [ #  #  #  # ]:          0 :         if (IS_ERR_OR_NULL(dentry))
     521                 :            :                 return;
     522                 :            : 
     523                 :          0 :         simple_pin_fs(&trace_fs_type, &tracefs_mount, &tracefs_mount_count);
     524                 :          0 :         simple_recursive_removal(dentry, remove_one);
     525                 :          0 :         simple_release_fs(&tracefs_mount, &tracefs_mount_count);
     526                 :            : }
     527                 :            : 
     528                 :            : /**
     529                 :            :  * tracefs_initialized - Tells whether tracefs has been registered
     530                 :            :  */
     531                 :         28 : bool tracefs_initialized(void)
     532                 :            : {
     533                 :         28 :         return tracefs_registered;
     534                 :            : }
     535                 :            : 
     536                 :         28 : static int __init tracefs_init(void)
     537                 :            : {
     538                 :         28 :         int retval;
     539                 :            : 
     540                 :         28 :         retval = sysfs_create_mount_point(kernel_kobj, "tracing");
     541         [ +  - ]:         28 :         if (retval)
     542                 :            :                 return -EINVAL;
     543                 :            : 
     544                 :         28 :         retval = register_filesystem(&trace_fs_type);
     545         [ +  - ]:         28 :         if (!retval)
     546                 :         28 :                 tracefs_registered = true;
     547                 :            : 
     548                 :            :         return retval;
     549                 :            : }
     550                 :            : core_initcall(tracefs_init);

Generated by: LCOV version 1.14