lib/kobject.c

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