LCOV - code coverage report
Current view: top level - lib - kobject.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 312 470 66.4 %
Date: 2022-03-28 13:20:08 Functions: 35 46 76.1 %
Branches: 120 240 50.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * kobject.c - library routines for handling generic kernel objects
       4                 :            :  *
       5                 :            :  * Copyright (c) 2002-2003 Patrick Mochel <mochel@osdl.org>
       6                 :            :  * Copyright (c) 2006-2007 Greg Kroah-Hartman <greg@kroah.com>
       7                 :            :  * Copyright (c) 2006-2007 Novell Inc.
       8                 :            :  *
       9                 :            :  * Please see the file Documentation/kobject.txt for critical information
      10                 :            :  * about using the kobject interface.
      11                 :            :  */
      12                 :            : 
      13                 :            : #include <linux/kobject.h>
      14                 :            : #include <linux/string.h>
      15                 :            : #include <linux/export.h>
      16                 :            : #include <linux/stat.h>
      17                 :            : #include <linux/slab.h>
      18                 :            : #include <linux/random.h>
      19                 :            : 
      20                 :            : /**
      21                 :            :  * kobject_namespace() - Return @kobj's namespace tag.
      22                 :            :  * @kobj: kobject in question
      23                 :            :  *
      24                 :            :  * Returns namespace tag of @kobj if its parent has namespace ops enabled
      25                 :            :  * and thus @kobj should have a namespace tag associated with it.  Returns
      26                 :            :  * %NULL otherwise.
      27                 :            :  */
      28                 :      35100 : const void *kobject_namespace(struct kobject *kobj)
      29                 :            : {
      30                 :      35100 :         const struct kobj_ns_type_operations *ns_ops = kobj_ns_ops(kobj);
      31                 :            : 
      32         [ -  + ]:        102 :         if (!ns_ops || ns_ops->type == KOBJ_NS_TYPE_NONE)
      33                 :      34998 :                 return NULL;
      34                 :            : 
      35                 :        102 :         return kobj->ktype->namespace(kobj);
      36                 :            : }
      37                 :            : 
      38                 :            : /**
      39                 :            :  * kobject_get_ownership() - Get sysfs ownership data for @kobj.
      40                 :            :  * @kobj: kobject in question
      41                 :            :  * @uid: kernel user ID for sysfs objects
      42                 :            :  * @gid: kernel group ID for sysfs objects
      43                 :            :  *
      44                 :            :  * Returns initial uid/gid pair that should be used when creating sysfs
      45                 :            :  * representation of given kobject. Normally used to adjust ownership of
      46                 :            :  * objects in a container.
      47                 :            :  */
      48                 :     134928 : void kobject_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid)
      49                 :            : {
      50                 :     134928 :         *uid = GLOBAL_ROOT_UID;
      51                 :     134928 :         *gid = GLOBAL_ROOT_GID;
      52                 :            : 
      53         [ +  + ]:     132972 :         if (kobj->ktype->get_ownership)
      54                 :      59580 :                 kobj->ktype->get_ownership(kobj, uid, gid);
      55                 :     132972 : }
      56                 :            : 
      57                 :            : /*
      58                 :            :  * populate_dir - populate directory with attributes.
      59                 :            :  * @kobj: object we're working on.
      60                 :            :  *
      61                 :            :  * Most subsystems have a set of default attributes that are associated
      62                 :            :  * with an object that registers with them.  This is a helper called during
      63                 :            :  * object registration that loops through the default attributes of the
      64                 :            :  * subsystem and creates attributes files for them in sysfs.
      65                 :            :  */
      66                 :      35100 : static int populate_dir(struct kobject *kobj)
      67                 :            : {
      68         [ +  - ]:      35100 :         struct kobj_type *t = get_ktype(kobj);
      69                 :      35100 :         struct attribute *attr;
      70                 :      35100 :         int error = 0;
      71                 :      35100 :         int i;
      72                 :            : 
      73   [ +  -  +  + ]:      35100 :         if (t && t->default_attrs) {
      74         [ +  + ]:       5400 :                 for (i = 0; (attr = t->default_attrs[i]) != NULL; i++) {
      75                 :       4170 :                         error = sysfs_create_file(kobj, attr);
      76         [ +  - ]:       4170 :                         if (error)
      77                 :            :                                 break;
      78                 :            :                 }
      79                 :            :         }
      80                 :      35100 :         return error;
      81                 :            : }
      82                 :            : 
      83                 :      35100 : static int create_dir(struct kobject *kobj)
      84                 :            : {
      85                 :      35100 :         const struct kobj_type *ktype = get_ktype(kobj);
      86                 :      35100 :         const struct kobj_ns_type_operations *ops;
      87                 :      35100 :         int error;
      88                 :            : 
      89                 :      35100 :         error = sysfs_create_dir_ns(kobj, kobject_namespace(kobj));
      90         [ +  - ]:      35100 :         if (error)
      91                 :            :                 return error;
      92                 :            : 
      93                 :      35100 :         error = populate_dir(kobj);
      94         [ -  + ]:      35100 :         if (error) {
      95                 :          0 :                 sysfs_remove_dir(kobj);
      96                 :          0 :                 return error;
      97                 :            :         }
      98                 :            : 
      99         [ +  - ]:      35100 :         if (ktype) {
     100                 :      35100 :                 error = sysfs_create_groups(kobj, ktype->default_groups);
     101         [ -  + ]:      35100 :                 if (error) {
     102                 :          0 :                         sysfs_remove_dir(kobj);
     103                 :          0 :                         return error;
     104                 :            :                 }
     105                 :            :         }
     106                 :            : 
     107                 :            :         /*
     108                 :            :          * @kobj->sd may be deleted by an ancestor going away.  Hold an
     109                 :            :          * extra reference so that it stays until @kobj is gone.
     110                 :            :          */
     111                 :      35100 :         sysfs_get(kobj->sd);
     112                 :            : 
     113                 :            :         /*
     114                 :            :          * If @kobj has ns_ops, its children need to be filtered based on
     115                 :            :          * their namespace tags.  Enable namespace support on @kobj->sd.
     116                 :            :          */
     117                 :      35100 :         ops = kobj_child_ns_ops(kobj);
     118                 :       3138 :         if (ops) {
     119         [ -  + ]:        132 :                 BUG_ON(ops->type <= KOBJ_NS_TYPE_NONE);
     120         [ -  + ]:        132 :                 BUG_ON(ops->type >= KOBJ_NS_TYPES);
     121                 :          0 :                 BUG_ON(!kobj_ns_type_registered(ops->type));
     122                 :            : 
     123                 :        132 :                 sysfs_enable_ns(kobj->sd);
     124                 :            :         }
     125                 :            : 
     126                 :            :         return 0;
     127                 :            : }
     128                 :            : 
     129                 :      51468 : static int get_kobj_path_length(struct kobject *kobj)
     130                 :            : {
     131                 :      51468 :         int length = 1;
     132                 :      51468 :         struct kobject *parent = kobj;
     133                 :            : 
     134                 :            :         /* walk up the ancestors until we hit the one pointing to the
     135                 :            :          * root.
     136                 :            :          * Add 1 to strlen for leading '/' of each level.
     137                 :            :          */
     138                 :     173628 :         do {
     139         [ +  - ]:     173628 :                 if (kobject_name(parent) == NULL)
     140                 :            :                         return 0;
     141         [ +  + ]:     173628 :                 length += strlen(kobject_name(parent)) + 1;
     142                 :     173628 :                 parent = parent->parent;
     143         [ +  + ]:     173628 :         } while (parent);
     144                 :            :         return length;
     145                 :            : }
     146                 :            : 
     147                 :      51468 : static void fill_kobj_path(struct kobject *kobj, char *path, int length)
     148                 :            : {
     149                 :      51468 :         struct kobject *parent;
     150                 :            : 
     151                 :      51468 :         --length;
     152         [ +  + ]:     225096 :         for (parent = kobj; parent; parent = parent->parent) {
     153                 :     173628 :                 int cur = strlen(kobject_name(parent));
     154                 :            :                 /* back up enough to print this name with '/' */
     155                 :     173628 :                 length -= cur;
     156                 :     173628 :                 memcpy(path + length, kobject_name(parent), cur);
     157                 :     173628 :                 *(path + --length) = '/';
     158                 :            :         }
     159                 :            : 
     160                 :      51468 :         pr_debug("kobject: '%s' (%p): %s: path = '%s'\n", kobject_name(kobj),
     161                 :            :                  kobj, __func__, path);
     162                 :      51468 : }
     163                 :            : 
     164                 :            : /**
     165                 :            :  * kobject_get_path() - Allocate memory and fill in the path for @kobj.
     166                 :            :  * @kobj:       kobject in question, with which to build the path
     167                 :            :  * @gfp_mask:   the allocation type used to allocate the path
     168                 :            :  *
     169                 :            :  * Return: The newly allocated memory, caller must free with kfree().
     170                 :            :  */
     171                 :      51468 : char *kobject_get_path(struct kobject *kobj, gfp_t gfp_mask)
     172                 :            : {
     173                 :      51468 :         char *path;
     174                 :      51468 :         int len;
     175                 :            : 
     176                 :      51468 :         len = get_kobj_path_length(kobj);
     177         [ +  - ]:      51468 :         if (len == 0)
     178                 :            :                 return NULL;
     179                 :      51468 :         path = kzalloc(len, gfp_mask);
     180         [ +  - ]:      51468 :         if (!path)
     181                 :            :                 return NULL;
     182                 :      51468 :         fill_kobj_path(kobj, path, len);
     183                 :            : 
     184                 :      51468 :         return path;
     185                 :            : }
     186                 :            : EXPORT_SYMBOL_GPL(kobject_get_path);
     187                 :            : 
     188                 :            : /* add the kobject to its kset's list */
     189                 :      28104 : static void kobj_kset_join(struct kobject *kobj)
     190                 :            : {
     191         [ +  - ]:      28104 :         if (!kobj->kset)
     192                 :            :                 return;
     193                 :            : 
     194                 :      28104 :         kset_get(kobj->kset);
     195                 :      28104 :         spin_lock(&kobj->kset->list_lock);
     196                 :      28104 :         list_add_tail(&kobj->entry, &kobj->kset->list);
     197                 :      28104 :         spin_unlock(&kobj->kset->list_lock);
     198                 :            : }
     199                 :            : 
     200                 :            : /* remove the kobject from its kset's list */
     201                 :        150 : static void kobj_kset_leave(struct kobject *kobj)
     202                 :            : {
     203         [ +  + ]:        150 :         if (!kobj->kset)
     204                 :            :                 return;
     205                 :            : 
     206                 :        120 :         spin_lock(&kobj->kset->list_lock);
     207                 :        120 :         list_del_init(&kobj->entry);
     208                 :        120 :         spin_unlock(&kobj->kset->list_lock);
     209                 :        120 :         kset_put(kobj->kset);
     210                 :            : }
     211                 :            : 
     212                 :      39498 : static void kobject_init_internal(struct kobject *kobj)
     213                 :            : {
     214                 :      39498 :         if (!kobj)
     215                 :            :                 return;
     216                 :       5676 :         kref_init(&kobj->kref);
     217                 :      39498 :         INIT_LIST_HEAD(&kobj->entry);
     218                 :      39498 :         kobj->state_in_sysfs = 0;
     219                 :      39498 :         kobj->state_add_uevent_sent = 0;
     220                 :      39498 :         kobj->state_remove_uevent_sent = 0;
     221                 :       5676 :         kobj->state_initialized = 1;
     222                 :            : }
     223                 :            : 
     224                 :            : 
     225                 :      35100 : static int kobject_add_internal(struct kobject *kobj)
     226                 :            : {
     227                 :      35100 :         int error = 0;
     228                 :      35100 :         struct kobject *parent;
     229                 :            : 
     230         [ +  - ]:      35100 :         if (!kobj)
     231                 :            :                 return -ENOENT;
     232                 :            : 
     233   [ +  -  -  + ]:      35100 :         if (!kobj->name || !kobj->name[0]) {
     234                 :          0 :                 WARN(1,
     235                 :            :                      "kobject: (%p): attempted to be registered with empty name!\n",
     236                 :            :                      kobj);
     237                 :          0 :                 return -EINVAL;
     238                 :            :         }
     239                 :            : 
     240                 :      35100 :         parent = kobject_get(kobj->parent);
     241                 :            : 
     242                 :            :         /* join kset if set, use it as parent if we do not already have one */
     243         [ +  + ]:      35100 :         if (kobj->kset) {
     244         [ +  + ]:      28104 :                 if (!parent)
     245                 :      17472 :                         parent = kobject_get(&kobj->kset->kobj);
     246                 :      28104 :                 kobj_kset_join(kobj);
     247                 :      28104 :                 kobj->parent = parent;
     248                 :            :         }
     249                 :            : 
     250                 :      35100 :         pr_debug("kobject: '%s' (%p): %s: parent: '%s', set: '%s'\n",
     251                 :            :                  kobject_name(kobj), kobj, __func__,
     252                 :            :                  parent ? kobject_name(parent) : "<NULL>",
     253                 :            :                  kobj->kset ? kobject_name(&kobj->kset->kobj) : "<NULL>");
     254                 :            : 
     255                 :      35100 :         error = create_dir(kobj);
     256         [ -  + ]:      35100 :         if (error) {
     257                 :          0 :                 kobj_kset_leave(kobj);
     258                 :          0 :                 kobject_put(parent);
     259                 :          0 :                 kobj->parent = NULL;
     260                 :            : 
     261                 :            :                 /* be noisy on error issues */
     262         [ #  # ]:          0 :                 if (error == -EEXIST)
     263                 :          0 :                         pr_err("%s failed for %s with -EEXIST, don't try to register things with the same name in the same directory.\n",
     264                 :            :                                __func__, kobject_name(kobj));
     265                 :            :                 else
     266         [ #  # ]:          0 :                         pr_err("%s failed for %s (error: %d parent: %s)\n",
     267                 :            :                                __func__, kobject_name(kobj), error,
     268                 :            :                                parent ? kobject_name(parent) : "'none'");
     269                 :            :         } else
     270                 :      35100 :                 kobj->state_in_sysfs = 1;
     271                 :            : 
     272                 :            :         return error;
     273                 :            : }
     274                 :            : 
     275                 :            : /**
     276                 :            :  * kobject_set_name_vargs() - Set the name of a kobject.
     277                 :            :  * @kobj: struct kobject to set the name of
     278                 :            :  * @fmt: format string used to build the name
     279                 :            :  * @vargs: vargs to format the string.
     280                 :            :  */
     281                 :      44658 : int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
     282                 :            :                                   va_list vargs)
     283                 :            : {
     284                 :      44658 :         const char *s;
     285                 :            : 
     286   [ +  +  -  + ]:      44658 :         if (kobj->name && !fmt)
     287                 :            :                 return 0;
     288                 :            : 
     289                 :      35454 :         s = kvasprintf_const(GFP_KERNEL, fmt, vargs);
     290         [ +  - ]:      35454 :         if (!s)
     291                 :            :                 return -ENOMEM;
     292                 :            : 
     293                 :            :         /*
     294                 :            :          * ewww... some of these buggers have '/' in the name ... If
     295                 :            :          * that's the case, we need to make sure we have an actual
     296                 :            :          * allocated copy to modify, since kvasprintf_const may have
     297                 :            :          * returned something from .rodata.
     298                 :            :          */
     299         [ +  + ]:      35454 :         if (strchr(s, '/')) {
     300                 :         60 :                 char *t;
     301                 :            : 
     302                 :         60 :                 t = kstrdup(s, GFP_KERNEL);
     303                 :         60 :                 kfree_const(s);
     304         [ +  - ]:         60 :                 if (!t)
     305                 :            :                         return -ENOMEM;
     306                 :         60 :                 strreplace(t, '/', '!');
     307                 :         60 :                 s = t;
     308                 :            :         }
     309                 :      35454 :         kfree_const(kobj->name);
     310                 :      35454 :         kobj->name = s;
     311                 :            : 
     312                 :      35454 :         return 0;
     313                 :            : }
     314                 :            : 
     315                 :            : /**
     316                 :            :  * kobject_set_name() - Set the name of a kobject.
     317                 :            :  * @kobj: struct kobject to set the name of
     318                 :            :  * @fmt: format string used to build the name
     319                 :            :  *
     320                 :            :  * This sets the name of the kobject.  If you have already added the
     321                 :            :  * kobject to the system, you must call kobject_rename() in order to
     322                 :            :  * change the name of the kobject.
     323                 :            :  */
     324                 :       4926 : int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
     325                 :            : {
     326                 :       4926 :         va_list vargs;
     327                 :       4926 :         int retval;
     328                 :            : 
     329                 :       4926 :         va_start(vargs, fmt);
     330                 :       4926 :         retval = kobject_set_name_vargs(kobj, fmt, vargs);
     331                 :       4926 :         va_end(vargs);
     332                 :            : 
     333                 :       4926 :         return retval;
     334                 :            : }
     335                 :            : EXPORT_SYMBOL(kobject_set_name);
     336                 :            : 
     337                 :            : /**
     338                 :            :  * kobject_init() - Initialize a kobject structure.
     339                 :            :  * @kobj: pointer to the kobject to initialize
     340                 :            :  * @ktype: pointer to the ktype for this kobject.
     341                 :            :  *
     342                 :            :  * This function will properly initialize a kobject such that it can then
     343                 :            :  * be passed to the kobject_add() call.
     344                 :            :  *
     345                 :            :  * After this function is called, the kobject MUST be cleaned up by a call
     346                 :            :  * to kobject_put(), not by a call to kfree directly to ensure that all of
     347                 :            :  * the memory is cleaned up properly.
     348                 :            :  */
     349                 :      33822 : void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
     350                 :            : {
     351                 :      33822 :         char *err_str;
     352                 :            : 
     353         [ -  + ]:      33822 :         if (!kobj) {
     354                 :          0 :                 err_str = "invalid kobject pointer!";
     355                 :          0 :                 goto error;
     356                 :            :         }
     357         [ -  + ]:      33822 :         if (!ktype) {
     358                 :          0 :                 err_str = "must have a ktype to be initialized properly!\n";
     359                 :          0 :                 goto error;
     360                 :            :         }
     361         [ -  + ]:      33822 :         if (kobj->state_initialized) {
     362                 :            :                 /* do not error out as sometimes we can recover */
     363                 :          0 :                 pr_err("kobject (%p): tried to init an initialized object, something is seriously wrong.\n",
     364                 :            :                        kobj);
     365                 :          0 :                 dump_stack();
     366                 :            :         }
     367                 :            : 
     368                 :      33822 :         kobject_init_internal(kobj);
     369                 :      33822 :         kobj->ktype = ktype;
     370                 :      33822 :         return;
     371                 :            : 
     372                 :          0 : error:
     373                 :          0 :         pr_err("kobject (%p): %s\n", kobj, err_str);
     374                 :          0 :         dump_stack();
     375                 :            : }
     376                 :            : EXPORT_SYMBOL(kobject_init);
     377                 :            : 
     378                 :      30804 : static __printf(3, 0) int kobject_add_varg(struct kobject *kobj,
     379                 :            :                                            struct kobject *parent,
     380                 :            :                                            const char *fmt, va_list vargs)
     381                 :            : {
     382                 :      30804 :         int retval;
     383                 :            : 
     384                 :      30804 :         retval = kobject_set_name_vargs(kobj, fmt, vargs);
     385         [ -  + ]:      30804 :         if (retval) {
     386                 :          0 :                 pr_err("kobject: can not set name properly!\n");
     387                 :          0 :                 return retval;
     388                 :            :         }
     389                 :      30804 :         kobj->parent = parent;
     390                 :      30804 :         return kobject_add_internal(kobj);
     391                 :            : }
     392                 :            : 
     393                 :            : /**
     394                 :            :  * kobject_add() - The main kobject add function.
     395                 :            :  * @kobj: the kobject to add
     396                 :            :  * @parent: pointer to the parent of the kobject.
     397                 :            :  * @fmt: format to name the kobject with.
     398                 :            :  *
     399                 :            :  * The kobject name is set and added to the kobject hierarchy in this
     400                 :            :  * function.
     401                 :            :  *
     402                 :            :  * If @parent is set, then the parent of the @kobj will be set to it.
     403                 :            :  * If @parent is NULL, then the parent of the @kobj will be set to the
     404                 :            :  * kobject associated with the kset assigned to this kobject.  If no kset
     405                 :            :  * is assigned to the kobject, then the kobject will be located in the
     406                 :            :  * root of the sysfs tree.
     407                 :            :  *
     408                 :            :  * Note, no "add" uevent will be created with this call, the caller should set
     409                 :            :  * up all of the necessary sysfs files for the object and then call
     410                 :            :  * kobject_uevent() with the UEVENT_ADD parameter to ensure that
     411                 :            :  * userspace is properly notified of this kobject's creation.
     412                 :            :  *
     413                 :            :  * Return: If this function returns an error, kobject_put() must be
     414                 :            :  *         called to properly clean up the memory associated with the
     415                 :            :  *         object.  Under no instance should the kobject that is passed
     416                 :            :  *         to this function be directly freed with a call to kfree(),
     417                 :            :  *         that can leak memory.
     418                 :            :  *
     419                 :            :  *         If this function returns success, kobject_put() must also be called
     420                 :            :  *         in order to properly clean up the memory associated with the object.
     421                 :            :  *
     422                 :            :  *         In short, once this function is called, kobject_put() MUST be called
     423                 :            :  *         when the use of the object is finished in order to properly free
     424                 :            :  *         everything.
     425                 :            :  */
     426                 :      15882 : int kobject_add(struct kobject *kobj, struct kobject *parent,
     427                 :            :                 const char *fmt, ...)
     428                 :            : {
     429                 :      15882 :         va_list args;
     430                 :      15882 :         int retval;
     431                 :            : 
     432         [ +  - ]:      15882 :         if (!kobj)
     433                 :            :                 return -EINVAL;
     434                 :            : 
     435         [ -  + ]:      15882 :         if (!kobj->state_initialized) {
     436                 :          0 :                 pr_err("kobject '%s' (%p): tried to add an uninitialized object, something is seriously wrong.\n",
     437                 :            :                        kobject_name(kobj), kobj);
     438                 :          0 :                 dump_stack();
     439                 :          0 :                 return -EINVAL;
     440                 :            :         }
     441                 :      15882 :         va_start(args, fmt);
     442                 :      15882 :         retval = kobject_add_varg(kobj, parent, fmt, args);
     443                 :      15882 :         va_end(args);
     444                 :            : 
     445                 :      15882 :         return retval;
     446                 :            : }
     447                 :            : EXPORT_SYMBOL(kobject_add);
     448                 :            : 
     449                 :            : /**
     450                 :            :  * kobject_init_and_add() - Initialize a kobject structure and add it to
     451                 :            :  *                          the kobject hierarchy.
     452                 :            :  * @kobj: pointer to the kobject to initialize
     453                 :            :  * @ktype: pointer to the ktype for this kobject.
     454                 :            :  * @parent: pointer to the parent of this kobject.
     455                 :            :  * @fmt: the name of the kobject.
     456                 :            :  *
     457                 :            :  * This function combines the call to kobject_init() and kobject_add().
     458                 :            :  *
     459                 :            :  * If this function returns an error, kobject_put() must be called to
     460                 :            :  * properly clean up the memory associated with the object.  This is the
     461                 :            :  * same type of error handling after a call to kobject_add() and kobject
     462                 :            :  * lifetime rules are the same here.
     463                 :            :  */
     464                 :      14922 : int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype,
     465                 :            :                          struct kobject *parent, const char *fmt, ...)
     466                 :            : {
     467                 :      14922 :         va_list args;
     468                 :      14922 :         int retval;
     469                 :            : 
     470                 :      14922 :         kobject_init(kobj, ktype);
     471                 :            : 
     472                 :      14922 :         va_start(args, fmt);
     473                 :      14922 :         retval = kobject_add_varg(kobj, parent, fmt, args);
     474                 :      14922 :         va_end(args);
     475                 :            : 
     476                 :      14922 :         return retval;
     477                 :            : }
     478                 :            : EXPORT_SYMBOL_GPL(kobject_init_and_add);
     479                 :            : 
     480                 :            : /**
     481                 :            :  * kobject_rename() - Change the name of an object.
     482                 :            :  * @kobj: object in question.
     483                 :            :  * @new_name: object's new name
     484                 :            :  *
     485                 :            :  * It is the responsibility of the caller to provide mutual
     486                 :            :  * exclusion between two different calls of kobject_rename
     487                 :            :  * on the same kobject and to ensure that new_name is valid and
     488                 :            :  * won't conflict with other kobjects.
     489                 :            :  */
     490                 :          0 : int kobject_rename(struct kobject *kobj, const char *new_name)
     491                 :            : {
     492                 :          0 :         int error = 0;
     493                 :          0 :         const char *devpath = NULL;
     494                 :          0 :         const char *dup_name = NULL, *name;
     495                 :          0 :         char *devpath_string = NULL;
     496                 :          0 :         char *envp[2];
     497                 :            : 
     498                 :          0 :         kobj = kobject_get(kobj);
     499         [ #  # ]:          0 :         if (!kobj)
     500                 :            :                 return -EINVAL;
     501         [ #  # ]:          0 :         if (!kobj->parent) {
     502                 :          0 :                 kobject_put(kobj);
     503                 :          0 :                 return -EINVAL;
     504                 :            :         }
     505                 :            : 
     506                 :          0 :         devpath = kobject_get_path(kobj, GFP_KERNEL);
     507         [ #  # ]:          0 :         if (!devpath) {
     508                 :          0 :                 error = -ENOMEM;
     509                 :          0 :                 goto out;
     510                 :            :         }
     511         [ #  # ]:          0 :         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
     512         [ #  # ]:          0 :         if (!devpath_string) {
     513                 :          0 :                 error = -ENOMEM;
     514                 :          0 :                 goto out;
     515                 :            :         }
     516                 :          0 :         sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
     517                 :          0 :         envp[0] = devpath_string;
     518                 :          0 :         envp[1] = NULL;
     519                 :            : 
     520                 :          0 :         name = dup_name = kstrdup_const(new_name, GFP_KERNEL);
     521         [ #  # ]:          0 :         if (!name) {
     522                 :          0 :                 error = -ENOMEM;
     523                 :          0 :                 goto out;
     524                 :            :         }
     525                 :            : 
     526                 :          0 :         error = sysfs_rename_dir_ns(kobj, new_name, kobject_namespace(kobj));
     527         [ #  # ]:          0 :         if (error)
     528                 :          0 :                 goto out;
     529                 :            : 
     530                 :            :         /* Install the new kobject name */
     531                 :          0 :         dup_name = kobj->name;
     532                 :          0 :         kobj->name = name;
     533                 :            : 
     534                 :            :         /* This function is mostly/only used for network interface.
     535                 :            :          * Some hotplug package track interfaces by their name and
     536                 :            :          * therefore want to know when the name is changed by the user. */
     537                 :          0 :         kobject_uevent_env(kobj, KOBJ_MOVE, envp);
     538                 :            : 
     539                 :          0 : out:
     540                 :          0 :         kfree_const(dup_name);
     541                 :          0 :         kfree(devpath_string);
     542                 :          0 :         kfree(devpath);
     543                 :          0 :         kobject_put(kobj);
     544                 :            : 
     545                 :          0 :         return error;
     546                 :            : }
     547                 :            : EXPORT_SYMBOL_GPL(kobject_rename);
     548                 :            : 
     549                 :            : /**
     550                 :            :  * kobject_move() - Move object to another parent.
     551                 :            :  * @kobj: object in question.
     552                 :            :  * @new_parent: object's new parent (can be NULL)
     553                 :            :  */
     554                 :          0 : int kobject_move(struct kobject *kobj, struct kobject *new_parent)
     555                 :            : {
     556                 :          0 :         int error;
     557                 :          0 :         struct kobject *old_parent;
     558                 :          0 :         const char *devpath = NULL;
     559                 :          0 :         char *devpath_string = NULL;
     560                 :          0 :         char *envp[2];
     561                 :            : 
     562                 :          0 :         kobj = kobject_get(kobj);
     563         [ #  # ]:          0 :         if (!kobj)
     564                 :            :                 return -EINVAL;
     565                 :          0 :         new_parent = kobject_get(new_parent);
     566         [ #  # ]:          0 :         if (!new_parent) {
     567         [ #  # ]:          0 :                 if (kobj->kset)
     568                 :          0 :                         new_parent = kobject_get(&kobj->kset->kobj);
     569                 :            :         }
     570                 :            : 
     571                 :            :         /* old object path */
     572                 :          0 :         devpath = kobject_get_path(kobj, GFP_KERNEL);
     573         [ #  # ]:          0 :         if (!devpath) {
     574                 :          0 :                 error = -ENOMEM;
     575                 :          0 :                 goto out;
     576                 :            :         }
     577         [ #  # ]:          0 :         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
     578         [ #  # ]:          0 :         if (!devpath_string) {
     579                 :          0 :                 error = -ENOMEM;
     580                 :          0 :                 goto out;
     581                 :            :         }
     582                 :          0 :         sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
     583                 :          0 :         envp[0] = devpath_string;
     584                 :          0 :         envp[1] = NULL;
     585                 :          0 :         error = sysfs_move_dir_ns(kobj, new_parent, kobject_namespace(kobj));
     586         [ #  # ]:          0 :         if (error)
     587                 :          0 :                 goto out;
     588                 :          0 :         old_parent = kobj->parent;
     589                 :          0 :         kobj->parent = new_parent;
     590                 :          0 :         new_parent = NULL;
     591                 :          0 :         kobject_put(old_parent);
     592                 :          0 :         kobject_uevent_env(kobj, KOBJ_MOVE, envp);
     593                 :          0 : out:
     594                 :          0 :         kobject_put(new_parent);
     595                 :          0 :         kobject_put(kobj);
     596                 :          0 :         kfree(devpath_string);
     597                 :          0 :         kfree(devpath);
     598                 :          0 :         return error;
     599                 :            : }
     600                 :            : EXPORT_SYMBOL_GPL(kobject_move);
     601                 :            : 
     602                 :            : /**
     603                 :            :  * kobject_del() - Unlink kobject from hierarchy.
     604                 :            :  * @kobj: object.
     605                 :            :  *
     606                 :            :  * This is the function that should be called to delete an object
     607                 :            :  * successfully added via kobject_add().
     608                 :            :  */
     609                 :        150 : void kobject_del(struct kobject *kobj)
     610                 :            : {
     611                 :        150 :         struct kernfs_node *sd;
     612                 :        150 :         const struct kobj_type *ktype;
     613                 :            : 
     614         [ +  - ]:        150 :         if (!kobj)
     615                 :            :                 return;
     616                 :            : 
     617                 :        150 :         sd = kobj->sd;
     618         [ +  - ]:        150 :         ktype = get_ktype(kobj);
     619                 :            : 
     620         [ +  - ]:        150 :         if (ktype)
     621                 :        150 :                 sysfs_remove_groups(kobj, ktype->default_groups);
     622                 :            : 
     623                 :        150 :         sysfs_remove_dir(kobj);
     624                 :        150 :         sysfs_put(sd);
     625                 :            : 
     626                 :        150 :         kobj->state_in_sysfs = 0;
     627                 :        150 :         kobj_kset_leave(kobj);
     628                 :        150 :         kobject_put(kobj->parent);
     629                 :        150 :         kobj->parent = NULL;
     630                 :            : }
     631                 :            : EXPORT_SYMBOL(kobject_del);
     632                 :            : 
     633                 :            : /**
     634                 :            :  * kobject_get() - Increment refcount for object.
     635                 :            :  * @kobj: object.
     636                 :            :  */
     637                 :     139984 : struct kobject *kobject_get(struct kobject *kobj)
     638                 :            : {
     639         [ +  + ]:     139984 :         if (kobj) {
     640         [ -  + ]:     119512 :                 if (!kobj->state_initialized)
     641                 :          0 :                         WARN(1, KERN_WARNING
     642                 :            :                                 "kobject: '%s' (%p): is not initialized, yet kobject_get() is being called.\n",
     643                 :            :                              kobject_name(kobj), kobj);
     644                 :     119512 :                 kref_get(&kobj->kref);
     645                 :            :         }
     646                 :     139984 :         return kobj;
     647                 :            : }
     648                 :            : EXPORT_SYMBOL(kobject_get);
     649                 :            : 
     650                 :      18787 : struct kobject * __must_check kobject_get_unless_zero(struct kobject *kobj)
     651                 :            : {
     652         [ +  - ]:       8257 :         if (!kobj)
     653                 :            :                 return NULL;
     654   [ -  +  -  + ]:      18787 :         if (!kref_get_unless_zero(&kobj->kref))
     655                 :          0 :                 kobj = NULL;
     656                 :            :         return kobj;
     657                 :            : }
     658                 :            : EXPORT_SYMBOL(kobject_get_unless_zero);
     659                 :            : 
     660                 :            : /*
     661                 :            :  * kobject_cleanup - free kobject resources.
     662                 :            :  * @kobj: object to cleanup
     663                 :            :  */
     664                 :        228 : static void kobject_cleanup(struct kobject *kobj)
     665                 :            : {
     666         [ +  + ]:        228 :         struct kobj_type *t = get_ktype(kobj);
     667                 :        228 :         const char *name = kobj->name;
     668                 :            : 
     669                 :        228 :         pr_debug("kobject: '%s' (%p): %s, parent %p\n",
     670                 :            :                  kobject_name(kobj), kobj, __func__, kobj->parent);
     671                 :            : 
     672                 :        228 :         if (t && !t->release)
     673                 :            :                 pr_debug("kobject: '%s' (%p): does not have a release() function, it is broken and must be fixed. See Documentation/kobject.txt.\n",
     674                 :            :                          kobject_name(kobj), kobj);
     675                 :            : 
     676                 :            :         /* send "remove" if the caller did not do it but sent "add" */
     677         [ +  + ]:        228 :         if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) {
     678                 :         90 :                 pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n",
     679                 :            :                          kobject_name(kobj), kobj);
     680                 :         90 :                 kobject_uevent(kobj, KOBJ_REMOVE);
     681                 :            :         }
     682                 :            : 
     683                 :            :         /* remove from sysfs if the caller did not do it */
     684         [ +  + ]:        228 :         if (kobj->state_in_sysfs) {
     685                 :        120 :                 pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n",
     686                 :            :                          kobject_name(kobj), kobj);
     687                 :        120 :                 kobject_del(kobj);
     688                 :            :         }
     689                 :            : 
     690   [ +  -  +  - ]:        228 :         if (t && t->release) {
     691                 :        228 :                 pr_debug("kobject: '%s' (%p): calling ktype release\n",
     692                 :            :                          kobject_name(kobj), kobj);
     693                 :        228 :                 t->release(kobj);
     694                 :            :         }
     695                 :            : 
     696                 :            :         /* free name if we allocated it */
     697         [ +  + ]:        228 :         if (name) {
     698                 :        204 :                 pr_debug("kobject: '%s': free name\n", name);
     699                 :        204 :                 kfree_const(name);
     700                 :            :         }
     701                 :        228 : }
     702                 :            : 
     703                 :            : #ifdef CONFIG_DEBUG_KOBJECT_RELEASE
     704                 :            : static void kobject_delayed_cleanup(struct work_struct *work)
     705                 :            : {
     706                 :            :         kobject_cleanup(container_of(to_delayed_work(work),
     707                 :            :                                      struct kobject, release));
     708                 :            : }
     709                 :            : #endif
     710                 :            : 
     711                 :        228 : static void kobject_release(struct kref *kref)
     712                 :            : {
     713                 :        228 :         struct kobject *kobj = container_of(kref, struct kobject, kref);
     714                 :            : #ifdef CONFIG_DEBUG_KOBJECT_RELEASE
     715                 :            :         unsigned long delay = HZ + HZ * (get_random_int() & 0x3);
     716                 :            :         pr_info("kobject: '%s' (%p): %s, parent %p (delayed %ld)\n",
     717                 :            :                  kobject_name(kobj), kobj, __func__, kobj->parent, delay);
     718                 :            :         INIT_DELAYED_WORK(&kobj->release, kobject_delayed_cleanup);
     719                 :            : 
     720                 :            :         schedule_delayed_work(&kobj->release, delay);
     721                 :            : #else
     722                 :        228 :         kobject_cleanup(kobj);
     723                 :            : #endif
     724                 :        228 : }
     725                 :            : 
     726                 :            : /**
     727                 :            :  * kobject_put() - Decrement refcount for object.
     728                 :            :  * @kobj: object.
     729                 :            :  *
     730                 :            :  * Decrement the refcount, and if 0, call kobject_cleanup().
     731                 :            :  */
     732                 :      42935 : void kobject_put(struct kobject *kobj)
     733                 :            : {
     734         [ +  - ]:      42935 :         if (kobj) {
     735         [ -  + ]:      42935 :                 if (!kobj->state_initialized)
     736                 :          0 :                         WARN(1, KERN_WARNING
     737                 :            :                                 "kobject: '%s' (%p): is not initialized, yet kobject_put() is being called.\n",
     738                 :            :                              kobject_name(kobj), kobj);
     739                 :      42935 :                 kref_put(&kobj->kref, kobject_release);
     740                 :            :         }
     741                 :      42935 : }
     742                 :            : EXPORT_SYMBOL(kobject_put);
     743                 :            : 
     744                 :          0 : static void dynamic_kobj_release(struct kobject *kobj)
     745                 :            : {
     746                 :          0 :         pr_debug("kobject: (%p): %s\n", kobj, __func__);
     747                 :          0 :         kfree(kobj);
     748                 :          0 : }
     749                 :            : 
     750                 :            : static struct kobj_type dynamic_kobj_ktype = {
     751                 :            :         .release        = dynamic_kobj_release,
     752                 :            :         .sysfs_ops      = &kobj_sysfs_ops,
     753                 :            : };
     754                 :            : 
     755                 :            : /**
     756                 :            :  * kobject_create() - Create a struct kobject dynamically.
     757                 :            :  *
     758                 :            :  * This function creates a kobject structure dynamically and sets it up
     759                 :            :  * to be a "dynamic" kobject with a default release function set up.
     760                 :            :  *
     761                 :            :  * If the kobject was not able to be created, NULL will be returned.
     762                 :            :  * The kobject structure returned from here must be cleaned up with a
     763                 :            :  * call to kobject_put() and not kfree(), as kobject_init() has
     764                 :            :  * already been called on this structure.
     765                 :            :  */
     766                 :       2550 : struct kobject *kobject_create(void)
     767                 :            : {
     768                 :       2550 :         struct kobject *kobj;
     769                 :            : 
     770                 :       2550 :         kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
     771         [ +  - ]:       2550 :         if (!kobj)
     772                 :            :                 return NULL;
     773                 :            : 
     774                 :       2550 :         kobject_init(kobj, &dynamic_kobj_ktype);
     775                 :       2550 :         return kobj;
     776                 :            : }
     777                 :            : 
     778                 :            : /**
     779                 :            :  * kobject_create_and_add() - Create a struct kobject dynamically and
     780                 :            :  *                            register it with sysfs.
     781                 :            :  * @name: the name for the kobject
     782                 :            :  * @parent: the parent kobject of this kobject, if any.
     783                 :            :  *
     784                 :            :  * This function creates a kobject structure dynamically and registers it
     785                 :            :  * with sysfs.  When you are finished with this structure, call
     786                 :            :  * kobject_put() and the structure will be dynamically freed when
     787                 :            :  * it is no longer being used.
     788                 :            :  *
     789                 :            :  * If the kobject was not able to be created, NULL will be returned.
     790                 :            :  */
     791                 :       2550 : struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)
     792                 :            : {
     793                 :       2550 :         struct kobject *kobj;
     794                 :       2550 :         int retval;
     795                 :            : 
     796                 :       2550 :         kobj = kobject_create();
     797         [ +  - ]:       2550 :         if (!kobj)
     798                 :            :                 return NULL;
     799                 :            : 
     800                 :       2550 :         retval = kobject_add(kobj, parent, "%s", name);
     801         [ -  + ]:       2550 :         if (retval) {
     802                 :          0 :                 pr_warn("%s: kobject_add error: %d\n", __func__, retval);
     803                 :          0 :                 kobject_put(kobj);
     804                 :          0 :                 kobj = NULL;
     805                 :            :         }
     806                 :            :         return kobj;
     807                 :            : }
     808                 :            : EXPORT_SYMBOL_GPL(kobject_create_and_add);
     809                 :            : 
     810                 :            : /**
     811                 :            :  * kset_init() - Initialize a kset for use.
     812                 :            :  * @k: kset
     813                 :            :  */
     814                 :       5676 : void kset_init(struct kset *k)
     815                 :            : {
     816         [ +  - ]:       5676 :         kobject_init_internal(&k->kobj);
     817                 :       5676 :         INIT_LIST_HEAD(&k->list);
     818                 :       5676 :         spin_lock_init(&k->list_lock);
     819                 :       5676 : }
     820                 :            : 
     821                 :            : /* default kobject attribute operations */
     822                 :          0 : static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,
     823                 :            :                               char *buf)
     824                 :            : {
     825                 :          0 :         struct kobj_attribute *kattr;
     826                 :          0 :         ssize_t ret = -EIO;
     827                 :            : 
     828                 :          0 :         kattr = container_of(attr, struct kobj_attribute, attr);
     829         [ #  # ]:          0 :         if (kattr->show)
     830                 :          0 :                 ret = kattr->show(kobj, kattr, buf);
     831                 :          0 :         return ret;
     832                 :            : }
     833                 :            : 
     834                 :          0 : static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,
     835                 :            :                                const char *buf, size_t count)
     836                 :            : {
     837                 :          0 :         struct kobj_attribute *kattr;
     838                 :          0 :         ssize_t ret = -EIO;
     839                 :            : 
     840                 :          0 :         kattr = container_of(attr, struct kobj_attribute, attr);
     841         [ #  # ]:          0 :         if (kattr->store)
     842                 :          0 :                 ret = kattr->store(kobj, kattr, buf, count);
     843                 :          0 :         return ret;
     844                 :            : }
     845                 :            : 
     846                 :            : const struct sysfs_ops kobj_sysfs_ops = {
     847                 :            :         .show   = kobj_attr_show,
     848                 :            :         .store  = kobj_attr_store,
     849                 :            : };
     850                 :            : EXPORT_SYMBOL_GPL(kobj_sysfs_ops);
     851                 :            : 
     852                 :            : /**
     853                 :            :  * kset_register() - Initialize and add a kset.
     854                 :            :  * @k: kset.
     855                 :            :  */
     856                 :       4296 : int kset_register(struct kset *k)
     857                 :            : {
     858                 :       4296 :         int err;
     859                 :            : 
     860         [ +  - ]:       4296 :         if (!k)
     861                 :            :                 return -EINVAL;
     862                 :            : 
     863                 :       4296 :         kset_init(k);
     864                 :       4296 :         err = kobject_add_internal(&k->kobj);
     865         [ +  - ]:       4296 :         if (err)
     866                 :            :                 return err;
     867                 :       4296 :         kobject_uevent(&k->kobj, KOBJ_ADD);
     868                 :       4296 :         return 0;
     869                 :            : }
     870                 :            : EXPORT_SYMBOL(kset_register);
     871                 :            : 
     872                 :            : /**
     873                 :            :  * kset_unregister() - Remove a kset.
     874                 :            :  * @k: kset.
     875                 :            :  */
     876                 :          0 : void kset_unregister(struct kset *k)
     877                 :            : {
     878         [ #  # ]:          0 :         if (!k)
     879                 :            :                 return;
     880                 :          0 :         kobject_del(&k->kobj);
     881                 :          0 :         kobject_put(&k->kobj);
     882                 :            : }
     883                 :            : EXPORT_SYMBOL(kset_unregister);
     884                 :            : 
     885                 :            : /**
     886                 :            :  * kset_find_obj() - Search for object in kset.
     887                 :            :  * @kset: kset we're looking in.
     888                 :            :  * @name: object's name.
     889                 :            :  *
     890                 :            :  * Lock kset via @kset->subsys, and iterate over @kset->list,
     891                 :            :  * looking for a matching kobject. If matching object is found
     892                 :            :  * take a reference and return the object.
     893                 :            :  */
     894                 :      19590 : struct kobject *kset_find_obj(struct kset *kset, const char *name)
     895                 :            : {
     896                 :      19590 :         struct kobject *k;
     897                 :      19590 :         struct kobject *ret = NULL;
     898                 :            : 
     899                 :      19590 :         spin_lock(&kset->list_lock);
     900                 :            : 
     901         [ +  + ]:     976770 :         list_for_each_entry(k, &kset->list, entry) {
     902   [ +  -  +  + ]:     967710 :                 if (kobject_name(k) && !strcmp(kobject_name(k), name)) {
     903         [ +  - ]:      10530 :                         ret = kobject_get_unless_zero(k);
     904                 :            :                         break;
     905                 :            :                 }
     906                 :            :         }
     907                 :            : 
     908                 :      19590 :         spin_unlock(&kset->list_lock);
     909                 :      19590 :         return ret;
     910                 :            : }
     911                 :            : EXPORT_SYMBOL_GPL(kset_find_obj);
     912                 :            : 
     913                 :          0 : static void kset_release(struct kobject *kobj)
     914                 :            : {
     915                 :          0 :         struct kset *kset = container_of(kobj, struct kset, kobj);
     916                 :          0 :         pr_debug("kobject: '%s' (%p): %s\n",
     917                 :            :                  kobject_name(kobj), kobj, __func__);
     918                 :          0 :         kfree(kset);
     919                 :          0 : }
     920                 :            : 
     921                 :       2106 : static void kset_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid)
     922                 :            : {
     923         [ +  + ]:       2106 :         if (kobj->parent)
     924         [ +  + ]:       1956 :                 kobject_get_ownership(kobj->parent, uid, gid);
     925                 :       2106 : }
     926                 :            : 
     927                 :            : static struct kobj_type kset_ktype = {
     928                 :            :         .sysfs_ops      = &kobj_sysfs_ops,
     929                 :            :         .release        = kset_release,
     930                 :            :         .get_ownership  = kset_get_ownership,
     931                 :            : };
     932                 :            : 
     933                 :            : /**
     934                 :            :  * kset_create() - Create a struct kset dynamically.
     935                 :            :  *
     936                 :            :  * @name: the name for the kset
     937                 :            :  * @uevent_ops: a struct kset_uevent_ops for the kset
     938                 :            :  * @parent_kobj: the parent kobject of this kset, if any.
     939                 :            :  *
     940                 :            :  * This function creates a kset structure dynamically.  This structure can
     941                 :            :  * then be registered with the system and show up in sysfs with a call to
     942                 :            :  * kset_register().  When you are finished with this structure, if
     943                 :            :  * kset_register() has been called, call kset_unregister() and the
     944                 :            :  * structure will be dynamically freed when it is no longer being used.
     945                 :            :  *
     946                 :            :  * If the kset was not able to be created, NULL will be returned.
     947                 :            :  */
     948                 :       2076 : static struct kset *kset_create(const char *name,
     949                 :            :                                 const struct kset_uevent_ops *uevent_ops,
     950                 :            :                                 struct kobject *parent_kobj)
     951                 :            : {
     952                 :       2076 :         struct kset *kset;
     953                 :       2076 :         int retval;
     954                 :            : 
     955                 :       2076 :         kset = kzalloc(sizeof(*kset), GFP_KERNEL);
     956         [ +  - ]:       2076 :         if (!kset)
     957                 :            :                 return NULL;
     958                 :       2076 :         retval = kobject_set_name(&kset->kobj, "%s", name);
     959         [ -  + ]:       2076 :         if (retval) {
     960                 :          0 :                 kfree(kset);
     961                 :          0 :                 return NULL;
     962                 :            :         }
     963                 :       2076 :         kset->uevent_ops = uevent_ops;
     964                 :       2076 :         kset->kobj.parent = parent_kobj;
     965                 :            : 
     966                 :            :         /*
     967                 :            :          * The kobject of this kset will have a type of kset_ktype and belong to
     968                 :            :          * no kset itself.  That way we can properly free it when it is
     969                 :            :          * finished being used.
     970                 :            :          */
     971                 :       2076 :         kset->kobj.ktype = &kset_ktype;
     972                 :       2076 :         kset->kobj.kset = NULL;
     973                 :            : 
     974                 :       2076 :         return kset;
     975                 :            : }
     976                 :            : 
     977                 :            : /**
     978                 :            :  * kset_create_and_add() - Create a struct kset dynamically and add it to sysfs.
     979                 :            :  *
     980                 :            :  * @name: the name for the kset
     981                 :            :  * @uevent_ops: a struct kset_uevent_ops for the kset
     982                 :            :  * @parent_kobj: the parent kobject of this kset, if any.
     983                 :            :  *
     984                 :            :  * This function creates a kset structure dynamically and registers it
     985                 :            :  * with sysfs.  When you are finished with this structure, call
     986                 :            :  * kset_unregister() and the structure will be dynamically freed when it
     987                 :            :  * is no longer being used.
     988                 :            :  *
     989                 :            :  * If the kset was not able to be created, NULL will be returned.
     990                 :            :  */
     991                 :       2076 : struct kset *kset_create_and_add(const char *name,
     992                 :            :                                  const struct kset_uevent_ops *uevent_ops,
     993                 :            :                                  struct kobject *parent_kobj)
     994                 :            : {
     995                 :       2076 :         struct kset *kset;
     996                 :       2076 :         int error;
     997                 :            : 
     998                 :       2076 :         kset = kset_create(name, uevent_ops, parent_kobj);
     999         [ +  - ]:       2076 :         if (!kset)
    1000                 :            :                 return NULL;
    1001                 :       2076 :         error = kset_register(kset);
    1002         [ -  + ]:       2076 :         if (error) {
    1003                 :          0 :                 kfree(kset);
    1004                 :          0 :                 return NULL;
    1005                 :            :         }
    1006                 :            :         return kset;
    1007                 :            : }
    1008                 :            : EXPORT_SYMBOL_GPL(kset_create_and_add);
    1009                 :            : 
    1010                 :            : 
    1011                 :            : static DEFINE_SPINLOCK(kobj_ns_type_lock);
    1012                 :            : static const struct kobj_ns_type_operations *kobj_ns_ops_tbl[KOBJ_NS_TYPES];
    1013                 :            : 
    1014                 :         30 : int kobj_ns_type_register(const struct kobj_ns_type_operations *ops)
    1015                 :            : {
    1016                 :         30 :         enum kobj_ns_type type = ops->type;
    1017                 :         30 :         int error;
    1018                 :            : 
    1019                 :         30 :         spin_lock(&kobj_ns_type_lock);
    1020                 :            : 
    1021                 :         30 :         error = -EINVAL;
    1022         [ -  + ]:         30 :         if (type >= KOBJ_NS_TYPES)
    1023                 :          0 :                 goto out;
    1024                 :            : 
    1025                 :         30 :         error = -EINVAL;
    1026         [ -  + ]:         30 :         if (type <= KOBJ_NS_TYPE_NONE)
    1027                 :          0 :                 goto out;
    1028                 :            : 
    1029                 :         30 :         error = -EBUSY;
    1030         [ -  + ]:         30 :         if (kobj_ns_ops_tbl[type])
    1031                 :          0 :                 goto out;
    1032                 :            : 
    1033                 :         30 :         error = 0;
    1034                 :         30 :         kobj_ns_ops_tbl[type] = ops;
    1035                 :            : 
    1036                 :         30 : out:
    1037                 :         30 :         spin_unlock(&kobj_ns_type_lock);
    1038                 :         30 :         return error;
    1039                 :            : }
    1040                 :            : 
    1041                 :        132 : int kobj_ns_type_registered(enum kobj_ns_type type)
    1042                 :            : {
    1043                 :        132 :         int registered = 0;
    1044                 :            : 
    1045                 :        132 :         spin_lock(&kobj_ns_type_lock);
    1046   [ -  -  +  - ]:        132 :         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES))
    1047                 :        132 :                 registered = kobj_ns_ops_tbl[type] != NULL;
    1048                 :        132 :         spin_unlock(&kobj_ns_type_lock);
    1049                 :            : 
    1050         [ -  + ]:        132 :         return registered;
    1051                 :            : }
    1052                 :            : 
    1053                 :     136200 : const struct kobj_ns_type_operations *kobj_child_ns_ops(struct kobject *parent)
    1054                 :            : {
    1055                 :     136200 :         const struct kobj_ns_type_operations *ops = NULL;
    1056                 :            : 
    1057   [ +  -  +  +  :     129330 :         if (parent && parent->ktype && parent->ktype->child_ns_type)
          -  -  -  -  -  
          -  +  -  +  -  
          +  +  +  -  +  
                      + ]
    1058                 :      18522 :                 ops = parent->ktype->child_ns_type(parent);
    1059                 :            : 
    1060   [ +  +  +  + ]:       8226 :         return ops;
    1061                 :            : }
    1062                 :            : 
    1063                 :     101100 : const struct kobj_ns_type_operations *kobj_ns_ops(struct kobject *kobj)
    1064                 :            : {
    1065   [ +  +  +  + ]:     101100 :         return kobj_child_ns_ops(kobj->parent);
    1066                 :            : }
    1067                 :            : 
    1068                 :         60 : bool kobj_ns_current_may_mount(enum kobj_ns_type type)
    1069                 :            : {
    1070                 :         60 :         bool may_mount = true;
    1071                 :            : 
    1072                 :         60 :         spin_lock(&kobj_ns_type_lock);
    1073         [ +  - ]:         60 :         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
    1074         [ +  - ]:         60 :             kobj_ns_ops_tbl[type])
    1075                 :         60 :                 may_mount = kobj_ns_ops_tbl[type]->current_may_mount();
    1076                 :         60 :         spin_unlock(&kobj_ns_type_lock);
    1077                 :            : 
    1078                 :         60 :         return may_mount;
    1079                 :            : }
    1080                 :            : 
    1081                 :         60 : void *kobj_ns_grab_current(enum kobj_ns_type type)
    1082                 :            : {
    1083                 :         60 :         void *ns = NULL;
    1084                 :            : 
    1085                 :         60 :         spin_lock(&kobj_ns_type_lock);
    1086         [ +  - ]:         60 :         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
    1087         [ +  - ]:         60 :             kobj_ns_ops_tbl[type])
    1088                 :         60 :                 ns = kobj_ns_ops_tbl[type]->grab_current_ns();
    1089                 :         60 :         spin_unlock(&kobj_ns_type_lock);
    1090                 :            : 
    1091                 :         60 :         return ns;
    1092                 :            : }
    1093                 :            : EXPORT_SYMBOL_GPL(kobj_ns_grab_current);
    1094                 :            : 
    1095                 :          0 : const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk)
    1096                 :            : {
    1097                 :          0 :         const void *ns = NULL;
    1098                 :            : 
    1099                 :          0 :         spin_lock(&kobj_ns_type_lock);
    1100         [ #  # ]:          0 :         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
    1101         [ #  # ]:          0 :             kobj_ns_ops_tbl[type])
    1102                 :          0 :                 ns = kobj_ns_ops_tbl[type]->netlink_ns(sk);
    1103                 :          0 :         spin_unlock(&kobj_ns_type_lock);
    1104                 :            : 
    1105                 :          0 :         return ns;
    1106                 :            : }
    1107                 :            : 
    1108                 :          0 : const void *kobj_ns_initial(enum kobj_ns_type type)
    1109                 :            : {
    1110                 :          0 :         const void *ns = NULL;
    1111                 :            : 
    1112                 :          0 :         spin_lock(&kobj_ns_type_lock);
    1113         [ #  # ]:          0 :         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
    1114         [ #  # ]:          0 :             kobj_ns_ops_tbl[type])
    1115                 :          0 :                 ns = kobj_ns_ops_tbl[type]->initial_ns();
    1116                 :          0 :         spin_unlock(&kobj_ns_type_lock);
    1117                 :            : 
    1118                 :          0 :         return ns;
    1119                 :            : }
    1120                 :            : 
    1121                 :         30 : void kobj_ns_drop(enum kobj_ns_type type, void *ns)
    1122                 :            : {
    1123                 :         30 :         spin_lock(&kobj_ns_type_lock);
    1124         [ +  - ]:         30 :         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
    1125   [ +  -  +  - ]:         30 :             kobj_ns_ops_tbl[type] && kobj_ns_ops_tbl[type]->drop_ns)
    1126                 :         30 :                 kobj_ns_ops_tbl[type]->drop_ns(ns);
    1127                 :         30 :         spin_unlock(&kobj_ns_type_lock);
    1128                 :         30 : }
    1129                 :            : EXPORT_SYMBOL_GPL(kobj_ns_drop);

Generated by: LCOV version 1.14