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