LCOV - code coverage report
Current view: top level - fs/tracefs - inode.c (source / functions) Hit Total Coverage
Test: Real Lines: 84 200 42.0 %
Date: 2020-10-17 15:46:16 Functions: 0 22 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           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                 :          0 : static char *get_dname(struct dentry *dentry)
      56                 :            : {
      57                 :            :         const char *dname;
      58                 :            :         char *name;
      59                 :          0 :         int len = dentry->d_name.len;
      60                 :            : 
      61                 :          0 :         dname = dentry->d_name.name;
      62                 :          0 :         name = kmalloc(len + 1, GFP_KERNEL);
      63                 :          0 :         if (!name)
      64                 :            :                 return NULL;
      65                 :          0 :         memcpy(name, dname, len);
      66                 :          0 :         name[len] = 0;
      67                 :          0 :         return name;
      68                 :            : }
      69                 :            : 
      70                 :          0 : static int tracefs_syscall_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode)
      71                 :            : {
      72                 :            :         char *name;
      73                 :            :         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                 :            :         inode_unlock(inode);
      85                 :          0 :         ret = tracefs_ops.mkdir(name);
      86                 :            :         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                 :            :         char *name;
      96                 :            :         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                 :            :         inode_unlock(inode);
     110                 :          0 :         inode_unlock(dentry->d_inode);
     111                 :            : 
     112                 :          0 :         ret = tracefs_ops.rmdir(name);
     113                 :            : 
     114                 :            :         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                 :          3 : static struct inode *tracefs_get_inode(struct super_block *sb)
     129                 :            : {
     130                 :          3 :         struct inode *inode = new_inode(sb);
     131                 :          3 :         if (inode) {
     132                 :          3 :                 inode->i_ino = get_next_ino();
     133                 :          3 :                 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
     134                 :            :         }
     135                 :          3 :         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                 :          3 : static int tracefs_parse_options(char *data, struct tracefs_mount_opts *opts)
     163                 :            : {
     164                 :            :         substring_t args[MAX_OPT_ARGS];
     165                 :            :         int option;
     166                 :            :         int token;
     167                 :            :         kuid_t uid;
     168                 :            :         kgid_t gid;
     169                 :            :         char *p;
     170                 :            : 
     171                 :          3 :         opts->mode = TRACEFS_DEFAULT_MODE;
     172                 :            : 
     173                 :          3 :         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                 :            :                 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                 :            :                 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                 :            :                 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                 :            : static int tracefs_apply_options(struct super_block *sb)
     211                 :            : {
     212                 :          3 :         struct tracefs_fs_info *fsi = sb->s_fs_info;
     213                 :          3 :         struct inode *inode = sb->s_root->d_inode;
     214                 :            :         struct tracefs_mount_opts *opts = &fsi->mount_opts;
     215                 :            : 
     216                 :          3 :         inode->i_mode &= ~S_IALLUGO;
     217                 :          3 :         inode->i_mode |= opts->mode;
     218                 :            : 
     219                 :          3 :         inode->i_uid = opts->uid;
     220                 :          3 :         inode->i_gid = opts->gid;
     221                 :            : 
     222                 :            :         return 0;
     223                 :            : }
     224                 :            : 
     225                 :          0 : static int tracefs_remount(struct super_block *sb, int *flags, char *data)
     226                 :            : {
     227                 :            :         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                 :            :                 goto fail;
     234                 :            : 
     235                 :            :         tracefs_apply_options(sb);
     236                 :            : 
     237                 :            : 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                 :          3 : static int trace_fill_super(struct super_block *sb, void *data, int silent)
     265                 :            : {
     266                 :            :         static const struct tree_descr trace_files[] = {{""}};
     267                 :            :         struct tracefs_fs_info *fsi;
     268                 :            :         int err;
     269                 :            : 
     270                 :          3 :         fsi = kzalloc(sizeof(struct tracefs_fs_info), GFP_KERNEL);
     271                 :          3 :         sb->s_fs_info = fsi;
     272                 :          3 :         if (!fsi) {
     273                 :            :                 err = -ENOMEM;
     274                 :            :                 goto fail;
     275                 :            :         }
     276                 :            : 
     277                 :          3 :         err = tracefs_parse_options(data, &fsi->mount_opts);
     278                 :          3 :         if (err)
     279                 :            :                 goto fail;
     280                 :            : 
     281                 :          3 :         err  =  simple_fill_super(sb, TRACEFS_MAGIC, trace_files);
     282                 :          3 :         if (err)
     283                 :            :                 goto fail;
     284                 :            : 
     285                 :          3 :         sb->s_op = &tracefs_super_operations;
     286                 :            : 
     287                 :            :         tracefs_apply_options(sb);
     288                 :            : 
     289                 :          3 :         return 0;
     290                 :            : 
     291                 :            : fail:
     292                 :          0 :         kfree(fsi);
     293                 :          0 :         sb->s_fs_info = NULL;
     294                 :          0 :         return err;
     295                 :            : }
     296                 :            : 
     297                 :          3 : static struct dentry *trace_mount(struct file_system_type *fs_type,
     298                 :            :                         int flags, const char *dev_name,
     299                 :            :                         void *data)
     300                 :            : {
     301                 :          3 :         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                 :          3 : static struct dentry *start_creating(const char *name, struct dentry *parent)
     313                 :            : {
     314                 :            :         struct dentry *dentry;
     315                 :            :         int error;
     316                 :            : 
     317                 :            :         pr_debug("tracefs: creating file '%s'\n",name);
     318                 :            : 
     319                 :          3 :         error = simple_pin_fs(&trace_fs_type, &tracefs_mount,
     320                 :            :                               &tracefs_mount_count);
     321                 :          3 :         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                 :          3 :         if (!parent)
     330                 :          3 :                 parent = tracefs_mount->mnt_root;
     331                 :            : 
     332                 :          3 :         inode_lock(parent->d_inode);
     333                 :          3 :         dentry = lookup_one_len(name, parent, strlen(name));
     334                 :          3 :         if (!IS_ERR(dentry) && dentry->d_inode) {
     335                 :          0 :                 dput(dentry);
     336                 :            :                 dentry = ERR_PTR(-EEXIST);
     337                 :            :         }
     338                 :            : 
     339                 :          3 :         if (IS_ERR(dentry)) {
     340                 :          0 :                 inode_unlock(parent->d_inode);
     341                 :          0 :                 simple_release_fs(&tracefs_mount, &tracefs_mount_count);
     342                 :            :         }
     343                 :            : 
     344                 :          3 :         return dentry;
     345                 :            : }
     346                 :            : 
     347                 :          0 : static struct dentry *failed_creating(struct dentry *dentry)
     348                 :            : {
     349                 :          0 :         inode_unlock(dentry->d_parent->d_inode);
     350                 :          0 :         dput(dentry);
     351                 :          0 :         simple_release_fs(&tracefs_mount, &tracefs_mount_count);
     352                 :          0 :         return NULL;
     353                 :            : }
     354                 :            : 
     355                 :            : static struct dentry *end_creating(struct dentry *dentry)
     356                 :            : {
     357                 :          3 :         inode_unlock(dentry->d_parent->d_inode);
     358                 :            :         return dentry;
     359                 :            : }
     360                 :            : 
     361                 :            : /**
     362                 :            :  * tracefs_create_file - create a file in the tracefs filesystem
     363                 :            :  * @name: a pointer to a string containing the name of the file to create.
     364                 :            :  * @mode: the permission that the file should have.
     365                 :            :  * @parent: a pointer to the parent dentry for this file.  This should be a
     366                 :            :  *          directory dentry if set.  If this parameter is NULL, then the
     367                 :            :  *          file will be created in the root of the tracefs filesystem.
     368                 :            :  * @data: a pointer to something that the caller will want to get to later
     369                 :            :  *        on.  The inode.i_private pointer will point to this value on
     370                 :            :  *        the open() call.
     371                 :            :  * @fops: a pointer to a struct file_operations that should be used for
     372                 :            :  *        this file.
     373                 :            :  *
     374                 :            :  * This is the basic "create a file" function for tracefs.  It allows for a
     375                 :            :  * wide range of flexibility in creating a file, or a directory (if you want
     376                 :            :  * to create a directory, the tracefs_create_dir() function is
     377                 :            :  * recommended to be used instead.)
     378                 :            :  *
     379                 :            :  * This function will return a pointer to a dentry if it succeeds.  This
     380                 :            :  * pointer must be passed to the tracefs_remove() function when the file is
     381                 :            :  * to be removed (no automatic cleanup happens if your module is unloaded,
     382                 :            :  * you are responsible here.)  If an error occurs, %NULL will be returned.
     383                 :            :  *
     384                 :            :  * If tracefs is not enabled in the kernel, the value -%ENODEV will be
     385                 :            :  * returned.
     386                 :            :  */
     387                 :          3 : struct dentry *tracefs_create_file(const char *name, umode_t mode,
     388                 :            :                                    struct dentry *parent, void *data,
     389                 :            :                                    const struct file_operations *fops)
     390                 :            : {
     391                 :            :         struct dentry *dentry;
     392                 :            :         struct inode *inode;
     393                 :            : 
     394                 :          3 :         if (security_locked_down(LOCKDOWN_TRACEFS))
     395                 :            :                 return NULL;
     396                 :            : 
     397                 :          3 :         if (!(mode & S_IFMT))
     398                 :          3 :                 mode |= S_IFREG;
     399                 :          3 :         BUG_ON(!S_ISREG(mode));
     400                 :          3 :         dentry = start_creating(name, parent);
     401                 :            : 
     402                 :          3 :         if (IS_ERR(dentry))
     403                 :            :                 return NULL;
     404                 :            : 
     405                 :          3 :         inode = tracefs_get_inode(dentry->d_sb);
     406                 :          3 :         if (unlikely(!inode))
     407                 :          0 :                 return failed_creating(dentry);
     408                 :            : 
     409                 :          3 :         inode->i_mode = mode;
     410                 :          3 :         inode->i_fop = fops ? fops : &tracefs_file_operations;
     411                 :          3 :         inode->i_private = data;
     412                 :          3 :         d_instantiate(dentry, inode);
     413                 :          3 :         fsnotify_create(dentry->d_parent->d_inode, dentry);
     414                 :          3 :         return end_creating(dentry);
     415                 :            : }
     416                 :            : 
     417                 :          3 : static struct dentry *__create_dir(const char *name, struct dentry *parent,
     418                 :            :                                    const struct inode_operations *ops)
     419                 :            : {
     420                 :          3 :         struct dentry *dentry = start_creating(name, parent);
     421                 :            :         struct inode *inode;
     422                 :            : 
     423                 :          3 :         if (IS_ERR(dentry))
     424                 :            :                 return NULL;
     425                 :            : 
     426                 :          3 :         inode = tracefs_get_inode(dentry->d_sb);
     427                 :          3 :         if (unlikely(!inode))
     428                 :          0 :                 return failed_creating(dentry);
     429                 :            : 
     430                 :          3 :         inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
     431                 :          3 :         inode->i_op = ops;
     432                 :          3 :         inode->i_fop = &simple_dir_operations;
     433                 :            : 
     434                 :            :         /* directory inodes start off with i_nlink == 2 (for "." entry) */
     435                 :          3 :         inc_nlink(inode);
     436                 :          3 :         d_instantiate(dentry, inode);
     437                 :          3 :         inc_nlink(dentry->d_parent->d_inode);
     438                 :          3 :         fsnotify_mkdir(dentry->d_parent->d_inode, dentry);
     439                 :          3 :         return end_creating(dentry);
     440                 :            : }
     441                 :            : 
     442                 :            : /**
     443                 :            :  * tracefs_create_dir - create a directory in the tracefs filesystem
     444                 :            :  * @name: a pointer to a string containing the name of the directory to
     445                 :            :  *        create.
     446                 :            :  * @parent: a pointer to the parent dentry for this file.  This should be a
     447                 :            :  *          directory dentry if set.  If this parameter is NULL, then the
     448                 :            :  *          directory will be created in the root of the tracefs filesystem.
     449                 :            :  *
     450                 :            :  * This function creates a directory in tracefs with the given name.
     451                 :            :  *
     452                 :            :  * This function will return a pointer to a dentry if it succeeds.  This
     453                 :            :  * pointer must be passed to the tracefs_remove() function when the file is
     454                 :            :  * to be removed. If an error occurs, %NULL will be returned.
     455                 :            :  *
     456                 :            :  * If tracing is not enabled in the kernel, the value -%ENODEV will be
     457                 :            :  * returned.
     458                 :            :  */
     459                 :          3 : struct dentry *tracefs_create_dir(const char *name, struct dentry *parent)
     460                 :            : {
     461                 :          3 :         return __create_dir(name, parent, &simple_dir_inode_operations);
     462                 :            : }
     463                 :            : 
     464                 :            : /**
     465                 :            :  * tracefs_create_instance_dir - create the tracing instances directory
     466                 :            :  * @name: The name of the instances directory to create
     467                 :            :  * @parent: The parent directory that the instances directory will exist
     468                 :            :  * @mkdir: The function to call when a mkdir is performed.
     469                 :            :  * @rmdir: The function to call when a rmdir is performed.
     470                 :            :  *
     471                 :            :  * Only one instances directory is allowed.
     472                 :            :  *
     473                 :            :  * The instances directory is special as it allows for mkdir and rmdir to
     474                 :            :  * to be done by userspace. When a mkdir or rmdir is performed, the inode
     475                 :            :  * locks are released and the methhods passed in (@mkdir and @rmdir) are
     476                 :            :  * called without locks and with the name of the directory being created
     477                 :            :  * within the instances directory.
     478                 :            :  *
     479                 :            :  * Returns the dentry of the instances directory.
     480                 :            :  */
     481                 :          3 : __init struct dentry *tracefs_create_instance_dir(const char *name,
     482                 :            :                                           struct dentry *parent,
     483                 :            :                                           int (*mkdir)(const char *name),
     484                 :            :                                           int (*rmdir)(const char *name))
     485                 :            : {
     486                 :            :         struct dentry *dentry;
     487                 :            : 
     488                 :            :         /* Only allow one instance of the instances directory. */
     489                 :          3 :         if (WARN_ON(tracefs_ops.mkdir || tracefs_ops.rmdir))
     490                 :            :                 return NULL;
     491                 :            : 
     492                 :          3 :         dentry = __create_dir(name, parent, &tracefs_dir_inode_operations);
     493                 :          3 :         if (!dentry)
     494                 :            :                 return NULL;
     495                 :            : 
     496                 :          3 :         tracefs_ops.mkdir = mkdir;
     497                 :          3 :         tracefs_ops.rmdir = rmdir;
     498                 :            : 
     499                 :          3 :         return dentry;
     500                 :            : }
     501                 :            : 
     502                 :          0 : static int __tracefs_remove(struct dentry *dentry, struct dentry *parent)
     503                 :            : {
     504                 :            :         int ret = 0;
     505                 :            : 
     506                 :          0 :         if (simple_positive(dentry)) {
     507                 :          0 :                 if (dentry->d_inode) {
     508                 :            :                         dget(dentry);
     509                 :          0 :                         switch (dentry->d_inode->i_mode & S_IFMT) {
     510                 :            :                         case S_IFDIR:
     511                 :          0 :                                 ret = simple_rmdir(parent->d_inode, dentry);
     512                 :          0 :                                 if (!ret)
     513                 :          0 :                                         fsnotify_rmdir(parent->d_inode, dentry);
     514                 :            :                                 break;
     515                 :            :                         default:
     516                 :          0 :                                 simple_unlink(parent->d_inode, dentry);
     517                 :          0 :                                 fsnotify_unlink(parent->d_inode, dentry);
     518                 :          0 :                                 break;
     519                 :            :                         }
     520                 :          0 :                         if (!ret)
     521                 :          0 :                                 d_delete(dentry);
     522                 :          0 :                         dput(dentry);
     523                 :            :                 }
     524                 :            :         }
     525                 :          0 :         return ret;
     526                 :            : }
     527                 :            : 
     528                 :            : /**
     529                 :            :  * tracefs_remove - removes a file or directory from the tracefs filesystem
     530                 :            :  * @dentry: a pointer to a the dentry of the file or directory to be
     531                 :            :  *          removed.
     532                 :            :  *
     533                 :            :  * This function removes a file or directory in tracefs that was previously
     534                 :            :  * created with a call to another tracefs function (like
     535                 :            :  * tracefs_create_file() or variants thereof.)
     536                 :            :  */
     537                 :          0 : void tracefs_remove(struct dentry *dentry)
     538                 :            : {
     539                 :            :         struct dentry *parent;
     540                 :            :         int ret;
     541                 :            : 
     542                 :          0 :         if (IS_ERR_OR_NULL(dentry))
     543                 :          0 :                 return;
     544                 :            : 
     545                 :          0 :         parent = dentry->d_parent;
     546                 :          0 :         inode_lock(parent->d_inode);
     547                 :          0 :         ret = __tracefs_remove(dentry, parent);
     548                 :          0 :         inode_unlock(parent->d_inode);
     549                 :          0 :         if (!ret)
     550                 :          0 :                 simple_release_fs(&tracefs_mount, &tracefs_mount_count);
     551                 :            : }
     552                 :            : 
     553                 :            : /**
     554                 :            :  * tracefs_remove_recursive - recursively removes a directory
     555                 :            :  * @dentry: a pointer to a the dentry of the directory to be removed.
     556                 :            :  *
     557                 :            :  * This function recursively removes a directory tree in tracefs that
     558                 :            :  * was previously created with a call to another tracefs function
     559                 :            :  * (like tracefs_create_file() or variants thereof.)
     560                 :            :  */
     561                 :          0 : void tracefs_remove_recursive(struct dentry *dentry)
     562                 :            : {
     563                 :            :         struct dentry *child, *parent;
     564                 :            : 
     565                 :          0 :         if (IS_ERR_OR_NULL(dentry))
     566                 :          0 :                 return;
     567                 :            : 
     568                 :            :         parent = dentry;
     569                 :            :  down:
     570                 :          0 :         inode_lock(parent->d_inode);
     571                 :            :  loop:
     572                 :            :         /*
     573                 :            :          * The parent->d_subdirs is protected by the d_lock. Outside that
     574                 :            :          * lock, the child can be unlinked and set to be freed which can
     575                 :            :          * use the d_u.d_child as the rcu head and corrupt this list.
     576                 :            :          */
     577                 :            :         spin_lock(&parent->d_lock);
     578                 :          0 :         list_for_each_entry(child, &parent->d_subdirs, d_child) {
     579                 :          0 :                 if (!simple_positive(child))
     580                 :          0 :                         continue;
     581                 :            : 
     582                 :            :                 /* perhaps simple_empty(child) makes more sense */
     583                 :          0 :                 if (!list_empty(&child->d_subdirs)) {
     584                 :            :                         spin_unlock(&parent->d_lock);
     585                 :          0 :                         inode_unlock(parent->d_inode);
     586                 :          0 :                         parent = child;
     587                 :          0 :                         goto down;
     588                 :            :                 }
     589                 :            : 
     590                 :            :                 spin_unlock(&parent->d_lock);
     591                 :            : 
     592                 :          0 :                 if (!__tracefs_remove(child, parent))
     593                 :          0 :                         simple_release_fs(&tracefs_mount, &tracefs_mount_count);
     594                 :            : 
     595                 :            :                 /*
     596                 :            :                  * The parent->d_lock protects agaist child from unlinking
     597                 :            :                  * from d_subdirs. When releasing the parent->d_lock we can
     598                 :            :                  * no longer trust that the next pointer is valid.
     599                 :            :                  * Restart the loop. We'll skip this one with the
     600                 :            :                  * simple_positive() check.
     601                 :            :                  */
     602                 :            :                 goto loop;
     603                 :            :         }
     604                 :            :         spin_unlock(&parent->d_lock);
     605                 :            : 
     606                 :          0 :         inode_unlock(parent->d_inode);
     607                 :            :         child = parent;
     608                 :          0 :         parent = parent->d_parent;
     609                 :          0 :         inode_lock(parent->d_inode);
     610                 :            : 
     611                 :          0 :         if (child != dentry)
     612                 :            :                 /* go up */
     613                 :            :                 goto loop;
     614                 :            : 
     615                 :          0 :         if (!__tracefs_remove(child, parent))
     616                 :          0 :                 simple_release_fs(&tracefs_mount, &tracefs_mount_count);
     617                 :          0 :         inode_unlock(parent->d_inode);
     618                 :            : }
     619                 :            : 
     620                 :            : /**
     621                 :            :  * tracefs_initialized - Tells whether tracefs has been registered
     622                 :            :  */
     623                 :          3 : bool tracefs_initialized(void)
     624                 :            : {
     625                 :          3 :         return tracefs_registered;
     626                 :            : }
     627                 :            : 
     628                 :          3 : static int __init tracefs_init(void)
     629                 :            : {
     630                 :            :         int retval;
     631                 :            : 
     632                 :          3 :         retval = sysfs_create_mount_point(kernel_kobj, "tracing");
     633                 :          3 :         if (retval)
     634                 :            :                 return -EINVAL;
     635                 :            : 
     636                 :          3 :         retval = register_filesystem(&trace_fs_type);
     637                 :          3 :         if (!retval)
     638                 :          3 :                 tracefs_registered = true;
     639                 :            : 
     640                 :          3 :         return retval;
     641                 :            : }
     642                 :            : core_initcall(tracefs_init);
    

Generated by: LCOV version 1.14