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                 kobj->name = old_name;
 270                 return -ENOMEM;
 271         }
 272
 273         /* ewww... some of these buggers have '/' in the name ... */
 274         while ((s = strchr(kobj->name, '/')))
 275                 s[0] = '!';
 276
 277         kfree(old_name);
 278         return 0;
 279 }
 280
 281 /**
 282  * kobject_set_name - Set the name of a kobject
 283  * @kobj: struct kobject to set the name of
 284  * @fmt: format string used to build the name
 285  *
 286  * This sets the name of the kobject.  If you have already added the
 287  * kobject to the system, you must call kobject_rename() in order to
 288  * change the name of the kobject.
 289  */
 290 int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
 291 {
 292         va_list vargs;
 293         int retval;
 294
 295         va_start(vargs, fmt);
 296         retval = kobject_set_name_vargs(kobj, fmt, vargs);
 297         va_end(vargs);
 298
 299         return retval;
 300 }
 301 EXPORT_SYMBOL(kobject_set_name);
 302
 303 /**
 304  * kobject_init - initialize a kobject structure
 305  * @kobj: pointer to the kobject to initialize
 306  * @ktype: pointer to the ktype for this kobject.
 307  *
 308  * This function will properly initialize a kobject such that it can then
 309  * be passed to the kobject_add() call.
 310  *
 311  * After this function is called, the kobject MUST be cleaned up by a call
 312  * to kobject_put(), not by a call to kfree directly to ensure that all of
 313  * the memory is cleaned up properly.
 314  */
 315 void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
 316 {
 317         char *err_str;
 318
 319         if (!kobj) {
 320                 err_str = "invalid kobject pointer!";
 321                 goto error;
 322         }
 323         if (!ktype) {
 324                 err_str = "must have a ktype to be initialized properly!\n";
 325                 goto error;
 326         }
 327         if (kobj->state_initialized) {
 328                 /* do not error out as sometimes we can recover */
 329                 printk(KERN_ERR "kobject (%p): tried to init an initialized "
 330                        "object, something is seriously wrong.\n", kobj);
 331                 dump_stack();
 332         }
 333
 334         kobject_init_internal(kobj);
 335         kobj->ktype = ktype;
 336         return;
 337
 338 error:
 339         printk(KERN_ERR "kobject (%p): %s\n", kobj, err_str);
 340         dump_stack();
 341 }
 342 EXPORT_SYMBOL(kobject_init);
 343
 344 static int kobject_add_varg(struct kobject *kobj, struct kobject *parent,
 345                             const char *fmt, va_list vargs)
 346 {
 347         int retval;
 348
 349         retval = kobject_set_name_vargs(kobj, fmt, vargs);
 350         if (retval) {
 351                 printk(KERN_ERR "kobject: can not set name properly!\n");
 352                 return retval;
 353         }
 354         kobj->parent = parent;
 355         return kobject_add_internal(kobj);
 356 }
 357
 358 /**
 359  * kobject_add - the main kobject add function
 360  * @kobj: the kobject to add
 361  * @parent: pointer to the parent of the kobject.
 362  * @fmt: format to name the kobject with.
 363  *
 364  * The kobject name is set and added to the kobject hierarchy in this
 365  * function.
 366  *
 367  * If @parent is set, then the parent of the @kobj will be set to it.
 368  * If @parent is NULL, then the parent of the @kobj will be set to the
 369  * kobject associted with the kset assigned to this kobject.  If no kset
 370  * is assigned to the kobject, then the kobject will be located in the
 371  * root of the sysfs tree.
 372  *
 373  * If this function returns an error, kobject_put() must be called to
 374  * properly clean up the memory associated with the object.
 375  * Under no instance should the kobject that is passed to this function
 376  * be directly freed with a call to kfree(), that can leak memory.
 377  *
 378  * Note, no "add" uevent will be created with this call, the caller should set
 379  * up all of the necessary sysfs files for the object and then call
 380  * kobject_uevent() with the UEVENT_ADD parameter to ensure that
 381  * userspace is properly notified of this kobject's creation.
 382  */
 383 int kobject_add(struct kobject *kobj, struct kobject *parent,
 384                 const char *fmt, ...)
 385 {
 386         va_list args;
 387         int retval;
 388
 389         if (!kobj)
 390                 return -EINVAL;
 391
 392         if (!kobj->state_initialized) {
 393                 printk(KERN_ERR "kobject '%s' (%p): tried to add an "
 394                        "uninitialized object, something is seriously wrong.\n",
 395                        kobject_name(kobj), kobj);
 396                 dump_stack();
 397                 return -EINVAL;
 398         }
 399         va_start(args, fmt);
 400         retval = kobject_add_varg(kobj, parent, fmt, args);
 401         va_end(args);
 402
 403         return retval;
 404 }
 405 EXPORT_SYMBOL(kobject_add);
 406
 407 /**
 408  * kobject_init_and_add - initialize a kobject structure and add it to the kobject hierarchy
 409  * @kobj: pointer to the kobject to initialize
 410  * @ktype: pointer to the ktype for this kobject.
 411  * @parent: pointer to the parent of this kobject.
 412  * @fmt: the name of the kobject.
 413  *
 414  * This function combines the call to kobject_init() and
 415  * kobject_add().  The same type of error handling after a call to
 416  * kobject_add() and kobject lifetime rules are the same here.
 417  */
 418 int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype,
 419                          struct kobject *parent, const char *fmt, ...)
 420 {
 421         va_list args;
 422         int retval;
 423
 424         kobject_init(kobj, ktype);
 425
 426         va_start(args, fmt);
 427         retval = kobject_add_varg(kobj, parent, fmt, args);
 428         va_end(args);
 429
 430         return retval;
 431 }
 432 EXPORT_SYMBOL_GPL(kobject_init_and_add);
 433
 434 /**
 435  * kobject_rename - change the name of an object
 436  * @kobj: object in question.
 437  * @new_name: object's new name
 438  *
 439  * It is the responsibility of the caller to provide mutual
 440  * exclusion between two different calls of kobject_rename
 441  * on the same kobject and to ensure that new_name is valid and
 442  * won't conflict with other kobjects.
 443  */
 444 int kobject_rename(struct kobject *kobj, const char *new_name)
 445 {
 446         int error = 0;
 447         const char *devpath = NULL;
 448         const char *dup_name = NULL, *name;
 449         char *devpath_string = NULL;
 450         char *envp[2];
 451
 452         kobj = kobject_get(kobj);
 453         if (!kobj)
 454                 return -EINVAL;
 455         if (!kobj->parent)
 456                 return -EINVAL;
 457
 458         devpath = kobject_get_path(kobj, GFP_KERNEL);
 459         if (!devpath) {
 460                 error = -ENOMEM;
 461                 goto out;
 462         }
 463         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
 464         if (!devpath_string) {
 465                 error = -ENOMEM;
 466                 goto out;
 467         }
 468         sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
 469         envp[0] = devpath_string;
 470         envp[1] = NULL;
 471
 472         name = dup_name = kstrdup(new_name, GFP_KERNEL);
 473         if (!name) {
 474                 error = -ENOMEM;
 475                 goto out;
 476         }
 477
 478         error = sysfs_rename_dir_ns(kobj, new_name, kobject_namespace(kobj));
 479         if (error)
 480                 goto out;
 481
 482         /* Install the new kobject name */
 483         dup_name = kobj->name;
 484         kobj->name = name;
 485
 486         /* This function is mostly/only used for network interface.
 487          * Some hotplug package track interfaces by their name and
 488          * therefore want to know when the name is changed by the user. */
 489         kobject_uevent_env(kobj, KOBJ_MOVE, envp);
 490
 491 out:
 492         kfree(dup_name);
 493         kfree(devpath_string);
 494         kfree(devpath);
 495         kobject_put(kobj);
 496
 497         return error;
 498 }
 499 EXPORT_SYMBOL_GPL(kobject_rename);
 500
 501 /**
 502  * kobject_move - move object to another parent
 503  * @kobj: object in question.
 504  * @new_parent: object's new parent (can be NULL)
 505  */
 506 int kobject_move(struct kobject *kobj, struct kobject *new_parent)
 507 {
 508         int error;
 509         struct kobject *old_parent;
 510         const char *devpath = NULL;
 511         char *devpath_string = NULL;
 512         char *envp[2];
 513
 514         kobj = kobject_get(kobj);
 515         if (!kobj)
 516                 return -EINVAL;
 517         new_parent = kobject_get(new_parent);
 518         if (!new_parent) {
 519                 if (kobj->kset)
 520                         new_parent = kobject_get(&kobj->kset->kobj);
 521         }
 522
 523         /* old object path */
 524         devpath = kobject_get_path(kobj, GFP_KERNEL);
 525         if (!devpath) {
 526                 error = -ENOMEM;
 527                 goto out;
 528         }
 529         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
 530         if (!devpath_string) {
 531                 error = -ENOMEM;
 532                 goto out;
 533         }
 534         sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
 535         envp[0] = devpath_string;
 536         envp[1] = NULL;
 537         error = sysfs_move_dir_ns(kobj, new_parent, kobject_namespace(kobj));
 538         if (error)
 539                 goto out;
 540         old_parent = kobj->parent;
 541         kobj->parent = new_parent;
 542         new_parent = NULL;
 543         kobject_put(old_parent);
 544         kobject_uevent_env(kobj, KOBJ_MOVE, envp);
 545 out:
 546         kobject_put(new_parent);
 547         kobject_put(kobj);
 548         kfree(devpath_string);
 549         kfree(devpath);
 550         return error;
 551 }
 552
 553 /**
 554  * kobject_del - unlink kobject from hierarchy.
 555  * @kobj: object.
 556  */
 557 void kobject_del(struct kobject *kobj)
 558 {
 559         struct kernfs_node *sd;
 560
 561         if (!kobj)
 562                 return;
 563
 564         sd = kobj->sd;
 565         sysfs_remove_dir(kobj);
 566         sysfs_put(sd);
 567
 568         kobj->state_in_sysfs = 0;
 569         kobj_kset_leave(kobj);
 570         kobject_put(kobj->parent);
 571         kobj->parent = NULL;
 572 }
 573
 574 /**
 575  * kobject_get - increment refcount for object.
 576  * @kobj: object.
 577  */
 578 struct kobject *kobject_get(struct kobject *kobj)
 579 {
 580         if (kobj)
 581                 kref_get(&kobj->kref);
 582         return kobj;
 583 }
 584
 585 static struct kobject * __must_check kobject_get_unless_zero(struct kobject *kobj)
 586 {
 587         if (!kref_get_unless_zero(&kobj->kref))
 588                 kobj = NULL;
 589         return kobj;
 590 }
 591
 592 /*
 593  * kobject_cleanup - free kobject resources.
 594  * @kobj: object to cleanup
 595  */
 596 static void kobject_cleanup(struct kobject *kobj)
 597 {
 598         struct kobj_type *t = get_ktype(kobj);
 599         const char *name = kobj->name;
 600
 601         pr_debug("kobject: '%s' (%p): %s, parent %p\n",
 602                  kobject_name(kobj), kobj, __func__, kobj->parent);
 603
 604         if (t && !t->release)
 605                 pr_debug("kobject: '%s' (%p): does not have a release() "
 606                          "function, it is broken and must be fixed.\n",
 607                          kobject_name(kobj), kobj);
 608
 609         /* send "remove" if the caller did not do it but sent "add" */
 610         if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) {
 611                 pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n",
 612                          kobject_name(kobj), kobj);
 613                 kobject_uevent(kobj, KOBJ_REMOVE);
 614         }
 615
 616         /* remove from sysfs if the caller did not do it */
 617         if (kobj->state_in_sysfs) {
 618                 pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n",
 619                          kobject_name(kobj), kobj);
 620                 kobject_del(kobj);
 621         }
 622
 623         if (t && t->release) {
 624                 pr_debug("kobject: '%s' (%p): calling ktype release\n",
 625                          kobject_name(kobj), kobj);
 626                 t->release(kobj);
 627         }
 628
 629         /* free name if we allocated it */
 630         if (name) {
 631                 pr_debug("kobject: '%s': free name\n", name);
 632                 kfree(name);
 633         }
 634 }
 635
 636 #ifdef CONFIG_DEBUG_KOBJECT_RELEASE
 637 static void kobject_delayed_cleanup(struct work_struct *work)
 638 {
 639         kobject_cleanup(container_of(to_delayed_work(work),
 640                                      struct kobject, release));
 641 }
 642 #endif
 643
 644 static void kobject_release(struct kref *kref)
 645 {
 646         struct kobject *kobj = container_of(kref, struct kobject, kref);
 647 #ifdef CONFIG_DEBUG_KOBJECT_RELEASE
 648         unsigned long delay = HZ + HZ * (get_random_int() & 0x3);
 649         pr_info("kobject: '%s' (%p): %s, parent %p (delayed %ld)\n",
 650                  kobject_name(kobj), kobj, __func__, kobj->parent, delay);
 651         INIT_DELAYED_WORK(&kobj->release, kobject_delayed_cleanup);
 652
 653         schedule_delayed_work(&kobj->release, delay);
 654 #else
 655         kobject_cleanup(kobj);
 656 #endif
 657 }
 658
 659 /**
 660  * kobject_put - decrement refcount for object.
 661  * @kobj: object.
 662  *
 663  * Decrement the refcount, and if 0, call kobject_cleanup().
 664  */
 665 void kobject_put(struct kobject *kobj)
 666 {
 667         if (kobj) {
 668                 if (!kobj->state_initialized)
 669                         WARN(1, KERN_WARNING "kobject: '%s' (%p): is not "
 670                                "initialized, yet kobject_put() is being "
 671                                "called.\n", kobject_name(kobj), kobj);
 672                 kref_put(&kobj->kref, kobject_release);
 673         }
 674 }
 675
 676 static void dynamic_kobj_release(struct kobject *kobj)
 677 {
 678         pr_debug("kobject: (%p): %s\n", kobj, __func__);
 679         kfree(kobj);
 680 }
 681
 682 static struct kobj_type dynamic_kobj_ktype = {
 683         .release        = dynamic_kobj_release,
 684         .sysfs_ops      = &kobj_sysfs_ops,
 685 };
 686
 687 /**
 688  * kobject_create - create a struct kobject dynamically
 689  *
 690  * This function creates a kobject structure dynamically and sets it up
 691  * to be a "dynamic" kobject with a default release function set up.
 692  *
 693  * If the kobject was not able to be created, NULL will be returned.
 694  * The kobject structure returned from here must be cleaned up with a
 695  * call to kobject_put() and not kfree(), as kobject_init() has
 696  * already been called on this structure.
 697  */
 698 struct kobject *kobject_create(void)
 699 {
 700         struct kobject *kobj;
 701
 702         kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
 703         if (!kobj)
 704                 return NULL;
 705
 706         kobject_init(kobj, &dynamic_kobj_ktype);
 707         return kobj;
 708 }
 709
 710 /**
 711  * kobject_create_and_add - create a struct kobject dynamically and register it with sysfs
 712  *
 713  * @name: the name for the kobject
 714  * @parent: the parent kobject of this kobject, if any.
 715  *
 716  * This function creates a kobject structure dynamically and registers it
 717  * with sysfs.  When you are finished with this structure, call
 718  * kobject_put() and the structure will be dynamically freed when
 719  * it is no longer being used.
 720  *
 721  * If the kobject was not able to be created, NULL will be returned.
 722  */
 723 struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)
 724 {
 725         struct kobject *kobj;
 726         int retval;
 727
 728         kobj = kobject_create();
 729         if (!kobj)
 730                 return NULL;
 731
 732         retval = kobject_add(kobj, parent, "%s", name);
 733         if (retval) {
 734                 printk(KERN_WARNING "%s: kobject_add error: %d\n",
 735                        __func__, retval);
 736                 kobject_put(kobj);
 737                 kobj = NULL;
 738         }
 739         return kobj;
 740 }
 741 EXPORT_SYMBOL_GPL(kobject_create_and_add);
 742
 743 /**
 744  * kset_init - initialize a kset for use
 745  * @k: kset
 746  */
 747 void kset_init(struct kset *k)
 748 {
 749         kobject_init_internal(&k->kobj);
 750         INIT_LIST_HEAD(&k->list);
 751         spin_lock_init(&k->list_lock);
 752 }
 753
 754 /* default kobject attribute operations */
 755 static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,
 756                               char *buf)
 757 {
 758         struct kobj_attribute *kattr;
 759         ssize_t ret = -EIO;
 760
 761         kattr = container_of(attr, struct kobj_attribute, attr);
 762         if (kattr->show)
 763                 ret = kattr->show(kobj, kattr, buf);
 764         return ret;
 765 }
 766
 767 static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,
 768                                const char *buf, size_t count)
 769 {
 770         struct kobj_attribute *kattr;
 771         ssize_t ret = -EIO;
 772
 773         kattr = container_of(attr, struct kobj_attribute, attr);
 774         if (kattr->store)
 775                 ret = kattr->store(kobj, kattr, buf, count);
 776         return ret;
 777 }
 778
 779 const struct sysfs_ops kobj_sysfs_ops = {
 780         .show   = kobj_attr_show,
 781         .store  = kobj_attr_store,
 782 };
 783
 784 /**
 785  * kobj_completion_init - initialize a kobj_completion object.
 786  * @kc: kobj_completion
 787  * @ktype: type of kobject to initialize
 788  *
 789  * kobj_completion structures can be embedded within structures with different
 790  * lifetime rules.  During the release of the enclosing object, we can
 791  * wait on the release of the kobject so that we don't free it while it's
 792  * still busy.
 793  */
 794 void kobj_completion_init(struct kobj_completion *kc, struct kobj_type *ktype)
 795 {
 796         init_completion(&kc->kc_unregister);
 797         kobject_init(&kc->kc_kobj, ktype);
 798 }
 799 EXPORT_SYMBOL_GPL(kobj_completion_init);
 800
 801 /**
 802  * kobj_completion_release - release a kobj_completion object
 803  * @kobj: kobject embedded in kobj_completion
 804  *
 805  * Used with kobject_release to notify waiters that the kobject has been
 806  * released.
 807  */
 808 void kobj_completion_release(struct kobject *kobj)
 809 {
 810         struct kobj_completion *kc = kobj_to_kobj_completion(kobj);
 811         complete(&kc->kc_unregister);
 812 }
 813 EXPORT_SYMBOL_GPL(kobj_completion_release);
 814
 815 /**
 816  * kobj_completion_del_and_wait - release the kobject and wait for it
 817  * @kc: kobj_completion object to release
 818  *
 819  * Delete the kobject from sysfs and drop the reference count.  Then wait
 820  * until any other outstanding references are also dropped.  This routine
 821  * is only necessary once other references may have been taken on the
 822  * kobject.  Typically this happens when the kobject has been published
 823  * to sysfs via kobject_add.
 824  */
 825 void kobj_completion_del_and_wait(struct kobj_completion *kc)
 826 {
 827         kobject_del(&kc->kc_kobj);
 828         kobject_put(&kc->kc_kobj);
 829         wait_for_completion(&kc->kc_unregister);
 830 }
 831 EXPORT_SYMBOL_GPL(kobj_completion_del_and_wait);
 832
 833 /**
 834  * kset_register - initialize and add a kset.
 835  * @k: kset.
 836  */
 837 int kset_register(struct kset *k)
 838 {
 839         int err;
 840
 841         if (!k)
 842                 return -EINVAL;
 843
 844         kset_init(k);
 845         err = kobject_add_internal(&k->kobj);
 846         if (err)
 847                 return err;
 848         kobject_uevent(&k->kobj, KOBJ_ADD);
 849         return 0;
 850 }
 851
 852 /**
 853  * kset_unregister - remove a kset.
 854  * @k: kset.
 855  */
 856 void kset_unregister(struct kset *k)
 857 {
 858         if (!k)
 859                 return;
 860         kobject_del(&k->kobj);
 861         kobject_put(&k->kobj);
 862 }
 863
 864 /**
 865  * kset_find_obj - search for object in kset.
 866  * @kset: kset we're looking in.
 867  * @name: object's name.
 868  *
 869  * Lock kset via @kset->subsys, and iterate over @kset->list,
 870  * looking for a matching kobject. If matching object is found
 871  * take a reference and return the object.
 872  */
 873 struct kobject *kset_find_obj(struct kset *kset, const char *name)
 874 {
 875         struct kobject *k;
 876         struct kobject *ret = NULL;
 877
 878         spin_lock(&kset->list_lock);
 879
 880         list_for_each_entry(k, &kset->list, entry) {
 881                 if (kobject_name(k) && !strcmp(kobject_name(k), name)) {
 882                         ret = kobject_get_unless_zero(k);
 883                         break;
 884                 }
 885         }
 886
 887         spin_unlock(&kset->list_lock);
 888         return ret;
 889 }
 890
 891 static void kset_release(struct kobject *kobj)
 892 {
 893         struct kset *kset = container_of(kobj, struct kset, kobj);
 894         pr_debug("kobject: '%s' (%p): %s\n",
 895                  kobject_name(kobj), kobj, __func__);
 896         kfree(kset);
 897 }
 898
 899 static struct kobj_type kset_ktype = {
 900         .sysfs_ops      = &kobj_sysfs_ops,
 901         .release = kset_release,
 902 };
 903
 904 /**
 905  * kset_create - create a struct kset dynamically
 906  *
 907  * @name: the name for the kset
 908  * @uevent_ops: a struct kset_uevent_ops for the kset
 909  * @parent_kobj: the parent kobject of this kset, if any.
 910  *
 911  * This function creates a kset structure dynamically.  This structure can
 912  * then be registered with the system and show up in sysfs with a call to
 913  * kset_register().  When you are finished with this structure, if
 914  * kset_register() has been called, call kset_unregister() and the
 915  * structure will be dynamically freed when it is no longer being used.
 916  *
 917  * If the kset was not able to be created, NULL will be returned.
 918  */
 919 static struct kset *kset_create(const char *name,
 920                                 const struct kset_uevent_ops *uevent_ops,
 921                                 struct kobject *parent_kobj)
 922 {
 923         struct kset *kset;
 924         int retval;
 925
 926         kset = kzalloc(sizeof(*kset), GFP_KERNEL);
 927         if (!kset)
 928                 return NULL;
 929         retval = kobject_set_name(&kset->kobj, "%s", name);
 930         if (retval) {
 931                 kfree(kset);
 932                 return NULL;
 933         }
 934         kset->uevent_ops = uevent_ops;
 935         kset->kobj.parent = parent_kobj;
 936
 937         /*
 938          * The kobject of this kset will have a type of kset_ktype and belong to
 939          * no kset itself.  That way we can properly free it when it is
 940          * finished being used.
 941          */
 942         kset->kobj.ktype = &kset_ktype;
 943         kset->kobj.kset = NULL;
 944
 945         return kset;
 946 }
 947
 948 /**
 949  * kset_create_and_add - create a struct kset dynamically and add it to sysfs
 950  *
 951  * @name: the name for the kset
 952  * @uevent_ops: a struct kset_uevent_ops for the kset
 953  * @parent_kobj: the parent kobject of this kset, if any.
 954  *
 955  * This function creates a kset structure dynamically and registers it
 956  * with sysfs.  When you are finished with this structure, call
 957  * kset_unregister() and the structure will be dynamically freed when it
 958  * is no longer being used.
 959  *
 960  * If the kset was not able to be created, NULL will be returned.
 961  */
 962 struct kset *kset_create_and_add(const char *name,
 963                                  const struct kset_uevent_ops *uevent_ops,
 964                                  struct kobject *parent_kobj)
 965 {
 966         struct kset *kset;
 967         int error;
 968
 969         kset = kset_create(name, uevent_ops, parent_kobj);
 970         if (!kset)
 971                 return NULL;
 972         error = kset_register(kset);
 973         if (error) {
 974                 kfree(kset);
 975                 return NULL;
 976         }
 977         return kset;
 978 }
 979 EXPORT_SYMBOL_GPL(kset_create_and_add);
 980
 981
 982 static DEFINE_SPINLOCK(kobj_ns_type_lock);
 983 static const struct kobj_ns_type_operations *kobj_ns_ops_tbl[KOBJ_NS_TYPES];
 984
 985 int kobj_ns_type_register(const struct kobj_ns_type_operations *ops)
 986 {
 987         enum kobj_ns_type type = ops->type;
 988         int error;
 989
 990         spin_lock(&kobj_ns_type_lock);
 991
 992         error = -EINVAL;
 993         if (type >= KOBJ_NS_TYPES)
 994                 goto out;
 995
 996         error = -EINVAL;
 997         if (type <= KOBJ_NS_TYPE_NONE)
 998                 goto out;
 999
1000         error = -EBUSY;
1001         if (kobj_ns_ops_tbl[type])
1002                 goto out;
1003
1004         error = 0;
1005         kobj_ns_ops_tbl[type] = ops;
1006
1007 out:
1008         spin_unlock(&kobj_ns_type_lock);
1009         return error;
1010 }
1011
1012 int kobj_ns_type_registered(enum kobj_ns_type type)
1013 {
1014         int registered = 0;
1015
1016         spin_lock(&kobj_ns_type_lock);
1017         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES))
1018                 registered = kobj_ns_ops_tbl[type] != NULL;
1019         spin_unlock(&kobj_ns_type_lock);
1020
1021         return registered;
1022 }
1023
1024 const struct kobj_ns_type_operations *kobj_child_ns_ops(struct kobject *parent)
1025 {
1026         const struct kobj_ns_type_operations *ops = NULL;
1027
1028         if (parent && parent->ktype->child_ns_type)
1029                 ops = parent->ktype->child_ns_type(parent);
1030
1031         return ops;
1032 }
1033
1034 const struct kobj_ns_type_operations *kobj_ns_ops(struct kobject *kobj)
1035 {
1036         return kobj_child_ns_ops(kobj->parent);
1037 }
1038
1039 bool kobj_ns_current_may_mount(enum kobj_ns_type type)
1040 {
1041         bool may_mount = true;
1042
1043         spin_lock(&kobj_ns_type_lock);
1044         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1045             kobj_ns_ops_tbl[type])
1046                 may_mount = kobj_ns_ops_tbl[type]->current_may_mount();
1047         spin_unlock(&kobj_ns_type_lock);
1048
1049         return may_mount;
1050 }
1051
1052 void *kobj_ns_grab_current(enum kobj_ns_type type)
1053 {
1054         void *ns = NULL;
1055
1056         spin_lock(&kobj_ns_type_lock);
1057         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1058             kobj_ns_ops_tbl[type])
1059                 ns = kobj_ns_ops_tbl[type]->grab_current_ns();
1060         spin_unlock(&kobj_ns_type_lock);
1061
1062         return ns;
1063 }
1064
1065 const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk)
1066 {
1067         const void *ns = NULL;
1068
1069         spin_lock(&kobj_ns_type_lock);
1070         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1071             kobj_ns_ops_tbl[type])
1072                 ns = kobj_ns_ops_tbl[type]->netlink_ns(sk);
1073         spin_unlock(&kobj_ns_type_lock);
1074
1075         return ns;
1076 }
1077
1078 const void *kobj_ns_initial(enum kobj_ns_type type)
1079 {
1080         const void *ns = NULL;
1081
1082         spin_lock(&kobj_ns_type_lock);
1083         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1084             kobj_ns_ops_tbl[type])
1085                 ns = kobj_ns_ops_tbl[type]->initial_ns();
1086         spin_unlock(&kobj_ns_type_lock);
1087
1088         return ns;
1089 }
1090
1091 void kobj_ns_drop(enum kobj_ns_type type, void *ns)
1092 {
1093         spin_lock(&kobj_ns_type_lock);
1094         if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1095             kobj_ns_ops_tbl[type] && kobj_ns_ops_tbl[type]->drop_ns)
1096                 kobj_ns_ops_tbl[type]->drop_ns(ns);
1097         spin_unlock(&kobj_ns_type_lock);
1098 }
1099
1100 EXPORT_SYMBOL(kobject_get);
1101 EXPORT_SYMBOL(kobject_put);
1102 EXPORT_SYMBOL(kobject_del);
1103
1104 EXPORT_SYMBOL(kset_register);
1105 EXPORT_SYMBOL(kset_unregister);