LCOV - code coverage report
Current view: top level - lib - kobject.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 238 353 67.4 %
Date: 2020-09-30 20:25:40 Functions: 37 47 78.7 %
Branches: 125 230 54.3 %

           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                 :     277791 : const void *kobject_namespace(struct kobject *kobj)
      29                 :            : {
      30                 :            :         const struct kobj_ns_type_operations *ns_ops = kobj_ns_ops(kobj);
      31                 :            : 
      32   [ +  +  +  - ]:     277793 :         if (!ns_ops || ns_ops->type == KOBJ_NS_TYPE_NONE)
      33                 :            :                 return NULL;
      34                 :            : 
      35                 :        621 :         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                 :    1100381 : void kobject_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid)
      49                 :            : {
      50                 :    1111766 :         *uid = GLOBAL_ROOT_UID;
      51                 :    1111766 :         *gid = GLOBAL_ROOT_GID;
      52                 :            : 
      53   [ +  +  +  + ]:    1111766 :         if (kobj->ktype->get_ownership)
      54                 :     414828 :                 kobj->ktype->get_ownership(kobj, uid, gid);
      55                 :    1100381 : }
      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                 :     277793 : static int populate_dir(struct kobject *kobj)
      67                 :            : {
      68                 :            :         struct kobj_type *t = get_ktype(kobj);
      69                 :            :         struct attribute *attr;
      70                 :            :         int error = 0;
      71                 :            :         int i;
      72                 :            : 
      73   [ +  +  +  + ]:     277793 :         if (t && t->default_attrs) {
      74         [ +  + ]:       3726 :                 for (i = 0; (attr = t->default_attrs[i]) != NULL; i++) {
      75                 :            :                         error = sysfs_create_file(kobj, attr);
      76         [ +  - ]:       3726 :                         if (error)
      77                 :            :                                 break;
      78                 :            :                 }
      79                 :            :         }
      80                 :     277793 :         return error;
      81                 :            : }
      82                 :            : 
      83                 :     277793 : static int create_dir(struct kobject *kobj)
      84                 :            : {
      85                 :            :         const struct kobj_type *ktype = get_ktype(kobj);
      86                 :            :         const struct kobj_ns_type_operations *ops;
      87                 :            :         int error;
      88                 :            : 
      89                 :     277793 :         error = sysfs_create_dir_ns(kobj, kobject_namespace(kobj));
      90         [ +  + ]:     277794 :         if (error)
      91                 :            :                 return error;
      92                 :            : 
      93                 :     277790 :         error = populate_dir(kobj);
      94         [ -  + ]:     277791 :         if (error) {
      95                 :          0 :                 sysfs_remove_dir(kobj);
      96                 :          0 :                 return error;
      97                 :            :         }
      98                 :            : 
      99         [ +  - ]:     277791 :         if (ktype) {
     100                 :     277791 :                 error = sysfs_create_groups(kobj, ktype->default_groups);
     101         [ -  + ]:     277792 :                 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                 :     277792 :         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                 :            :         ops = kobj_child_ns_ops(kobj);
     118         [ +  + ]:     277787 :         if (ops) {
     119         [ -  + ]:       1035 :                 BUG_ON(ops->type <= KOBJ_NS_TYPE_NONE);
     120         [ -  + ]:       1035 :                 BUG_ON(ops->type >= KOBJ_NS_TYPES);
     121         [ -  + ]:       1035 :                 BUG_ON(!kobj_ns_type_registered(ops->type));
     122                 :            : 
     123                 :       1035 :                 sysfs_enable_ns(kobj->sd);
     124                 :            :         }
     125                 :            : 
     126                 :            :         return 0;
     127                 :            : }
     128                 :            : 
     129                 :     283286 : static int get_kobj_path_length(struct kobject *kobj)
     130                 :            : {
     131                 :            :         int length = 1;
     132                 :            :         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                 :            :         do {
     139         [ +  - ]:    1044124 :                 if (kobject_name(parent) == NULL)
     140                 :            :                         return 0;
     141                 :    1044130 :                 length += strlen(kobject_name(parent)) + 1;
     142                 :    1044130 :                 parent = parent->parent;
     143         [ +  + ]:    1044130 :         } while (parent);
     144                 :     283292 :         return length;
     145                 :            : }
     146                 :            : 
     147                 :     283293 : static void fill_kobj_path(struct kobject *kobj, char *path, int length)
     148                 :            : {
     149                 :            :         struct kobject *parent;
     150                 :            : 
     151                 :     283293 :         --length;
     152         [ +  + ]:    1327410 :         for (parent = kobj; parent; parent = parent->parent) {
     153                 :    1044117 :                 int cur = strlen(kobject_name(parent));
     154                 :            :                 /* back up enough to print this name with '/' */
     155                 :    1044117 :                 length -= cur;
     156                 :    1044117 :                 memcpy(path + length, kobject_name(parent), cur);
     157                 :    1044117 :                 *(path + --length) = '/';
     158                 :            :         }
     159                 :            : 
     160                 :            :         pr_debug("kobject: '%s' (%p): %s: path = '%s'\n", kobject_name(kobj),
     161                 :            :                  kobj, __func__, path);
     162                 :     283293 : }
     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                 :     283284 : char *kobject_get_path(struct kobject *kobj, gfp_t gfp_mask)
     172                 :            : {
     173                 :            :         char *path;
     174                 :            :         int len;
     175                 :            : 
     176                 :     283284 :         len = get_kobj_path_length(kobj);
     177         [ +  + ]:     283292 :         if (len == 0)
     178                 :            :                 return NULL;
     179                 :     283285 :         path = kzalloc(len, gfp_mask);
     180         [ +  - ]:     283291 :         if (!path)
     181                 :            :                 return NULL;
     182                 :     283291 :         fill_kobj_path(kobj, path, len);
     183                 :            : 
     184                 :     283293 :         return path;
     185                 :            : }
     186                 :            : EXPORT_SYMBOL_GPL(kobject_get_path);
     187                 :            : 
     188                 :            : /* add the kobject to its kset's list */
     189                 :     180085 : static void kobj_kset_join(struct kobject *kobj)
     190                 :            : {
     191         [ +  - ]:     180085 :         if (!kobj->kset)
     192                 :     180085 :                 return;
     193                 :            : 
     194                 :     180090 :         kset_get(kobj->kset);
     195                 :     180085 :         spin_lock(&kobj->kset->list_lock);
     196                 :     180089 :         list_add_tail(&kobj->entry, &kobj->kset->list);
     197                 :     180089 :         spin_unlock(&kobj->kset->list_lock);
     198                 :            : }
     199                 :            : 
     200                 :            : /* remove the kobject from its kset's list */
     201                 :        207 : static void kobj_kset_leave(struct kobject *kobj)
     202                 :            : {
     203         [ +  - ]:        207 :         if (!kobj->kset)
     204                 :        207 :                 return;
     205                 :            : 
     206                 :            :         spin_lock(&kobj->kset->list_lock);
     207                 :        207 :         list_del_init(&kobj->entry);
     208                 :        207 :         spin_unlock(&kobj->kset->list_lock);
     209                 :        207 :         kset_put(kobj->kset);
     210                 :            : }
     211                 :            : 
     212                 :            : static void kobject_init_internal(struct kobject *kobj)
     213                 :            : {
     214   [ +  -  +  -  :     317941 :         if (!kobj)
                   +  + ]
     215                 :            :                 return;
     216                 :            :         kref_init(&kobj->kref);
     217                 :     317940 :         INIT_LIST_HEAD(&kobj->entry);
     218                 :     317940 :         kobj->state_in_sysfs = 0;
     219                 :     317940 :         kobj->state_add_uevent_sent = 0;
     220                 :     317940 :         kobj->state_remove_uevent_sent = 0;
     221                 :     317940 :         kobj->state_initialized = 1;
     222                 :            : }
     223                 :            : 
     224                 :            : 
     225                 :     277790 : static int kobject_add_internal(struct kobject *kobj)
     226                 :            : {
     227                 :            :         int error = 0;
     228                 :            :         struct kobject *parent;
     229                 :            : 
     230         [ +  + ]:     277790 :         if (!kobj)
     231                 :            :                 return -ENOENT;
     232                 :            : 
     233   [ +  +  +  + ]:     277789 :         if (!kobj->name || !kobj->name[0]) {
     234                 :          5 :                 WARN(1,
     235                 :            :                      "kobject: (%p): attempted to be registered with empty name!\n",
     236                 :            :                      kobj);
     237                 :          0 :                 return -EINVAL;
     238                 :            :         }
     239                 :            : 
     240                 :     277786 :         parent = kobject_get(kobj->parent);
     241                 :            : 
     242                 :            :         /* join kset if set, use it as parent if we do not already have one */
     243         [ +  + ]:     277791 :         if (kobj->kset) {
     244         [ +  + ]:     180085 :                 if (!parent)
     245                 :      74519 :                         parent = kobject_get(&kobj->kset->kobj);
     246                 :     180085 :                 kobj_kset_join(kobj);
     247                 :     180090 :                 kobj->parent = parent;
     248                 :            :         }
     249                 :            : 
     250                 :            :         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                 :     277796 :         error = create_dir(kobj);
     256         [ -  + ]:     277790 :         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                 :     277790 :                 kobj->state_in_sysfs = 1;
     271                 :            : 
     272                 :     277791 :         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                 :     357280 : int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
     282                 :            :                                   va_list vargs)
     283                 :            : {
     284                 :            :         const char *s;
     285                 :            : 
     286   [ +  +  +  + ]:     357280 :         if (kobj->name && !fmt)
     287                 :            :                 return 0;
     288                 :            : 
     289                 :     288763 :         s = kvasprintf_const(GFP_KERNEL, fmt, vargs);
     290         [ +  - ]:     288765 :         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         [ -  + ]:     288765 :         if (strchr(s, '/')) {
     300                 :            :                 char *t;
     301                 :            : 
     302                 :          0 :                 t = kstrdup(s, GFP_KERNEL);
     303                 :          0 :                 kfree_const(s);
     304         [ #  # ]:          0 :                 if (!t)
     305                 :            :                         return -ENOMEM;
     306                 :          0 :                 strreplace(t, '/', '!');
     307                 :            :                 s = t;
     308                 :            :         }
     309                 :     288765 :         kfree_const(kobj->name);
     310                 :     288761 :         kobj->name = s;
     311                 :            : 
     312                 :     288761 :         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                 :      30222 : int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
     325                 :            : {
     326                 :            :         va_list vargs;
     327                 :            :         int retval;
     328                 :            : 
     329                 :      30222 :         va_start(vargs, fmt);
     330                 :      30222 :         retval = kobject_set_name_vargs(kobj, fmt, vargs);
     331                 :      30222 :         va_end(vargs);
     332                 :            : 
     333                 :      30222 :         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                 :     279447 : void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
     350                 :            : {
     351                 :            :         char *err_str;
     352                 :            : 
     353         [ +  + ]:     279447 :         if (!kobj) {
     354                 :            :                 err_str = "invalid kobject pointer!";
     355                 :            :                 goto error;
     356                 :            :         }
     357         [ +  + ]:     279446 :         if (!ktype) {
     358                 :            :                 err_str = "must have a ktype to be initialized properly!\n";
     359                 :            :                 goto error;
     360                 :            :         }
     361         [ -  + ]:     279443 :         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                 :            :         kobject_init_internal(kobj);
     369                 :     279439 :         kobj->ktype = ktype;
     370                 :     558878 :         return;
     371                 :            : 
     372                 :            : error:
     373                 :          6 :         pr_err("kobject (%p): %s\n", kobj, err_str);
     374                 :          0 :         dump_stack();
     375                 :            : }
     376                 :            : EXPORT_SYMBOL(kobject_init);
     377                 :            : 
     378                 :     249846 : static __printf(3, 0) int kobject_add_varg(struct kobject *kobj,
     379                 :            :                                            struct kobject *parent,
     380                 :            :                                            const char *fmt, va_list vargs)
     381                 :            : {
     382                 :            :         int retval;
     383                 :            : 
     384                 :     249846 :         retval = kobject_set_name_vargs(kobj, fmt, vargs);
     385         [ -  + ]:     249848 :         if (retval) {
     386                 :          0 :                 pr_err("kobject: can not set name properly!\n");
     387                 :          0 :                 return retval;
     388                 :            :         }
     389                 :     249848 :         kobj->parent = parent;
     390                 :     249848 :         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                 :     191267 : int kobject_add(struct kobject *kobj, struct kobject *parent,
     427                 :            :                 const char *fmt, ...)
     428                 :            : {
     429                 :            :         va_list args;
     430                 :            :         int retval;
     431                 :            : 
     432         [ +  + ]:     191267 :         if (!kobj)
     433                 :            :                 return -EINVAL;
     434                 :            : 
     435         [ -  + ]:     191251 :         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                 :     191251 :         va_start(args, fmt);
     442                 :     191251 :         retval = kobject_add_varg(kobj, parent, fmt, args);
     443                 :     191268 :         va_end(args);
     444                 :            : 
     445                 :     191268 :         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                 :      58581 : int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype,
     465                 :            :                          struct kobject *parent, const char *fmt, ...)
     466                 :            : {
     467                 :            :         va_list args;
     468                 :            :         int retval;
     469                 :            : 
     470                 :      58581 :         kobject_init(kobj, ktype);
     471                 :            : 
     472                 :      58581 :         va_start(args, fmt);
     473                 :      58581 :         retval = kobject_add_varg(kobj, parent, fmt, args);
     474                 :      58580 :         va_end(args);
     475                 :            : 
     476                 :      58580 :         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                 :            :         int error = 0;
     493                 :            :         const char *devpath = NULL;
     494                 :            :         const char *dup_name = NULL, *name;
     495                 :            :         char *devpath_string = NULL;
     496                 :            :         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                 :            :                 error = -ENOMEM;
     509                 :            :                 goto out;
     510                 :            :         }
     511                 :          0 :         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
     512         [ #  # ]:          0 :         if (!devpath_string) {
     513                 :            :                 error = -ENOMEM;
     514                 :            :                 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                 :            :                 error = -ENOMEM;
     523                 :            :                 goto out;
     524                 :            :         }
     525                 :            : 
     526                 :          0 :         error = sysfs_rename_dir_ns(kobj, new_name, kobject_namespace(kobj));
     527         [ #  # ]:          0 :         if (error)
     528                 :            :                 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                 :            : 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                 :            :         int error;
     557                 :            :         struct kobject *old_parent;
     558                 :            :         const char *devpath = NULL;
     559                 :            :         char *devpath_string = NULL;
     560                 :            :         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                 :            :                 error = -ENOMEM;
     575                 :            :                 goto out;
     576                 :            :         }
     577                 :          0 :         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
     578         [ #  # ]:          0 :         if (!devpath_string) {
     579                 :            :                 error = -ENOMEM;
     580                 :            :                 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                 :            :                 goto out;
     588                 :          0 :         old_parent = kobj->parent;
     589                 :          0 :         kobj->parent = new_parent;
     590                 :            :         new_parent = NULL;
     591                 :          0 :         kobject_put(old_parent);
     592                 :          0 :         kobject_uevent_env(kobj, KOBJ_MOVE, envp);
     593                 :            : 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                 :        207 : static void __kobject_del(struct kobject *kobj)
     603                 :            : {
     604                 :            :         struct kernfs_node *sd;
     605                 :            :         const struct kobj_type *ktype;
     606                 :            : 
     607         [ +  - ]:        207 :         if (!kobj)
     608                 :        207 :                 return;
     609                 :            : 
     610                 :        207 :         sd = kobj->sd;
     611                 :            :         ktype = get_ktype(kobj);
     612                 :            : 
     613         [ +  - ]:        207 :         if (ktype)
     614                 :        207 :                 sysfs_remove_groups(kobj, ktype->default_groups);
     615                 :            : 
     616                 :        207 :         sysfs_remove_dir(kobj);
     617                 :            :         sysfs_put(sd);
     618                 :            : 
     619                 :        207 :         kobj->state_in_sysfs = 0;
     620                 :        207 :         kobj_kset_leave(kobj);
     621                 :        207 :         kobj->parent = NULL;
     622                 :            : }
     623                 :            : 
     624                 :            : /**
     625                 :            :  * kobject_del() - Unlink kobject from hierarchy.
     626                 :            :  * @kobj: object.
     627                 :            :  *
     628                 :            :  * This is the function that should be called to delete an object
     629                 :            :  * successfully added via kobject_add().
     630                 :            :  */
     631                 :        207 : void kobject_del(struct kobject *kobj)
     632                 :            : {
     633                 :        207 :         struct kobject *parent = kobj->parent;
     634                 :            : 
     635                 :        207 :         __kobject_del(kobj);
     636                 :        207 :         kobject_put(parent);
     637                 :        207 : }
     638                 :            : EXPORT_SYMBOL(kobject_del);
     639                 :            : 
     640                 :            : /**
     641                 :            :  * kobject_get() - Increment refcount for object.
     642                 :            :  * @kobj: object.
     643                 :            :  */
     644                 :    1544060 : struct kobject *kobject_get(struct kobject *kobj)
     645                 :            : {
     646         [ +  + ]:    1544060 :         if (kobj) {
     647         [ -  + ]:    1447574 :                 if (!kobj->state_initialized)
     648                 :          0 :                         WARN(1, KERN_WARNING
     649                 :            :                                 "kobject: '%s' (%p): is not initialized, yet kobject_get() is being called.\n",
     650                 :            :                              kobject_name(kobj), kobj);
     651                 :            :                 kref_get(&kobj->kref);
     652                 :            :         }
     653                 :    1544088 :         return kobj;
     654                 :            : }
     655                 :            : EXPORT_SYMBOL(kobject_get);
     656                 :            : 
     657                 :     177755 : struct kobject * __must_check kobject_get_unless_zero(struct kobject *kobj)
     658                 :            : {
     659   [ +  -  +  + ]:     225572 :         if (!kobj)
     660                 :            :                 return NULL;
     661   [ -  +  -  + ]:     225572 :         if (!kref_get_unless_zero(&kobj->kref))
     662                 :            :                 kobj = NULL;
     663                 :     177755 :         return kobj;
     664                 :            : }
     665                 :            : EXPORT_SYMBOL(kobject_get_unless_zero);
     666                 :            : 
     667                 :            : /*
     668                 :            :  * kobject_cleanup - free kobject resources.
     669                 :            :  * @kobj: object to cleanup
     670                 :            :  */
     671                 :        414 : static void kobject_cleanup(struct kobject *kobj)
     672                 :            : {
     673                 :        414 :         struct kobject *parent = kobj->parent;
     674                 :            :         struct kobj_type *t = get_ktype(kobj);
     675                 :        414 :         const char *name = kobj->name;
     676                 :            : 
     677                 :            :         pr_debug("kobject: '%s' (%p): %s, parent %p\n",
     678                 :            :                  kobject_name(kobj), kobj, __func__, kobj->parent);
     679                 :            : 
     680                 :            :         if (t && !t->release)
     681                 :            :                 pr_debug("kobject: '%s' (%p): does not have a release() function, it is broken and must be fixed. See Documentation/kobject.txt.\n",
     682                 :            :                          kobject_name(kobj), kobj);
     683                 :            : 
     684                 :            :         /* send "remove" if the caller did not do it but sent "add" */
     685         [ -  + ]:        414 :         if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) {
     686                 :            :                 pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n",
     687                 :            :                          kobject_name(kobj), kobj);
     688                 :          0 :                 kobject_uevent(kobj, KOBJ_REMOVE);
     689                 :            :         }
     690                 :            : 
     691                 :            :         /* remove from sysfs if the caller did not do it */
     692         [ -  + ]:        414 :         if (kobj->state_in_sysfs) {
     693                 :            :                 pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n",
     694                 :            :                          kobject_name(kobj), kobj);
     695                 :          0 :                 __kobject_del(kobj);
     696                 :            :         } else {
     697                 :            :                 /* avoid dropping the parent reference unnecessarily */
     698                 :            :                 parent = NULL;
     699                 :            :         }
     700                 :            : 
     701   [ +  -  +  - ]:        414 :         if (t && t->release) {
     702                 :            :                 pr_debug("kobject: '%s' (%p): calling ktype release\n",
     703                 :            :                          kobject_name(kobj), kobj);
     704                 :        414 :                 t->release(kobj);
     705                 :            :         }
     706                 :            : 
     707                 :            :         /* free name if we allocated it */
     708         [ +  - ]:        414 :         if (name) {
     709                 :            :                 pr_debug("kobject: '%s': free name\n", name);
     710                 :        414 :                 kfree_const(name);
     711                 :            :         }
     712                 :            : 
     713                 :        414 :         kobject_put(parent);
     714                 :        414 : }
     715                 :            : 
     716                 :            : #ifdef CONFIG_DEBUG_KOBJECT_RELEASE
     717                 :            : static void kobject_delayed_cleanup(struct work_struct *work)
     718                 :            : {
     719                 :            :         kobject_cleanup(container_of(to_delayed_work(work),
     720                 :            :                                      struct kobject, release));
     721                 :            : }
     722                 :            : #endif
     723                 :            : 
     724                 :        414 : static void kobject_release(struct kref *kref)
     725                 :            : {
     726                 :        414 :         struct kobject *kobj = container_of(kref, struct kobject, kref);
     727                 :            : #ifdef CONFIG_DEBUG_KOBJECT_RELEASE
     728                 :            :         unsigned long delay = HZ + HZ * (get_random_int() & 0x3);
     729                 :            :         pr_info("kobject: '%s' (%p): %s, parent %p (delayed %ld)\n",
     730                 :            :                  kobject_name(kobj), kobj, __func__, kobj->parent, delay);
     731                 :            :         INIT_DELAYED_WORK(&kobj->release, kobject_delayed_cleanup);
     732                 :            : 
     733                 :            :         schedule_delayed_work(&kobj->release, delay);
     734                 :            : #else
     735                 :        414 :         kobject_cleanup(kobj);
     736                 :            : #endif
     737                 :        414 : }
     738                 :            : 
     739                 :            : /**
     740                 :            :  * kobject_put() - Decrement refcount for object.
     741                 :            :  * @kobj: object.
     742                 :            :  *
     743                 :            :  * Decrement the refcount, and if 0, call kobject_cleanup().
     744                 :            :  */
     745                 :     893738 : void kobject_put(struct kobject *kobj)
     746                 :            : {
     747         [ +  + ]:     893738 :         if (kobj) {
     748         [ -  + ]:     893233 :                 if (!kobj->state_initialized)
     749                 :          0 :                         WARN(1, KERN_WARNING
     750                 :            :                                 "kobject: '%s' (%p): is not initialized, yet kobject_put() is being called.\n",
     751                 :            :                              kobject_name(kobj), kobj);
     752                 :     893233 :                 kref_put(&kobj->kref, kobject_release);
     753                 :            :         }
     754                 :     893888 : }
     755                 :            : EXPORT_SYMBOL(kobject_put);
     756                 :            : 
     757                 :          0 : static void dynamic_kobj_release(struct kobject *kobj)
     758                 :            : {
     759                 :            :         pr_debug("kobject: (%p): %s\n", kobj, __func__);
     760                 :          0 :         kfree(kobj);
     761                 :          0 : }
     762                 :            : 
     763                 :            : static struct kobj_type dynamic_kobj_ktype = {
     764                 :            :         .release        = dynamic_kobj_release,
     765                 :            :         .sysfs_ops      = &kobj_sysfs_ops,
     766                 :            : };
     767                 :            : 
     768                 :            : /**
     769                 :            :  * kobject_create() - Create a struct kobject dynamically.
     770                 :            :  *
     771                 :            :  * This function creates a kobject structure dynamically and sets it up
     772                 :            :  * to be a "dynamic" kobject with a default release function set up.
     773                 :            :  *
     774                 :            :  * If the kobject was not able to be created, NULL will be returned.
     775                 :            :  * The kobject structure returned from here must be cleaned up with a
     776                 :            :  * call to kobject_put() and not kfree(), as kobject_init() has
     777                 :            :  * already been called on this structure.
     778                 :            :  */
     779                 :      31877 : struct kobject *kobject_create(void)
     780                 :            : {
     781                 :            :         struct kobject *kobj;
     782                 :            : 
     783                 :      31877 :         kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
     784         [ +  - ]:      31877 :         if (!kobj)
     785                 :            :                 return NULL;
     786                 :            : 
     787                 :      31878 :         kobject_init(kobj, &dynamic_kobj_ktype);
     788                 :      31876 :         return kobj;
     789                 :            : }
     790                 :            : 
     791                 :            : /**
     792                 :            :  * kobject_create_and_add() - Create a struct kobject dynamically and
     793                 :            :  *                            register it with sysfs.
     794                 :            :  * @name: the name for the kobject
     795                 :            :  * @parent: the parent kobject of this kobject, if any.
     796                 :            :  *
     797                 :            :  * This function creates a kobject structure dynamically and registers it
     798                 :            :  * with sysfs.  When you are finished with this structure, call
     799                 :            :  * kobject_put() and the structure will be dynamically freed when
     800                 :            :  * it is no longer being used.
     801                 :            :  *
     802                 :            :  * If the kobject was not able to be created, NULL will be returned.
     803                 :            :  */
     804                 :      31878 : struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)
     805                 :            : {
     806                 :            :         struct kobject *kobj;
     807                 :            :         int retval;
     808                 :            : 
     809                 :      31878 :         kobj = kobject_create();
     810         [ +  - ]:      31876 :         if (!kobj)
     811                 :            :                 return NULL;
     812                 :            : 
     813                 :      31877 :         retval = kobject_add(kobj, parent, "%s", name);
     814         [ -  + ]:      31878 :         if (retval) {
     815                 :          0 :                 pr_warn("%s: kobject_add error: %d\n", __func__, retval);
     816                 :          0 :                 kobject_put(kobj);
     817                 :            :                 kobj = NULL;
     818                 :            :         }
     819                 :      31878 :         return kobj;
     820                 :            : }
     821                 :            : EXPORT_SYMBOL_GPL(kobject_create_and_add);
     822                 :            : 
     823                 :            : /**
     824                 :            :  * kset_init() - Initialize a kset for use.
     825                 :            :  * @k: kset
     826                 :            :  */
     827                 :      10557 : void kset_init(struct kset *k)
     828                 :            : {
     829                 :      38502 :         kobject_init_internal(&k->kobj);
     830                 :      38502 :         INIT_LIST_HEAD(&k->list);
     831                 :      38502 :         spin_lock_init(&k->list_lock);
     832                 :      10557 : }
     833                 :            : 
     834                 :            : /* default kobject attribute operations */
     835                 :          0 : static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,
     836                 :            :                               char *buf)
     837                 :            : {
     838                 :            :         struct kobj_attribute *kattr;
     839                 :            :         ssize_t ret = -EIO;
     840                 :            : 
     841                 :            :         kattr = container_of(attr, struct kobj_attribute, attr);
     842         [ #  # ]:          0 :         if (kattr->show)
     843                 :          0 :                 ret = kattr->show(kobj, kattr, buf);
     844                 :          0 :         return ret;
     845                 :            : }
     846                 :            : 
     847                 :          0 : static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,
     848                 :            :                                const char *buf, size_t count)
     849                 :            : {
     850                 :            :         struct kobj_attribute *kattr;
     851                 :            :         ssize_t ret = -EIO;
     852                 :            : 
     853                 :            :         kattr = container_of(attr, struct kobj_attribute, attr);
     854         [ #  # ]:          0 :         if (kattr->store)
     855                 :          0 :                 ret = kattr->store(kobj, kattr, buf, count);
     856                 :          0 :         return ret;
     857                 :            : }
     858                 :            : 
     859                 :            : const struct sysfs_ops kobj_sysfs_ops = {
     860                 :            :         .show   = kobj_attr_show,
     861                 :            :         .store  = kobj_attr_store,
     862                 :            : };
     863                 :            : EXPORT_SYMBOL_GPL(kobj_sysfs_ops);
     864                 :            : 
     865                 :            : /**
     866                 :            :  * kset_register() - Initialize and add a kset.
     867                 :            :  * @k: kset.
     868                 :            :  */
     869                 :      27945 : int kset_register(struct kset *k)
     870                 :            : {
     871                 :            :         int err;
     872                 :            : 
     873         [ +  - ]:      27945 :         if (!k)
     874                 :            :                 return -EINVAL;
     875                 :            : 
     876                 :            :         kset_init(k);
     877                 :      27945 :         err = kobject_add_internal(&k->kobj);
     878         [ +  - ]:      27945 :         if (err)
     879                 :            :                 return err;
     880                 :      27945 :         kobject_uevent(&k->kobj, KOBJ_ADD);
     881                 :      27945 :         return 0;
     882                 :            : }
     883                 :            : EXPORT_SYMBOL(kset_register);
     884                 :            : 
     885                 :            : /**
     886                 :            :  * kset_unregister() - Remove a kset.
     887                 :            :  * @k: kset.
     888                 :            :  */
     889                 :          0 : void kset_unregister(struct kset *k)
     890                 :            : {
     891         [ #  # ]:          0 :         if (!k)
     892                 :          0 :                 return;
     893                 :          0 :         kobject_del(&k->kobj);
     894                 :          0 :         kobject_put(&k->kobj);
     895                 :            : }
     896                 :            : EXPORT_SYMBOL(kset_unregister);
     897                 :            : 
     898                 :            : /**
     899                 :            :  * kset_find_obj() - Search for object in kset.
     900                 :            :  * @kset: kset we're looking in.
     901                 :            :  * @name: object's name.
     902                 :            :  *
     903                 :            :  * Lock kset via @kset->subsys, and iterate over @kset->list,
     904                 :            :  * looking for a matching kobject. If matching object is found
     905                 :            :  * take a reference and return the object.
     906                 :            :  */
     907                 :      81765 : struct kobject *kset_find_obj(struct kset *kset, const char *name)
     908                 :            : {
     909                 :            :         struct kobject *k;
     910                 :            :         struct kobject *ret = NULL;
     911                 :            : 
     912                 :            :         spin_lock(&kset->list_lock);
     913                 :            : 
     914         [ +  + ]:    2757177 :         list_for_each_entry(k, &kset->list, entry) {
     915   [ +  -  +  + ]:    2723229 :                 if (kobject_name(k) && !strcmp(kobject_name(k), name)) {
     916                 :            :                         ret = kobject_get_unless_zero(k);
     917                 :      47817 :                         break;
     918                 :            :                 }
     919                 :            :         }
     920                 :            : 
     921                 :            :         spin_unlock(&kset->list_lock);
     922                 :      81765 :         return ret;
     923                 :            : }
     924                 :            : EXPORT_SYMBOL_GPL(kset_find_obj);
     925                 :            : 
     926                 :          0 : static void kset_release(struct kobject *kobj)
     927                 :            : {
     928                 :          0 :         struct kset *kset = container_of(kobj, struct kset, kobj);
     929                 :            :         pr_debug("kobject: '%s' (%p): %s\n",
     930                 :            :                  kobject_name(kobj), kobj, __func__);
     931                 :          0 :         kfree(kset);
     932                 :          0 : }
     933                 :            : 
     934                 :      12420 : static void kset_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid)
     935                 :            : {
     936         [ +  + ]:      12420 :         if (kobj->parent)
     937                 :            :                 kobject_get_ownership(kobj->parent, uid, gid);
     938                 :      12420 : }
     939                 :            : 
     940                 :            : static struct kobj_type kset_ktype = {
     941                 :            :         .sysfs_ops      = &kobj_sysfs_ops,
     942                 :            :         .release        = kset_release,
     943                 :            :         .get_ownership  = kset_get_ownership,
     944                 :            : };
     945                 :            : 
     946                 :            : /**
     947                 :            :  * kset_create() - Create a struct kset dynamically.
     948                 :            :  *
     949                 :            :  * @name: the name for the kset
     950                 :            :  * @uevent_ops: a struct kset_uevent_ops for the kset
     951                 :            :  * @parent_kobj: the parent kobject of this kset, if any.
     952                 :            :  *
     953                 :            :  * This function creates a kset structure dynamically.  This structure can
     954                 :            :  * then be registered with the system and show up in sysfs with a call to
     955                 :            :  * kset_register().  When you are finished with this structure, if
     956                 :            :  * kset_register() has been called, call kset_unregister() and the
     957                 :            :  * structure will be dynamically freed when it is no longer being used.
     958                 :            :  *
     959                 :            :  * If the kset was not able to be created, NULL will be returned.
     960                 :            :  */
     961                 :      12213 : static struct kset *kset_create(const char *name,
     962                 :            :                                 const struct kset_uevent_ops *uevent_ops,
     963                 :            :                                 struct kobject *parent_kobj)
     964                 :            : {
     965                 :            :         struct kset *kset;
     966                 :            :         int retval;
     967                 :            : 
     968                 :      12213 :         kset = kzalloc(sizeof(*kset), GFP_KERNEL);
     969         [ +  - ]:      12213 :         if (!kset)
     970                 :            :                 return NULL;
     971                 :      12213 :         retval = kobject_set_name(&kset->kobj, "%s", name);
     972         [ -  + ]:      12213 :         if (retval) {
     973                 :          0 :                 kfree(kset);
     974                 :          0 :                 return NULL;
     975                 :            :         }
     976                 :      12213 :         kset->uevent_ops = uevent_ops;
     977                 :      12213 :         kset->kobj.parent = parent_kobj;
     978                 :            : 
     979                 :            :         /*
     980                 :            :          * The kobject of this kset will have a type of kset_ktype and belong to
     981                 :            :          * no kset itself.  That way we can properly free it when it is
     982                 :            :          * finished being used.
     983                 :            :          */
     984                 :      12213 :         kset->kobj.ktype = &kset_ktype;
     985                 :      12213 :         kset->kobj.kset = NULL;
     986                 :            : 
     987                 :      12213 :         return kset;
     988                 :            : }
     989                 :            : 
     990                 :            : /**
     991                 :            :  * kset_create_and_add() - Create a struct kset dynamically and add it to sysfs.
     992                 :            :  *
     993                 :            :  * @name: the name for the kset
     994                 :            :  * @uevent_ops: a struct kset_uevent_ops for the kset
     995                 :            :  * @parent_kobj: the parent kobject of this kset, if any.
     996                 :            :  *
     997                 :            :  * This function creates a kset structure dynamically and registers it
     998                 :            :  * with sysfs.  When you are finished with this structure, call
     999                 :            :  * kset_unregister() and the structure will be dynamically freed when it
    1000                 :            :  * is no longer being used.
    1001                 :            :  *
    1002                 :            :  * If the kset was not able to be created, NULL will be returned.
    1003                 :            :  */
    1004                 :      12213 : struct kset *kset_create_and_add(const char *name,
    1005                 :            :                                  const struct kset_uevent_ops *uevent_ops,
    1006                 :            :                                  struct kobject *parent_kobj)
    1007                 :            : {
    1008                 :            :         struct kset *kset;
    1009                 :            :         int error;
    1010                 :            : 
    1011                 :      12213 :         kset = kset_create(name, uevent_ops, parent_kobj);
    1012         [ +  - ]:      12213 :         if (!kset)
    1013                 :            :                 return NULL;
    1014                 :      12213 :         error = kset_register(kset);
    1015         [ -  + ]:      12213 :         if (error) {
    1016                 :          0 :                 kfree(kset);
    1017                 :          0 :                 return NULL;
    1018                 :            :         }
    1019                 :            :         return kset;
    1020                 :            : }
    1021                 :            : EXPORT_SYMBOL_GPL(kset_create_and_add);
    1022                 :            : 
    1023                 :            : 
    1024                 :            : static DEFINE_SPINLOCK(kobj_ns_type_lock);
    1025                 :            : static const struct kobj_ns_type_operations *kobj_ns_ops_tbl[KOBJ_NS_TYPES];
    1026                 :            : 
    1027                 :        207 : int kobj_ns_type_register(const struct kobj_ns_type_operations *ops)
    1028                 :            : {
    1029                 :        207 :         enum kobj_ns_type type = ops->type;
    1030                 :            :         int error;
    1031                 :            : 
    1032                 :            :         spin_lock(&kobj_ns_type_lock);
    1033                 :            : 
    1034                 :            :         error = -EINVAL;
    1035         [ +  - ]:        207 :         if (type >= KOBJ_NS_TYPES)
    1036                 :            :                 goto out;
    1037                 :            : 
    1038                 :            :         error = -EINVAL;
    1039         [ +  - ]:        207 :         if (type <= KOBJ_NS_TYPE_NONE)
    1040                 :            :                 goto out;
    1041                 :            : 
    1042                 :            :         error = -EBUSY;
    1043         [ +  - ]:        207 :         if (kobj_ns_ops_tbl[type])
    1044                 :            :                 goto out;
    1045                 :            : 
    1046                 :            :         error = 0;
    1047                 :        207 :         kobj_ns_ops_tbl[type] = ops;
    1048                 :            : 
    1049                 :            : out:
    1050                 :            :         spin_unlock(&kobj_ns_type_lock);
    1051                 :        207 :         return error;
    1052                 :            : }
    1053                 :            : 
    1054                 :       1035 : int kobj_ns_type_registered(enum kobj_ns_type type)
    1055                 :            : {
    1056                 :            :         int registered = 0;
    1057                 :            : 
    1058                 :            :         spin_lock(&kobj_ns_type_lock);
    1059         [ +  - ]:       1035 :         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES))
    1060                 :       1035 :                 registered = kobj_ns_ops_tbl[type] != NULL;
    1061                 :            :         spin_unlock(&kobj_ns_type_lock);
    1062                 :            : 
    1063                 :       1035 :         return registered;
    1064                 :            : }
    1065                 :            : 
    1066                 :          0 : const struct kobj_ns_type_operations *kobj_child_ns_ops(struct kobject *parent)
    1067                 :            : {
    1068                 :            :         const struct kobj_ns_type_operations *ops = NULL;
    1069                 :            : 
    1070   [ +  +  +  -  :     888972 :         if (parent && parent->ktype && parent->ktype->child_ns_type)
          +  +  #  #  #  
          #  #  #  +  -  
          +  +  +  +  +  
             +  +  +  +  
                      + ]
    1071                 :     151110 :                 ops = parent->ktype->child_ns_type(parent);
    1072                 :            : 
    1073                 :          0 :         return ops;
    1074                 :            : }
    1075                 :            : 
    1076                 :     333387 : const struct kobj_ns_type_operations *kobj_ns_ops(struct kobject *kobj)
    1077                 :            : {
    1078                 :     944565 :         return kobj_child_ns_ops(kobj->parent);
    1079                 :            : }
    1080                 :            : 
    1081                 :        414 : bool kobj_ns_current_may_mount(enum kobj_ns_type type)
    1082                 :            : {
    1083                 :            :         bool may_mount = true;
    1084                 :            : 
    1085                 :            :         spin_lock(&kobj_ns_type_lock);
    1086   [ +  -  +  - ]:        828 :         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
    1087                 :        414 :             kobj_ns_ops_tbl[type])
    1088                 :        414 :                 may_mount = kobj_ns_ops_tbl[type]->current_may_mount();
    1089                 :            :         spin_unlock(&kobj_ns_type_lock);
    1090                 :            : 
    1091                 :        414 :         return may_mount;
    1092                 :            : }
    1093                 :            : 
    1094                 :        414 : void *kobj_ns_grab_current(enum kobj_ns_type type)
    1095                 :            : {
    1096                 :            :         void *ns = NULL;
    1097                 :            : 
    1098                 :            :         spin_lock(&kobj_ns_type_lock);
    1099   [ +  -  +  - ]:        828 :         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
    1100                 :        414 :             kobj_ns_ops_tbl[type])
    1101                 :        414 :                 ns = kobj_ns_ops_tbl[type]->grab_current_ns();
    1102                 :            :         spin_unlock(&kobj_ns_type_lock);
    1103                 :            : 
    1104                 :        414 :         return ns;
    1105                 :            : }
    1106                 :            : EXPORT_SYMBOL_GPL(kobj_ns_grab_current);
    1107                 :            : 
    1108                 :          0 : const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk)
    1109                 :            : {
    1110                 :            :         const void *ns = NULL;
    1111                 :            : 
    1112                 :            :         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]->netlink_ns(sk);
    1116                 :            :         spin_unlock(&kobj_ns_type_lock);
    1117                 :            : 
    1118                 :          0 :         return ns;
    1119                 :            : }
    1120                 :            : 
    1121                 :          0 : const void *kobj_ns_initial(enum kobj_ns_type type)
    1122                 :            : {
    1123                 :            :         const void *ns = NULL;
    1124                 :            : 
    1125                 :            :         spin_lock(&kobj_ns_type_lock);
    1126   [ #  #  #  # ]:          0 :         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
    1127                 :          0 :             kobj_ns_ops_tbl[type])
    1128                 :          0 :                 ns = kobj_ns_ops_tbl[type]->initial_ns();
    1129                 :            :         spin_unlock(&kobj_ns_type_lock);
    1130                 :            : 
    1131                 :          0 :         return ns;
    1132                 :            : }
    1133                 :            : 
    1134                 :        207 : void kobj_ns_drop(enum kobj_ns_type type, void *ns)
    1135                 :            : {
    1136                 :            :         spin_lock(&kobj_ns_type_lock);
    1137   [ +  -  +  - ]:        414 :         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
    1138         [ +  - ]:        414 :             kobj_ns_ops_tbl[type] && kobj_ns_ops_tbl[type]->drop_ns)
    1139                 :        207 :                 kobj_ns_ops_tbl[type]->drop_ns(ns);
    1140                 :            :         spin_unlock(&kobj_ns_type_lock);
    1141                 :        207 : }
    1142                 :            : EXPORT_SYMBOL_GPL(kobj_ns_drop);

Generated by: LCOV version 1.14