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_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         if (!kobj)
 616                 return;
 617
 618         sd = kobj->sd;
 619         ktype = get_ktype(kobj);
 620
 621         if (ktype)
 622                 sysfs_remove_groups(kobj, ktype->default_groups);
 623
 624         sysfs_remove_dir(kobj);
 625         sysfs_put(sd);
 626
 627         kobj->state_in_sysfs = 0;
 628         kobj_kset_leave(kobj);
 629         kobj->parent = NULL;
 630 }
 631
 632 /**
 633  * kobject_del() - Unlink kobject from hierarchy.
 634  * @kobj: object.
 635  *
 636  * This is the function that should be called to delete an object
 637  * successfully added via kobject_add().
 638  */
 639 void kobject_del(struct kobject *kobj)
 640 {
 641         struct kobject *parent;
 642
 643         if (!kobj)
 644                 return;
 645
 646         parent = kobj->parent;
 647         __kobject_del(kobj);
 648         kobject_put(parent);
 649 }
 650 EXPORT_SYMBOL(kobject_del);
 651
 652 /**
 653  * kobject_get() - Increment refcount for object.
 654  * @kobj: object.
 655  */
 656 struct kobject *kobject_get(struct kobject *kobj)
 657 {
 658         if (kobj) {
 659                 if (!kobj->state_initialized)
 660                         WARN(1, KERN_WARNING
 661                                 "kobject: '%s' (%p): is not initialized, yet kobject_get() is being called.\n",
 662                              kobject_name(kobj), kobj);
 663                 kref_get(&kobj->kref);
 664         }
 665         return kobj;
 666 }
 667 EXPORT_SYMBOL(kobject_get);
 668
 669 struct kobject * __must_check kobject_get_unless_zero(struct kobject *kobj)
 670 {
 671         if (!kobj)
 672                 return NULL;
 673         if (!kref_get_unless_zero(&kobj->kref))
 674                 kobj = NULL;
 675         return kobj;
 676 }
 677 EXPORT_SYMBOL(kobject_get_unless_zero);
 678
 679 /*
 680  * kobject_cleanup - free kobject resources.
 681  * @kobj: object to cleanup
 682  */
 683 static void kobject_cleanup(struct kobject *kobj)
 684 {
 685         struct kobject *parent = kobj->parent;
 686         struct kobj_type *t = get_ktype(kobj);
 687         const char *name = kobj->name;
 688
 689         pr_debug("kobject: '%s' (%p): %s, parent %p\n",
 690                  kobject_name(kobj), kobj, __func__, kobj->parent);
 691
 692         if (t && !t->release)
 693                 pr_debug("kobject: '%s' (%p): does not have a release() function, it is broken and must be fixed. See Documentation/kobject.txt.\n",
 694                          kobject_name(kobj), kobj);
 695
 696         /* send "remove" if the caller did not do it but sent "add" */
 697         if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) {
 698                 pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n",
 699                          kobject_name(kobj), kobj);
 700                 kobject_uevent(kobj, KOBJ_REMOVE);
 701         }
 702
 703         /* remove from sysfs if the caller did not do it */
 704         if (kobj->state_in_sysfs) {
 705                 pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n",
 706                          kobject_name(kobj), kobj);
 707                 __kobject_del(kobj);
 708         } else {
 709                 /* avoid dropping the parent reference unnecessarily */
 710                 parent = NULL;
 711         }
 712
 713         if (t && t->release) {
 714                 pr_debug("kobject: '%s' (%p): calling ktype release\n",
 715                          kobject_name(kobj), kobj);
 716                 t->release(kobj);
 717         }
 718
 719         /* free name if we allocated it */
 720         if (name) {
 721                 pr_debug("kobject: '%s': free name\n", name);
 722                 kfree_const(name);
 723         }
 724
 725         kobject_put(parent);
 726 }
 727
 728 #ifdef CONFIG_DEBUG_KOBJECT_RELEASE
 729 static void kobject_delayed_cleanup(struct work_struct *work)
 730 {
 731         kobject_cleanup(container_of(to_delayed_work(work),
 732                                      struct kobject, release));
 733 }
 734 #endif
 735
 736 static void kobject_release(struct kref *kref)
 737 {
 738         struct kobject *kobj = container_of(kref, struct kobject, kref);
 739 #ifdef CONFIG_DEBUG_KOBJECT_RELEASE
 740         unsigned long delay = HZ + HZ * (get_random_int() & 0x3);
 741         pr_info("kobject: '%s' (%p): %s, parent %p (delayed %ld)\n",
 742                  kobject_name(kobj), kobj, __func__, kobj->parent, delay);
 743         INIT_DELAYED_WORK(&kobj->release, kobject_delayed_cleanup);
 744
 745         schedule_delayed_work(&kobj->release, delay);
 746 #else
 747         kobject_cleanup(kobj);
 748 #endif
 749 }
 750
 751 /**
 752  * kobject_put() - Decrement refcount for object.
 753  * @kobj: object.
 754  *
 755  * Decrement the refcount, and if 0, call kobject_cleanup().
 756  */
 757 void kobject_put(struct kobject *kobj)
 758 {
 759         if (kobj) {
 760                 if (!kobj->state_initialized)
 761                         WARN(1, KERN_WARNING
 762                                 "kobject: '%s' (%p): is not initialized, yet kobject_put() is being called.\n",
 763                              kobject_name(kobj), kobj);
 764                 kref_put(&kobj->kref, kobject_release);
 765         }
 766 }
 767 EXPORT_SYMBOL(kobject_put);
 768
 769 static void dynamic_kobj_release(struct kobject *kobj)
 770 {
 771         pr_debug("kobject: (%p): %s\n", kobj, __func__);
 772         kfree(kobj);
 773 }
 774
 775 static struct kobj_type dynamic_kobj_ktype = {
 776         .release        = dynamic_kobj_release,
 777         .sysfs_ops      = &kobj_sysfs_ops,
 778 };
 779
 780 /**
 781  * kobject_create() - Create a struct kobject dynamically.
 782  *
 783  * This function creates a kobject structure dynamically and sets it up
 784  * to be a "dynamic" kobject with a default release function set up.
 785  *
 786  * If the kobject was not able to be created, NULL will be returned.
 787  * The kobject structure returned from here must be cleaned up with a
 788  * call to kobject_put() and not kfree(), as kobject_init() has
 789  * already been called on this structure.
 790  */
 791 struct kobject *kobject_create(void)
 792 {
 793         struct kobject *kobj;
 794
 795         kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
 796         if (!kobj)
 797                 return NULL;
 798
 799         kobject_init(kobj, &dynamic_kobj_ktype);
 800         return kobj;
 801 }
 802
 803 /**
 804  * kobject_create_and_add() - Create a struct kobject dynamically and
 805  *                            register it with sysfs.
 806  * @name: the name for the kobject
 807  * @parent: the parent kobject of this kobject, if any.
 808  *
 809  * This function creates a kobject structure dynamically and registers it
 810  * with sysfs.  When you are finished with this structure, call
 811  * kobject_put() and the structure will be dynamically freed when
 812  * it is no longer being used.
 813  *
 814  * If the kobject was not able to be created, NULL will be returned.
 815  */
 816 struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)
 817 {
 818         struct kobject *kobj;
 819         int retval;
 820
 821         kobj = kobject_create();
 822         if (!kobj)
 823                 return NULL;
 824
 825         retval = kobject_add(kobj, parent, "%s", name);
 826         if (retval) {
 827                 pr_warn("%s: kobject_add error: %d\n", __func__, retval);
 828                 kobject_put(kobj);
 829                 kobj = NULL;
 830         }
 831         return kobj;
 832 }
 833 EXPORT_SYMBOL_GPL(kobject_create_and_add);
 834
 835 /**
 836  * kset_init() - Initialize a kset for use.
 837  * @k: kset
 838  */
 839 void kset_init(struct kset *k)
 840 {
 841         kobject_init_internal(&k->kobj);
 842         INIT_LIST_HEAD(&k->list);
 843         spin_lock_init(&k->list_lock);
 844 }
 845
 846 /* default kobject attribute operations */
 847 static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,
 848                               char *buf)
 849 {
 850         struct kobj_attribute *kattr;
 851         ssize_t ret = -EIO;
 852
 853         kattr = container_of(attr, struct kobj_attribute, attr);
 854         if (kattr->show)
 855                 ret = kattr->show(kobj, kattr, buf);
 856         return ret;
 857 }
 858
 859 static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,
 860                                const char *buf, size_t count)
 861 {
 862         struct kobj_attribute *kattr;
 863         ssize_t ret = -EIO;
 864
 865         kattr = container_of(attr, struct kobj_attribute, attr);
 866         if (kattr->store)
 867                 ret = kattr->store(kobj, kattr, buf, count);
 868         return ret;
 869 }
 870
 871 const struct sysfs_ops kobj_sysfs_ops = {
 872         .show   = kobj_attr_show,
 873         .store  = kobj_attr_store,
 874 };
 875 EXPORT_SYMBOL_GPL(kobj_sysfs_ops);
 876
 877 /**
 878  * kset_register() - Initialize and add a kset.
 879  * @k: kset.
 880  */
 881 int kset_register(struct kset *k)
 882 {
 883         int err;
 884
 885         if (!k)
 886                 return -EINVAL;
 887
 888         if (!k->kobj.ktype) {
 889                 pr_err("must have a ktype to be initialized properly!\n");
 890                 return -EINVAL;
 891         }
 892
 893         kset_init(k);
 894         err = kobject_add_internal(&k->kobj);
 895         if (err)
 896                 return err;
 897         kobject_uevent(&k->kobj, KOBJ_ADD);
 898         return 0;
 899 }
 900 EXPORT_SYMBOL(kset_register);
 901
 902 /**
 903  * kset_unregister() - Remove a kset.
 904  * @k: kset.
 905  */
 906 void kset_unregister(struct kset *k)
 907 {
 908         if (!k)
 909                 return;
 910         kobject_del(&k->kobj);
 911         kobject_put(&k->kobj);
 912 }
 913 EXPORT_SYMBOL(kset_unregister);
 914
 915 /**
 916  * kset_find_obj() - Search for object in kset.
 917  * @kset: kset we're looking in.
 918  * @name: object's name.
 919  *
 920  * Lock kset via @kset->subsys, and iterate over @kset->list,
 921  * looking for a matching kobject. If matching object is found
 922  * take a reference and return the object.
 923  */
 924 struct kobject *kset_find_obj(struct kset *kset, const char *name)
 925 {
 926         struct kobject *k;
 927         struct kobject *ret = NULL;
 928
 929         spin_lock(&kset->list_lock);
 930
 931         list_for_each_entry(k, &kset->list, entry) {
 932                 if (kobject_name(k) && !strcmp(kobject_name(k), name)) {
 933                         ret = kobject_get_unless_zero(k);
 934                         break;
 935                 }
 936         }
 937
 938         spin_unlock(&kset->list_lock);
 939         return ret;
 940 }
 941 EXPORT_SYMBOL_GPL(kset_find_obj);
 942
 943 static void kset_release(struct kobject *kobj)
 944 {
 945         struct kset *kset = container_of(kobj, struct kset, kobj);
 946         pr_debug("kobject: '%s' (%p): %s\n",
 947                  kobject_name(kobj), kobj, __func__);
 948         kfree(kset);
 949 }
 950
 951 static void kset_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid)
 952 {
 953         if (kobj->parent)
 954                 kobject_get_ownership(kobj->parent, uid, gid);
 955 }
 956
 957 static struct kobj_type kset_ktype = {
 958         .sysfs_ops      = &kobj_sysfs_ops,
 959         .release        = kset_release,
 960         .get_ownership  = kset_get_ownership,
 961 };
 962
 963 /**
 964  * kset_create() - Create a struct kset dynamically.
 965  *
 966  * @name: the name for the kset
 967  * @uevent_ops: a struct kset_uevent_ops for the kset
 968  * @parent_kobj: the parent kobject of this kset, if any.
 969  *
 970  * This function creates a kset structure dynamically.  This structure can
 971  * then be registered with the system and show up in sysfs with a call to
 972  * kset_register().  When you are finished with this structure, if
 973  * kset_register() has been called, call kset_unregister() and the
 974  * structure will be dynamically freed when it is no longer being used.
 975  *
 976  * If the kset was not able to be created, NULL will be returned.
 977  */
 978 static struct kset *kset_create(const char *name,
 979                                 const struct kset_uevent_ops *uevent_ops,
 980                                 struct kobject *parent_kobj)
 981 {
 982         struct kset *kset;
 983         int retval;
 984
 985         kset = kzalloc(sizeof(*kset), GFP_KERNEL);
 986         if (!kset)
 987                 return NULL;
 988         retval = kobject_set_name(&kset->kobj, "%s", name);
 989         if (retval) {
 990                 kfree(kset);
 991                 return NULL;
 992         }
 993         kset->uevent_ops = uevent_ops;
 994         kset->kobj.parent = parent_kobj;
 995
 996         /*
 997          * The kobject of this kset will have a type of kset_ktype and belong to
 998          * no kset itself.  That way we can properly free it when it is
 999          * finished being used.
1000          */
1001         kset->kobj.ktype = &kset_ktype;
1002         kset->kobj.kset = NULL;
1003
1004         return kset;
1005 }
1006
1007 /**
1008  * kset_create_and_add() - Create a struct kset dynamically and add it to sysfs.
1009  *
1010  * @name: the name for the kset
1011  * @uevent_ops: a struct kset_uevent_ops for the kset
1012  * @parent_kobj: the parent kobject of this kset, if any.
1013  *
1014  * This function creates a kset structure dynamically and registers it
1015  * with sysfs.  When you are finished with this structure, call
1016  * kset_unregister() and the structure will be dynamically freed when it
1017  * is no longer being used.
1018  *
1019  * If the kset was not able to be created, NULL will be returned.
1020  */
1021 struct kset *kset_create_and_add(const char *name,
1022                                  const struct kset_uevent_ops *uevent_ops,
1023                                  struct kobject *parent_kobj)
1024 {
1025         struct kset *kset;
1026         int error;
1027
1028         kset = kset_create(name, uevent_ops, parent_kobj);
1029         if (!kset)
1030                 return NULL;
1031         error = kset_register(kset);
1032         if (error) {
1033                 kfree(kset);
1034                 return NULL;
1035         }
1036         return kset;
1037 }
1038 EXPORT_SYMBOL_GPL(kset_create_and_add);
1039
1040
1041 static DEFINE_SPINLOCK(kobj_ns_type_lock);
1042 static const struct kobj_ns_type_operations *kobj_ns_ops_tbl[KOBJ_NS_TYPES];
1043
1044 int kobj_ns_type_register(const struct kobj_ns_type_operations *ops)
1045 {
1046         enum kobj_ns_type type = ops->type;
1047         int error;
1048
1049         spin_lock(&kobj_ns_type_lock);
1050
1051         error = -EINVAL;
1052         if (type >= KOBJ_NS_TYPES)
1053                 goto out;
1054
1055         error = -EINVAL;
1056         if (type <= KOBJ_NS_TYPE_NONE)
1057                 goto out;
1058
1059         error = -EBUSY;
1060         if (kobj_ns_ops_tbl[type])
1061                 goto out;
1062
1063         error = 0;
1064         kobj_ns_ops_tbl[type] = ops;
1065
1066 out:
1067         spin_unlock(&kobj_ns_type_lock);
1068         return error;
1069 }
1070
1071 int kobj_ns_type_registered(enum kobj_ns_type type)
1072 {
1073         int registered = 0;
1074
1075         spin_lock(&kobj_ns_type_lock);
1076         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES))
1077                 registered = kobj_ns_ops_tbl[type] != NULL;
1078         spin_unlock(&kobj_ns_type_lock);
1079
1080         return registered;
1081 }
1082
1083 const struct kobj_ns_type_operations *kobj_child_ns_ops(struct kobject *parent)
1084 {
1085         const struct kobj_ns_type_operations *ops = NULL;
1086
1087         if (parent && parent->ktype && parent->ktype->child_ns_type)
1088                 ops = parent->ktype->child_ns_type(parent);
1089
1090         return ops;
1091 }
1092
1093 const struct kobj_ns_type_operations *kobj_ns_ops(struct kobject *kobj)
1094 {
1095         return kobj_child_ns_ops(kobj->parent);
1096 }
1097
1098 bool kobj_ns_current_may_mount(enum kobj_ns_type type)
1099 {
1100         bool may_mount = true;
1101
1102         spin_lock(&kobj_ns_type_lock);
1103         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1104             kobj_ns_ops_tbl[type])
1105                 may_mount = kobj_ns_ops_tbl[type]->current_may_mount();
1106         spin_unlock(&kobj_ns_type_lock);
1107
1108         return may_mount;
1109 }
1110
1111 void *kobj_ns_grab_current(enum kobj_ns_type type)
1112 {
1113         void *ns = NULL;
1114
1115         spin_lock(&kobj_ns_type_lock);
1116         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1117             kobj_ns_ops_tbl[type])
1118                 ns = kobj_ns_ops_tbl[type]->grab_current_ns();
1119         spin_unlock(&kobj_ns_type_lock);
1120
1121         return ns;
1122 }
1123 EXPORT_SYMBOL_GPL(kobj_ns_grab_current);
1124
1125 const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk)
1126 {
1127         const void *ns = NULL;
1128
1129         spin_lock(&kobj_ns_type_lock);
1130         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1131             kobj_ns_ops_tbl[type])
1132                 ns = kobj_ns_ops_tbl[type]->netlink_ns(sk);
1133         spin_unlock(&kobj_ns_type_lock);
1134
1135         return ns;
1136 }
1137
1138 const void *kobj_ns_initial(enum kobj_ns_type type)
1139 {
1140         const void *ns = NULL;
1141
1142         spin_lock(&kobj_ns_type_lock);
1143         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1144             kobj_ns_ops_tbl[type])
1145                 ns = kobj_ns_ops_tbl[type]->initial_ns();
1146         spin_unlock(&kobj_ns_type_lock);
1147
1148         return ns;
1149 }
1150
1151 void kobj_ns_drop(enum kobj_ns_type type, void *ns)
1152 {
1153         spin_lock(&kobj_ns_type_lock);
1154         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1155             kobj_ns_ops_tbl[type] && kobj_ns_ops_tbl[type]->drop_ns)
1156                 kobj_ns_ops_tbl[type]->drop_ns(ns);
1157         spin_unlock(&kobj_ns_type_lock);
1158 }
1159 EXPORT_SYMBOL_GPL(kobj_ns_drop);