lib/kobject.c

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