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