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/string.h>
  17 #include <linux/module.h>
  18 #include <linux/stat.h>
  19 #include <linux/slab.h>
  20
  21 /**
  22  *      populate_dir - populate directory with attributes.
  23  *      @kobj:  object we're working on.
  24  *
  25  *      Most subsystems have a set of default attributes that
  26  *      are associated with an object that registers with them.
  27  *      This is a helper called during object registration that
  28  *      loops through the default attributes of the subsystem
  29  *      and creates attributes files for them in sysfs.
  30  *
  31  */
  32
  33 static int populate_dir(struct kobject * kobj)
  34 {
  35         struct kobj_type * t = get_ktype(kobj);
  36         struct attribute * attr;
  37         int error = 0;
  38         int i;
  39
  40         if (t && t->default_attrs) {
  41                 for (i = 0; (attr = t->default_attrs[i]) != NULL; i++) {
  42                         if ((error = sysfs_create_file(kobj,attr)))
  43                                 break;
  44                 }
  45         }
  46         return error;
  47 }
  48
  49 static int create_dir(struct kobject * kobj)
  50 {
  51         int error = 0;
  52         if (kobject_name(kobj)) {
  53                 error = sysfs_create_dir(kobj);
  54                 if (!error) {
  55                         if ((error = populate_dir(kobj)))
  56                                 sysfs_remove_dir(kobj);
  57                 }
  58         }
  59         return error;
  60 }
  61
  62 static inline struct kobject * to_kobj(struct list_head * entry)
  63 {
  64         return container_of(entry,struct kobject,entry);
  65 }
  66
  67 static int get_kobj_path_length(struct kobject *kobj)
  68 {
  69         int length = 1;
  70         struct kobject * parent = kobj;
  71
  72         /* walk up the ancestors until we hit the one pointing to the
  73          * root.
  74          * Add 1 to strlen for leading '/' of each level.
  75          */
  76         do {
  77                 if (kobject_name(parent) == NULL)
  78                         return 0;
  79                 length += strlen(kobject_name(parent)) + 1;
  80                 parent = parent->parent;
  81         } while (parent);
  82         return length;
  83 }
  84
  85 static void fill_kobj_path(struct kobject *kobj, char *path, int length)
  86 {
  87         struct kobject * parent;
  88
  89         --length;
  90         for (parent = kobj; parent; parent = parent->parent) {
  91                 int cur = strlen(kobject_name(parent));
  92                 /* back up enough to print this name with '/' */
  93                 length -= cur;
  94                 strncpy (path + length, kobject_name(parent), cur);
  95                 *(path + --length) = '/';
  96         }
  97
  98         pr_debug("kobject: '%s' (%p): %s: path = '%s'\n", kobject_name(kobj),
  99                  kobj, __FUNCTION__,path);
 100 }
 101
 102 /**
 103  * kobject_get_path - generate and return the path associated with a given kobj and kset pair.
 104  *
 105  * @kobj:       kobject in question, with which to build the path
 106  * @gfp_mask:   the allocation type used to allocate the path
 107  *
 108  * The result must be freed by the caller with kfree().
 109  */
 110 char *kobject_get_path(struct kobject *kobj, gfp_t gfp_mask)
 111 {
 112         char *path;
 113         int len;
 114
 115         len = get_kobj_path_length(kobj);
 116         if (len == 0)
 117                 return NULL;
 118         path = kzalloc(len, gfp_mask);
 119         if (!path)
 120                 return NULL;
 121         fill_kobj_path(kobj, path, len);
 122
 123         return path;
 124 }
 125 EXPORT_SYMBOL_GPL(kobject_get_path);
 126
 127 /* add the kobject to its kset's list */
 128 static void kobj_kset_join(struct kobject *kobj)
 129 {
 130         if (!kobj->kset)
 131                 return;
 132
 133         kset_get(kobj->kset);
 134         spin_lock(&kobj->kset->list_lock);
 135         list_add_tail(&kobj->entry, &kobj->kset->list);
 136         spin_unlock(&kobj->kset->list_lock);
 137 }
 138
 139 /* remove the kobject from its kset's list */
 140 static void kobj_kset_leave(struct kobject *kobj)
 141 {
 142         if (!kobj->kset)
 143                 return;
 144
 145         spin_lock(&kobj->kset->list_lock);
 146         list_del_init(&kobj->entry);
 147         spin_unlock(&kobj->kset->list_lock);
 148         kset_put(kobj->kset);
 149 }
 150
 151 static void kobject_init_internal(struct kobject * kobj)
 152 {
 153         if (!kobj)
 154                 return;
 155         kref_init(&kobj->kref);
 156         INIT_LIST_HEAD(&kobj->entry);
 157 }
 158
 159
 160 static int kobject_add_internal(struct kobject *kobj)
 161 {
 162         int error = 0;
 163         struct kobject * parent;
 164
 165         if (!kobj)
 166                 return -ENOENT;
 167
 168         if (!kobj->name || !kobj->name[0]) {
 169                 pr_debug("kobject: (%p): attempted to be registered with empty "
 170                          "name!\n", kobj);
 171                 WARN_ON(1);
 172                 return -EINVAL;
 173         }
 174
 175         parent = kobject_get(kobj->parent);
 176
 177         /* join kset if set, use it as parent if we do not already have one */
 178         if (kobj->kset) {
 179                 if (!parent)
 180                         parent = kobject_get(&kobj->kset->kobj);
 181                 kobj_kset_join(kobj);
 182                 kobj->parent = parent;
 183         }
 184
 185         pr_debug("kobject: '%s' (%p): %s: parent: '%s', set: '%s'\n",
 186                  kobject_name(kobj), kobj, __FUNCTION__,
 187                  parent ? kobject_name(parent) : "<NULL>",
 188                  kobj->kset ? kobject_name(&kobj->kset->kobj) : "<NULL>" );
 189
 190         error = create_dir(kobj);
 191         if (error) {
 192                 kobj_kset_leave(kobj);
 193                 kobject_put(parent);
 194                 kobj->parent = NULL;
 195
 196                 /* be noisy on error issues */
 197                 if (error == -EEXIST)
 198                         printk(KERN_ERR "%s failed for %s with "
 199                                "-EEXIST, don't try to register things with "
 200                                "the same name in the same directory.\n",
 201                                __FUNCTION__, kobject_name(kobj));
 202                 else
 203                         printk(KERN_ERR "%s failed for %s (%d)\n",
 204                                __FUNCTION__, kobject_name(kobj), error);
 205                 dump_stack();
 206         } else
 207                 kobj->state_in_sysfs = 1;
 208
 209         return error;
 210 }
 211
 212 /**
 213  * kobject_set_name_vargs - Set the name of an kobject
 214  * @kobj: struct kobject to set the name of
 215  * @fmt: format string used to build the name
 216  * @vargs: vargs to format the string.
 217  */
 218 static int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
 219                                   va_list vargs)
 220 {
 221         va_list aq;
 222         char *name;
 223
 224         va_copy(aq, vargs);
 225         name = kvasprintf(GFP_KERNEL, fmt, vargs);
 226         va_end(aq);
 227
 228         if (!name)
 229                 return -ENOMEM;
 230
 231         /* Free the old name, if necessary. */
 232         kfree(kobj->name);
 233
 234         /* Now, set the new name */
 235         kobj->name = name;
 236
 237         return 0;
 238 }
 239
 240 /**
 241  * kobject_set_name - Set the name of a kobject
 242  * @kobj: struct kobject to set the name of
 243  * @fmt: format string used to build the name
 244  *
 245  * This sets the name of the kobject.  If you have already added the
 246  * kobject to the system, you must call kobject_rename() in order to
 247  * change the name of the kobject.
 248  */
 249 int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
 250 {
 251         va_list args;
 252         int retval;
 253
 254         va_start(args, fmt);
 255         retval = kobject_set_name_vargs(kobj, fmt, args);
 256         va_end(args);
 257
 258         return retval;
 259 }
 260 EXPORT_SYMBOL(kobject_set_name);
 261
 262 /**
 263  * kobject_init - initialize a kobject structure
 264  * @kobj: pointer to the kobject to initialize
 265  * @ktype: pointer to the ktype for this kobject.
 266  *
 267  * This function will properly initialize a kobject such that it can then
 268  * be passed to the kobject_add() call.
 269  *
 270  * After this function is called, the kobject MUST be cleaned up by a call
 271  * to kobject_put(), not by a call to kfree directly to ensure that all of
 272  * the memory is cleaned up properly.
 273  */
 274 void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
 275 {
 276         char *err_str;
 277
 278         if (!kobj) {
 279                 err_str = "invalid kobject pointer!";
 280                 goto error;
 281         }
 282         if (!ktype) {
 283                 err_str = "must have a ktype to be initialized properly!\n";
 284                 goto error;
 285         }
 286         if (kobj->state_initialized) {
 287                 /* do not error out as sometimes we can recover */
 288                 printk(KERN_ERR "kobject (%p): tried to init an initialized "
 289                        "object, something is seriously wrong.\n", kobj);
 290                 dump_stack();
 291         }
 292
 293         kref_init(&kobj->kref);
 294         INIT_LIST_HEAD(&kobj->entry);
 295         kobj->ktype = ktype;
 296         kobj->state_in_sysfs = 0;
 297         kobj->state_add_uevent_sent = 0;
 298         kobj->state_remove_uevent_sent = 0;
 299         kobj->state_initialized = 1;
 300         return;
 301
 302 error:
 303         printk(KERN_ERR "kobject (%p): %s\n", kobj, err_str);
 304         dump_stack();
 305 }
 306 EXPORT_SYMBOL(kobject_init);
 307
 308 static int kobject_add_varg(struct kobject *kobj, struct kobject *parent,
 309                             const char *fmt, va_list vargs)
 310 {
 311         va_list aq;
 312         int retval;
 313
 314         va_copy(aq, vargs);
 315         retval = kobject_set_name_vargs(kobj, fmt, aq);
 316         va_end(aq);
 317         if (retval) {
 318                 printk(KERN_ERR "kobject: can not set name properly!\n");
 319                 return retval;
 320         }
 321         kobj->parent = parent;
 322         return kobject_add_internal(kobj);
 323 }
 324
 325 /**
 326  * kobject_add - the main kobject add function
 327  * @kobj: the kobject to add
 328  * @parent: pointer to the parent of the kobject.
 329  * @fmt: format to name the kobject with.
 330  *
 331  * The kobject name is set and added to the kobject hierarchy in this
 332  * function.
 333  *
 334  * If @parent is set, then the parent of the @kobj will be set to it.
 335  * If @parent is NULL, then the parent of the @kobj will be set to the
 336  * kobject associted with the kset assigned to this kobject.  If no kset
 337  * is assigned to the kobject, then the kobject will be located in the
 338  * root of the sysfs tree.
 339  *
 340  * If this function returns an error, kobject_put() must be called to
 341  * properly clean up the memory associated with the object.
 342  * Under no instance should the kobject that is passed to this function
 343  * be directly freed with a call to kfree(), that can leak memory.
 344  *
 345  * Note, no "add" uevent will be created with this call, the caller should set
 346  * up all of the necessary sysfs files for the object and then call
 347  * kobject_uevent() with the UEVENT_ADD parameter to ensure that
 348  * userspace is properly notified of this kobject's creation.
 349  */
 350 int kobject_add(struct kobject *kobj, struct kobject *parent,
 351                 const char *fmt, ...)
 352 {
 353         va_list args;
 354         int retval;
 355
 356         if (!kobj)
 357                 return -EINVAL;
 358
 359         if (!kobj->state_initialized) {
 360                 printk(KERN_ERR "kobject '%s' (%p): tried to add an "
 361                        "uninitialized object, something is seriously wrong.\n",
 362                        kobject_name(kobj), kobj);
 363                 dump_stack();
 364                 return -EINVAL;
 365         }
 366         va_start(args, fmt);
 367         retval = kobject_add_varg(kobj, parent, fmt, args);
 368         va_end(args);
 369
 370         return retval;
 371 }
 372 EXPORT_SYMBOL(kobject_add);
 373
 374 /**
 375  * kobject_init_and_add - initialize a kobject structure and add it to the kobject hierarchy
 376  * @kobj: pointer to the kobject to initialize
 377  * @ktype: pointer to the ktype for this kobject.
 378  * @parent: pointer to the parent of this kobject.
 379  * @fmt: the name of the kobject.
 380  *
 381  * This function combines the call to kobject_init() and
 382  * kobject_add().  The same type of error handling after a call to
 383  * kobject_add() and kobject lifetime rules are the same here.
 384  */
 385 int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype,
 386                          struct kobject *parent, const char *fmt, ...)
 387 {
 388         va_list args;
 389         int retval;
 390
 391         kobject_init(kobj, ktype);
 392
 393         va_start(args, fmt);
 394         retval = kobject_add_varg(kobj, parent, fmt, args);
 395         va_end(args);
 396
 397         return retval;
 398 }
 399 EXPORT_SYMBOL_GPL(kobject_init_and_add);
 400
 401 /**
 402  *      kobject_rename - change the name of an object
 403  *      @kobj:  object in question.
 404  *      @new_name: object's new name
 405  */
 406
 407 int kobject_rename(struct kobject * kobj, const char *new_name)
 408 {
 409         int error = 0;
 410         const char *devpath = NULL;
 411         char *devpath_string = NULL;
 412         char *envp[2];
 413
 414         kobj = kobject_get(kobj);
 415         if (!kobj)
 416                 return -EINVAL;
 417         if (!kobj->parent)
 418                 return -EINVAL;
 419
 420         /* see if this name is already in use */
 421         if (kobj->kset) {
 422                 struct kobject *temp_kobj;
 423                 temp_kobj = kset_find_obj(kobj->kset, new_name);
 424                 if (temp_kobj) {
 425                         printk(KERN_WARNING "kobject '%s' cannot be renamed "
 426                                "to '%s' as '%s' is already in existence.\n",
 427                                kobject_name(kobj), new_name, new_name);
 428                         kobject_put(temp_kobj);
 429                         return -EINVAL;
 430                 }
 431         }
 432
 433         devpath = kobject_get_path(kobj, GFP_KERNEL);
 434         if (!devpath) {
 435                 error = -ENOMEM;
 436                 goto out;
 437         }
 438         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
 439         if (!devpath_string) {
 440                 error = -ENOMEM;
 441                 goto out;
 442         }
 443         sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
 444         envp[0] = devpath_string;
 445         envp[1] = NULL;
 446
 447         error = sysfs_rename_dir(kobj, new_name);
 448
 449         /* This function is mostly/only used for network interface.
 450          * Some hotplug package track interfaces by their name and
 451          * therefore want to know when the name is changed by the user. */
 452         if (!error)
 453                 kobject_uevent_env(kobj, KOBJ_MOVE, envp);
 454
 455 out:
 456         kfree(devpath_string);
 457         kfree(devpath);
 458         kobject_put(kobj);
 459
 460         return error;
 461 }
 462
 463 /**
 464  *      kobject_move - move object to another parent
 465  *      @kobj:  object in question.
 466  *      @new_parent: object's new parent (can be NULL)
 467  */
 468
 469 int kobject_move(struct kobject *kobj, struct kobject *new_parent)
 470 {
 471         int error;
 472         struct kobject *old_parent;
 473         const char *devpath = NULL;
 474         char *devpath_string = NULL;
 475         char *envp[2];
 476
 477         kobj = kobject_get(kobj);
 478         if (!kobj)
 479                 return -EINVAL;
 480         new_parent = kobject_get(new_parent);
 481         if (!new_parent) {
 482                 if (kobj->kset)
 483                         new_parent = kobject_get(&kobj->kset->kobj);
 484         }
 485         /* old object path */
 486         devpath = kobject_get_path(kobj, GFP_KERNEL);
 487         if (!devpath) {
 488                 error = -ENOMEM;
 489                 goto out;
 490         }
 491         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
 492         if (!devpath_string) {
 493                 error = -ENOMEM;
 494                 goto out;
 495         }
 496         sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
 497         envp[0] = devpath_string;
 498         envp[1] = NULL;
 499         error = sysfs_move_dir(kobj, new_parent);
 500         if (error)
 501                 goto out;
 502         old_parent = kobj->parent;
 503         kobj->parent = new_parent;
 504         new_parent = NULL;
 505         kobject_put(old_parent);
 506         kobject_uevent_env(kobj, KOBJ_MOVE, envp);
 507 out:
 508         kobject_put(new_parent);
 509         kobject_put(kobj);
 510         kfree(devpath_string);
 511         kfree(devpath);
 512         return error;
 513 }
 514
 515 /**
 516  *      kobject_del - unlink kobject from hierarchy.
 517  *      @kobj:  object.
 518  */
 519
 520 void kobject_del(struct kobject * kobj)
 521 {
 522         if (!kobj)
 523                 return;
 524
 525         sysfs_remove_dir(kobj);
 526         kobj->state_in_sysfs = 0;
 527         kobj_kset_leave(kobj);
 528         kobject_put(kobj->parent);
 529         kobj->parent = NULL;
 530 }
 531
 532 /**
 533  *      kobject_get - increment refcount for object.
 534  *      @kobj:  object.
 535  */
 536
 537 struct kobject * kobject_get(struct kobject * kobj)
 538 {
 539         if (kobj)
 540                 kref_get(&kobj->kref);
 541         return kobj;
 542 }
 543
 544 /*
 545  * kobject_cleanup - free kobject resources.
 546  * @kobj: object to cleanup
 547  */
 548 static void kobject_cleanup(struct kobject *kobj)
 549 {
 550         struct kobj_type *t = get_ktype(kobj);
 551         const char *name = kobj->name;
 552
 553         pr_debug("kobject: '%s' (%p): %s\n",
 554                  kobject_name(kobj), kobj, __FUNCTION__);
 555
 556         if (t && !t->release)
 557                 pr_debug("kobject: '%s' (%p): does not have a release() "
 558                          "function, it is broken and must be fixed.\n",
 559                          kobject_name(kobj), kobj);
 560
 561         /* send "remove" if the caller did not do it but sent "add" */
 562         if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) {
 563                 pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n",
 564                          kobject_name(kobj), kobj);
 565                 kobject_uevent(kobj, KOBJ_REMOVE);
 566         }
 567
 568         /* remove from sysfs if the caller did not do it */
 569         if (kobj->state_in_sysfs) {
 570                 pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n",
 571                          kobject_name(kobj), kobj);
 572                 kobject_del(kobj);
 573         }
 574
 575         if (t && t->release) {
 576                 pr_debug("kobject: '%s' (%p): calling ktype release\n",
 577                          kobject_name(kobj), kobj);
 578                 t->release(kobj);
 579         }
 580
 581         /* free name if we allocated it */
 582         if (name) {
 583                 pr_debug("kobject: '%s': free name\n", name);
 584                 kfree(name);
 585         }
 586 }
 587
 588 static void kobject_release(struct kref *kref)
 589 {
 590         kobject_cleanup(container_of(kref, struct kobject, kref));
 591 }
 592
 593 /**
 594  *      kobject_put - decrement refcount for object.
 595  *      @kobj:  object.
 596  *
 597  *      Decrement the refcount, and if 0, call kobject_cleanup().
 598  */
 599 void kobject_put(struct kobject * kobj)
 600 {
 601         if (kobj)
 602                 kref_put(&kobj->kref, kobject_release);
 603 }
 604
 605 static void dynamic_kobj_release(struct kobject *kobj)
 606 {
 607         pr_debug("kobject: (%p): %s\n", kobj, __FUNCTION__);
 608         kfree(kobj);
 609 }
 610
 611 static struct kobj_type dynamic_kobj_ktype = {
 612         .release        = dynamic_kobj_release,
 613         .sysfs_ops      = &kobj_sysfs_ops,
 614 };
 615
 616 /**
 617  * kobject_create - create a struct kobject dynamically
 618  *
 619  * This function creates a kobject structure dynamically and sets it up
 620  * to be a "dynamic" kobject with a default release function set up.
 621  *
 622  * If the kobject was not able to be created, NULL will be returned.
 623  * The kobject structure returned from here must be cleaned up with a
 624  * call to kobject_put() and not kfree(), as kobject_init() has
 625  * already been called on this structure.
 626  */
 627 struct kobject *kobject_create(void)
 628 {
 629         struct kobject *kobj;
 630
 631         kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
 632         if (!kobj)
 633                 return NULL;
 634
 635         kobject_init(kobj, &dynamic_kobj_ktype);
 636         return kobj;
 637 }
 638
 639 /**
 640  * kobject_create_and_add - create a struct kobject dynamically and register it with sysfs
 641  *
 642  * @name: the name for the kset
 643  * @parent: the parent kobject of this kobject, if any.
 644  *
 645  * This function creates a kset structure dynamically and registers it
 646  * with sysfs.  When you are finished with this structure, call
 647  * kobject_put() and the structure will be dynamically freed when
 648  * it is no longer being used.
 649  *
 650  * If the kobject was not able to be created, NULL will be returned.
 651  */
 652 struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)
 653 {
 654         struct kobject *kobj;
 655         int retval;
 656
 657         kobj = kobject_create();
 658         if (!kobj)
 659                 return NULL;
 660
 661         retval = kobject_add(kobj, parent, "%s", name);
 662         if (retval) {
 663                 printk(KERN_WARNING "%s: kobject_add error: %d\n",
 664                        __FUNCTION__, retval);
 665                 kobject_put(kobj);
 666                 kobj = NULL;
 667         }
 668         return kobj;
 669 }
 670 EXPORT_SYMBOL_GPL(kobject_create_and_add);
 671
 672 /**
 673  *      kset_init - initialize a kset for use
 674  *      @k:     kset
 675  */
 676
 677 void kset_init(struct kset * k)
 678 {
 679         kobject_init_internal(&k->kobj);
 680         INIT_LIST_HEAD(&k->list);
 681         spin_lock_init(&k->list_lock);
 682 }
 683
 684 /* default kobject attribute operations */
 685 static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,
 686                               char *buf)
 687 {
 688         struct kobj_attribute *kattr;
 689         ssize_t ret = -EIO;
 690
 691         kattr = container_of(attr, struct kobj_attribute, attr);
 692         if (kattr->show)
 693                 ret = kattr->show(kobj, kattr, buf);
 694         return ret;
 695 }
 696
 697 static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,
 698                                const char *buf, size_t count)
 699 {
 700         struct kobj_attribute *kattr;
 701         ssize_t ret = -EIO;
 702
 703         kattr = container_of(attr, struct kobj_attribute, attr);
 704         if (kattr->store)
 705                 ret = kattr->store(kobj, kattr, buf, count);
 706         return ret;
 707 }
 708
 709 struct sysfs_ops kobj_sysfs_ops = {
 710         .show   = kobj_attr_show,
 711         .store  = kobj_attr_store,
 712 };
 713
 714 /**
 715  *      kset_register - initialize and add a kset.
 716  *      @k:     kset.
 717  */
 718
 719 int kset_register(struct kset * k)
 720 {
 721         int err;
 722
 723         if (!k)
 724                 return -EINVAL;
 725
 726         kset_init(k);
 727         err = kobject_add_internal(&k->kobj);
 728         if (err)
 729                 return err;
 730         kobject_uevent(&k->kobj, KOBJ_ADD);
 731         return 0;
 732 }
 733
 734
 735 /**
 736  *      kset_unregister - remove a kset.
 737  *      @k:     kset.
 738  */
 739
 740 void kset_unregister(struct kset * k)
 741 {
 742         if (!k)
 743                 return;
 744         kobject_put(&k->kobj);
 745 }
 746
 747
 748 /**
 749  *      kset_find_obj - search for object in kset.
 750  *      @kset:  kset we're looking in.
 751  *      @name:  object's name.
 752  *
 753  *      Lock kset via @kset->subsys, and iterate over @kset->list,
 754  *      looking for a matching kobject. If matching object is found
 755  *      take a reference and return the object.
 756  */
 757
 758 struct kobject * kset_find_obj(struct kset * kset, const char * name)
 759 {
 760         struct list_head * entry;
 761         struct kobject * ret = NULL;
 762
 763         spin_lock(&kset->list_lock);
 764         list_for_each(entry,&kset->list) {
 765                 struct kobject * k = to_kobj(entry);
 766                 if (kobject_name(k) && !strcmp(kobject_name(k),name)) {
 767                         ret = kobject_get(k);
 768                         break;
 769                 }
 770         }
 771         spin_unlock(&kset->list_lock);
 772         return ret;
 773 }
 774
 775 static void kset_release(struct kobject *kobj)
 776 {
 777         struct kset *kset = container_of(kobj, struct kset, kobj);
 778         pr_debug("kobject: '%s' (%p): %s\n",
 779                  kobject_name(kobj), kobj, __FUNCTION__);
 780         kfree(kset);
 781 }
 782
 783 static struct kobj_type kset_ktype = {
 784         .sysfs_ops      = &kobj_sysfs_ops,
 785         .release = kset_release,
 786 };
 787
 788 /**
 789  * kset_create - create a struct kset dynamically
 790  *
 791  * @name: the name for the kset
 792  * @uevent_ops: a struct kset_uevent_ops for the kset
 793  * @parent_kobj: the parent kobject of this kset, if any.
 794  *
 795  * This function creates a kset structure dynamically.  This structure can
 796  * then be registered with the system and show up in sysfs with a call to
 797  * kset_register().  When you are finished with this structure, if
 798  * kset_register() has been called, call kset_unregister() and the
 799  * structure will be dynamically freed when it is no longer being used.
 800  *
 801  * If the kset was not able to be created, NULL will be returned.
 802  */
 803 static struct kset *kset_create(const char *name,
 804                                 struct kset_uevent_ops *uevent_ops,
 805                                 struct kobject *parent_kobj)
 806 {
 807         struct kset *kset;
 808
 809         kset = kzalloc(sizeof(*kset), GFP_KERNEL);
 810         if (!kset)
 811                 return NULL;
 812         kobject_set_name(&kset->kobj, name);
 813         kset->uevent_ops = uevent_ops;
 814         kset->kobj.parent = parent_kobj;
 815
 816         /*
 817          * The kobject of this kset will have a type of kset_ktype and belong to
 818          * no kset itself.  That way we can properly free it when it is
 819          * finished being used.
 820          */
 821         kset->kobj.ktype = &kset_ktype;
 822         kset->kobj.kset = NULL;
 823
 824         return kset;
 825 }
 826
 827 /**
 828  * kset_create_and_add - create a struct kset dynamically and add it to sysfs
 829  *
 830  * @name: the name for the kset
 831  * @uevent_ops: a struct kset_uevent_ops for the kset
 832  * @parent_kobj: the parent kobject of this kset, if any.
 833  *
 834  * This function creates a kset structure dynamically and registers it
 835  * with sysfs.  When you are finished with this structure, call
 836  * kset_unregister() and the structure will be dynamically freed when it
 837  * is no longer being used.
 838  *
 839  * If the kset was not able to be created, NULL will be returned.
 840  */
 841 struct kset *kset_create_and_add(const char *name,
 842                                  struct kset_uevent_ops *uevent_ops,
 843                                  struct kobject *parent_kobj)
 844 {
 845         struct kset *kset;
 846         int error;
 847
 848         kset = kset_create(name, uevent_ops, parent_kobj);
 849         if (!kset)
 850                 return NULL;
 851         error = kset_register(kset);
 852         if (error) {
 853                 kfree(kset);
 854                 return NULL;
 855         }
 856         return kset;
 857 }
 858 EXPORT_SYMBOL_GPL(kset_create_and_add);
 859
 860 EXPORT_SYMBOL(kobject_get);
 861 EXPORT_SYMBOL(kobject_put);
 862 EXPORT_SYMBOL(kobject_del);
 863
 864 EXPORT_SYMBOL(kset_register);
 865 EXPORT_SYMBOL(kset_unregister);