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