fs/sysfs/dir.c

   1 /*
   2  * fs/sysfs/dir.c - sysfs core and dir operation implementation
   3  *
   4  * Copyright (c) 2001-3 Patrick Mochel
   5  * Copyright (c) 2007 SUSE Linux Products GmbH
   6  * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
   7  *
   8  * This file is released under the GPLv2.
   9  *
  10  * Please see Documentation/filesystems/sysfs.txt for more information.
  11  */
  12
  13 #undef DEBUG
  14
  15 #include <linux/fs.h>
  16 #include <linux/kobject.h>
  17 #include <linux/slab.h>
  18 #include "sysfs.h"
  19
  20 DEFINE_SPINLOCK(sysfs_symlink_target_lock);
  21
  22 void sysfs_warn_dup(struct kernfs_node *parent, const char *name)
  23 {
  24         char *buf;
  25
  26         buf = kzalloc(PATH_MAX, GFP_KERNEL);
  27         if (buf)
  28                 kernfs_path(parent, buf, PATH_MAX);
  29
  30         WARN(1, KERN_WARNING "sysfs: cannot create duplicate filename '%s/%s'\n",
  31              buf, name);
  32
  33         kfree(buf);
  34 }
  35
  36 /**
  37  * sysfs_create_dir_ns - create a directory for an object with a namespace tag
  38  * @kobj: object we're creating directory for
  39  * @ns: the namespace tag to use
  40  */
  41 int sysfs_create_dir_ns(struct kobject *kobj, const void *ns)
  42 {
  43         struct kernfs_node *parent, *kn;
  44
  45         BUG_ON(!kobj);
  46
  47         if (kobj->parent)
  48                 parent = kobj->parent->sd;
  49         else
  50                 parent = sysfs_root_kn;
  51
  52         if (!parent)
  53                 return -ENOENT;
  54
  55         kn = kernfs_create_dir_ns(parent, kobject_name(kobj),
  56                                   S_IRWXU | S_IRUGO | S_IXUGO, kobj, ns);
  57         if (IS_ERR(kn)) {
  58                 if (PTR_ERR(kn) == -EEXIST)
  59                         sysfs_warn_dup(parent, kobject_name(kobj));
  60                 return PTR_ERR(kn);
  61         }
  62
  63         kobj->sd = kn;
  64         return 0;
  65 }
  66
  67 /**
  68  *      sysfs_remove_dir - remove an object's directory.
  69  *      @kobj:  object.
  70  *
  71  *      The only thing special about this is that we remove any files in
  72  *      the directory before we remove the directory, and we've inlined
  73  *      what used to be sysfs_rmdir() below, instead of calling separately.
  74  */
  75 void sysfs_remove_dir(struct kobject *kobj)
  76 {
  77         struct kernfs_node *kn = kobj->sd;
  78
  79         /*
  80          * In general, kboject owner is responsible for ensuring removal
  81          * doesn't race with other operations and sysfs doesn't provide any
  82          * protection; however, when @kobj is used as a symlink target, the
  83          * symlinking entity usually doesn't own @kobj and thus has no
  84          * control over removal.  @kobj->sd may be removed anytime
  85          * and symlink code may end up dereferencing an already freed node.
  86          *
  87          * sysfs_symlink_target_lock synchronizes @kobj->sd
  88          * disassociation against symlink operations so that symlink code
  89          * can safely dereference @kobj->sd.
  90          */
  91         spin_lock(&sysfs_symlink_target_lock);
  92         kobj->sd = NULL;
  93         spin_unlock(&sysfs_symlink_target_lock);
  94
  95         if (kn) {
  96                 WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR);
  97                 kernfs_remove(kn);
  98         }
  99 }
 100
 101 int sysfs_rename_dir_ns(struct kobject *kobj, const char *new_name,
 102                         const void *new_ns)
 103 {
 104         struct kernfs_node *parent;
 105         int ret;
 106
 107         parent = kernfs_get_parent(kobj->sd);
 108         ret = kernfs_rename_ns(kobj->sd, parent, new_name, new_ns);
 109         kernfs_put(parent);
 110         return ret;
 111 }
 112
 113 int sysfs_move_dir_ns(struct kobject *kobj, struct kobject *new_parent_kobj,
 114                       const void *new_ns)
 115 {
 116         struct kernfs_node *kn = kobj->sd;
 117         struct kernfs_node *new_parent;
 118
 119         new_parent = new_parent_kobj && new_parent_kobj->sd ?
 120                 new_parent_kobj->sd : sysfs_root_kn;
 121
 122         return kernfs_rename_ns(kn, new_parent, kn->name, new_ns);
 123 }
 124
 125 /**
 126  * sysfs_create_mount_point - create an always empty directory
 127  * @parent_kobj:  kobject that will contain this always empty directory
 128  * @name: The name of the always empty directory to add
 129  */
 130 int sysfs_create_mount_point(struct kobject *parent_kobj, const char *name)
 131 {
 132         struct kernfs_node *kn, *parent = parent_kobj->sd;
 133
 134         kn = kernfs_create_empty_dir(parent, name);
 135         if (IS_ERR(kn)) {
 136                 if (PTR_ERR(kn) == -EEXIST)
 137                         sysfs_warn_dup(parent, name);
 138                 return PTR_ERR(kn);
 139         }
 140
 141         return 0;
 142 }
 143 EXPORT_SYMBOL_GPL(sysfs_create_mount_point);
 144
 145 /**
 146  *      sysfs_remove_mount_point - remove an always empty directory.
 147  *      @parent_kobj: kobject that will contain this always empty directory
 148  *      @name: The name of the always empty directory to remove
 149  *
 150  */
 151 void sysfs_remove_mount_point(struct kobject *parent_kobj, const char *name)
 152 {
 153         struct kernfs_node *parent = parent_kobj->sd;
 154
 155         kernfs_remove_by_name_ns(parent, name, NULL);
 156 }
 157 EXPORT_SYMBOL_GPL(sysfs_remove_mount_point);