SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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->k_name || !kobj->k_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
 232         /* Free the old name, if necessary. */
 233         kfree(kobj->k_name);
 234
 235         /* Now, set the new name */
 236         kobj->k_name = name;
 237         kobj->state_name_set = 1;
 238
 239         return 0;
 240 }
 241
 242 /**
 243  * kobject_set_name - Set the name of a kobject
 244  * @kobj: struct kobject to set the name of
 245  * @fmt: format string used to build the name
 246  *
 247  * This sets the name of the kobject.  If you have already added the
 248  * kobject to the system, you must call kobject_rename() in order to
 249  * change the name of the kobject.
 250  */
 251 int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
 252 {
 253         va_list args;
 254         int retval;
 255
 256         va_start(args, fmt);
 257         retval = kobject_set_name_vargs(kobj, fmt, args);
 258         va_end(args);
 259
 260         return retval;
 261 }
 262 EXPORT_SYMBOL(kobject_set_name);
 263
 264 /**
 265  * kobject_init - initialize a kobject structure
 266  * @kobj: pointer to the kobject to initialize
 267  * @ktype: pointer to the ktype for this kobject.
 268  *
 269  * This function will properly initialize a kobject such that it can then
 270  * be passed to the kobject_add() call.
 271  *
 272  * After this function is called, the kobject MUST be cleaned up by a call
 273  * to kobject_put(), not by a call to kfree directly to ensure that all of
 274  * the memory is cleaned up properly.
 275  */
 276 void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
 277 {
 278         char *err_str;
 279
 280         if (!kobj) {
 281                 err_str = "invalid kobject pointer!";
 282                 goto error;
 283         }
 284         if (!ktype) {
 285                 err_str = "must have a ktype to be initialized properly!\n";
 286                 goto error;
 287         }
 288         if (kobj->state_initialized) {
 289                 /* do not error out as sometimes we can recover */
 290                 printk(KERN_ERR "kobject (%p): tried to init an initialized "
 291                        "object, something is seriously wrong.\n", kobj);
 292                 dump_stack();
 293         }
 294
 295         kref_init(&kobj->kref);
 296         INIT_LIST_HEAD(&kobj->entry);
 297         kobj->ktype = ktype;
 298         kobj->state_name_set = 0;
 299         kobj->state_in_sysfs = 0;
 300         kobj->state_add_uevent_sent = 0;
 301         kobj->state_remove_uevent_sent = 0;
 302         kobj->state_initialized = 1;
 303         return;
 304
 305 error:
 306         printk(KERN_ERR "kobject (%p): %s\n", kobj, err_str);
 307         dump_stack();
 308 }
 309 EXPORT_SYMBOL(kobject_init);
 310
 311 static int kobject_add_varg(struct kobject *kobj, struct kobject *parent,
 312                             const char *fmt, va_list vargs)
 313 {
 314         va_list aq;
 315         int retval;
 316
 317         va_copy(aq, vargs);
 318         retval = kobject_set_name_vargs(kobj, fmt, aq);
 319         va_end(aq);
 320         if (retval) {
 321                 printk(KERN_ERR "kobject: can not set name properly!\n");
 322                 return retval;
 323         }
 324         kobj->parent = parent;
 325         return kobject_add_internal(kobj);
 326 }
 327
 328 /**
 329  * kobject_add - the main kobject add function
 330  * @kobj: the kobject to add
 331  * @parent: pointer to the parent of the kobject.
 332  * @fmt: format to name the kobject with.
 333  *
 334  * The kobject name is set and added to the kobject hierarchy in this
 335  * function.
 336  *
 337  * If @parent is set, then the parent of the @kobj will be set to it.
 338  * If @parent is NULL, then the parent of the @kobj will be set to the
 339  * kobject associted with the kset assigned to this kobject.  If no kset
 340  * is assigned to the kobject, then the kobject will be located in the
 341  * root of the sysfs tree.
 342  *
 343  * If this function returns an error, kobject_put() must be called to
 344  * properly clean up the memory associated with the object.
 345  * Under no instance should the kobject that is passed to this function
 346  * be directly freed with a call to kfree(), that can leak memory.
 347  *
 348  * Note, no "add" uevent will be created with this call, the caller should set
 349  * up all of the necessary sysfs files for the object and then call
 350  * kobject_uevent() with the UEVENT_ADD parameter to ensure that
 351  * userspace is properly notified of this kobject's creation.
 352  */
 353 int kobject_add(struct kobject *kobj, struct kobject *parent,
 354                 const char *fmt, ...)
 355 {
 356         va_list args;
 357         int retval;
 358
 359         if (!kobj)
 360                 return -EINVAL;
 361
 362         if (!kobj->state_initialized) {
 363                 printk(KERN_ERR "kobject '%s' (%p): tried to add an "
 364                        "uninitialized object, something is seriously wrong.\n",
 365                        kobject_name(kobj), kobj);
 366                 dump_stack();
 367                 return -EINVAL;
 368         }
 369         va_start(args, fmt);
 370         retval = kobject_add_varg(kobj, parent, fmt, args);
 371         va_end(args);
 372
 373         return retval;
 374 }
 375 EXPORT_SYMBOL(kobject_add);
 376
 377 /**
 378  * kobject_init_and_add - initialize a kobject structure and add it to the kobject hierarchy
 379  * @kobj: pointer to the kobject to initialize
 380  * @ktype: pointer to the ktype for this kobject.
 381  * @parent: pointer to the parent of this kobject.
 382  * @fmt: the name of the kobject.
 383  *
 384  * This function combines the call to kobject_init() and
 385  * kobject_add().  The same type of error handling after a call to
 386  * kobject_add() and kobject lifetime rules are the same here.
 387  */
 388 int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype,
 389                          struct kobject *parent, const char *fmt, ...)
 390 {
 391         va_list args;
 392         int retval;
 393
 394         kobject_init(kobj, ktype);
 395
 396         va_start(args, fmt);
 397         retval = kobject_add_varg(kobj, parent, fmt, args);
 398         va_end(args);
 399
 400         return retval;
 401 }
 402 EXPORT_SYMBOL_GPL(kobject_init_and_add);
 403
 404 /**
 405  *      kobject_rename - change the name of an object
 406  *      @kobj:  object in question.
 407  *      @new_name: object's new name
 408  */
 409
 410 int kobject_rename(struct kobject * kobj, const char *new_name)
 411 {
 412         int error = 0;
 413         const char *devpath = NULL;
 414         char *devpath_string = NULL;
 415         char *envp[2];
 416
 417         kobj = kobject_get(kobj);
 418         if (!kobj)
 419                 return -EINVAL;
 420         if (!kobj->parent)
 421                 return -EINVAL;
 422
 423         /* see if this name is already in use */
 424         if (kobj->kset) {
 425                 struct kobject *temp_kobj;
 426                 temp_kobj = kset_find_obj(kobj->kset, new_name);
 427                 if (temp_kobj) {
 428                         printk(KERN_WARNING "kobject '%s' cannot be renamed "
 429                                "to '%s' as '%s' is already in existence.\n",
 430                                kobject_name(kobj), new_name, new_name);
 431                         kobject_put(temp_kobj);
 432                         return -EINVAL;
 433                 }
 434         }
 435
 436         devpath = kobject_get_path(kobj, GFP_KERNEL);
 437         if (!devpath) {
 438                 error = -ENOMEM;
 439                 goto out;
 440         }
 441         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
 442         if (!devpath_string) {
 443                 error = -ENOMEM;
 444                 goto out;
 445         }
 446         sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
 447         envp[0] = devpath_string;
 448         envp[1] = NULL;
 449
 450         error = sysfs_rename_dir(kobj, new_name);
 451
 452         /* This function is mostly/only used for network interface.
 453          * Some hotplug package track interfaces by their name and
 454          * therefore want to know when the name is changed by the user. */
 455         if (!error)
 456                 kobject_uevent_env(kobj, KOBJ_MOVE, envp);
 457
 458 out:
 459         kfree(devpath_string);
 460         kfree(devpath);
 461         kobject_put(kobj);
 462
 463         return error;
 464 }
 465
 466 /**
 467  *      kobject_move - move object to another parent
 468  *      @kobj:  object in question.
 469  *      @new_parent: object's new parent (can be NULL)
 470  */
 471
 472 int kobject_move(struct kobject *kobj, struct kobject *new_parent)
 473 {
 474         int error;
 475         struct kobject *old_parent;
 476         const char *devpath = NULL;
 477         char *devpath_string = NULL;
 478         char *envp[2];
 479
 480         kobj = kobject_get(kobj);
 481         if (!kobj)
 482                 return -EINVAL;
 483         new_parent = kobject_get(new_parent);
 484         if (!new_parent) {
 485                 if (kobj->kset)
 486                         new_parent = kobject_get(&kobj->kset->kobj);
 487         }
 488         /* old object path */
 489         devpath = kobject_get_path(kobj, GFP_KERNEL);
 490         if (!devpath) {
 491                 error = -ENOMEM;
 492                 goto out;
 493         }
 494         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
 495         if (!devpath_string) {
 496                 error = -ENOMEM;
 497                 goto out;
 498         }
 499         sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
 500         envp[0] = devpath_string;
 501         envp[1] = NULL;
 502         error = sysfs_move_dir(kobj, new_parent);
 503         if (error)
 504                 goto out;
 505         old_parent = kobj->parent;
 506         kobj->parent = new_parent;
 507         new_parent = NULL;
 508         kobject_put(old_parent);
 509         kobject_uevent_env(kobj, KOBJ_MOVE, envp);
 510 out:
 511         kobject_put(new_parent);
 512         kobject_put(kobj);
 513         kfree(devpath_string);
 514         kfree(devpath);
 515         return error;
 516 }
 517
 518 /**
 519  *      kobject_del - unlink kobject from hierarchy.
 520  *      @kobj:  object.
 521  */
 522
 523 void kobject_del(struct kobject * kobj)
 524 {
 525         if (!kobj)
 526                 return;
 527
 528         sysfs_remove_dir(kobj);
 529         kobj->state_in_sysfs = 0;
 530         kobj_kset_leave(kobj);
 531         kobject_put(kobj->parent);
 532         kobj->parent = NULL;
 533 }
 534
 535 /**
 536  *      kobject_unregister - remove object from hierarchy and decrement refcount.
 537  *      @kobj:  object going away.
 538  */
 539
 540 void kobject_unregister(struct kobject * kobj)
 541 {
 542         if (!kobj)
 543                 return;
 544         pr_debug("kobject: '%s' (%p): %s\n",
 545                  kobject_name(kobj), kobj, __FUNCTION__);
 546         kobject_uevent(kobj, KOBJ_REMOVE);
 547         kobject_del(kobj);
 548         kobject_put(kobj);
 549 }
 550
 551 /**
 552  *      kobject_get - increment refcount for object.
 553  *      @kobj:  object.
 554  */
 555
 556 struct kobject * kobject_get(struct kobject * kobj)
 557 {
 558         if (kobj)
 559                 kref_get(&kobj->kref);
 560         return kobj;
 561 }
 562
 563 /*
 564  * kobject_cleanup - free kobject resources.
 565  * @kobj: object to cleanup
 566  */
 567 static void kobject_cleanup(struct kobject *kobj)
 568 {
 569         struct kobj_type *t = get_ktype(kobj);
 570         const char *name = kobj->k_name;
 571         int name_set = kobj->state_name_set;
 572
 573         pr_debug("kobject: '%s' (%p): %s\n",
 574                  kobject_name(kobj), kobj, __FUNCTION__);
 575
 576         if (t && !t->release)
 577                 pr_debug("kobject: '%s' (%p): does not have a release() "
 578                          "function, it is broken and must be fixed.\n",
 579                          kobject_name(kobj), kobj);
 580
 581         /* send "remove" if the caller did not do it but sent "add" */
 582         if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) {
 583                 pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n",
 584                          kobject_name(kobj), kobj);
 585                 kobject_uevent(kobj, KOBJ_REMOVE);
 586         }
 587
 588         /* remove from sysfs if the caller did not do it */
 589         if (kobj->state_in_sysfs) {
 590                 pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n",
 591                          kobject_name(kobj), kobj);
 592                 kobject_del(kobj);
 593         }
 594
 595         if (t && t->release) {
 596                 pr_debug("kobject: '%s' (%p): calling ktype release\n",
 597                          kobject_name(kobj), kobj);
 598                 t->release(kobj);
 599         }
 600
 601         /* free name if we allocated it */
 602         if (name_set && name) {
 603                 pr_debug("kobject: '%s': free name\n", name);
 604                 kfree(name);
 605         }
 606 }
 607
 608 static void kobject_release(struct kref *kref)
 609 {
 610         kobject_cleanup(container_of(kref, struct kobject, kref));
 611 }
 612
 613 /**
 614  *      kobject_put - decrement refcount for object.
 615  *      @kobj:  object.
 616  *
 617  *      Decrement the refcount, and if 0, call kobject_cleanup().
 618  */
 619 void kobject_put(struct kobject * kobj)
 620 {
 621         if (kobj)
 622                 kref_put(&kobj->kref, kobject_release);
 623 }
 624
 625 static void dynamic_kobj_release(struct kobject *kobj)
 626 {
 627         pr_debug("kobject: (%p): %s\n", kobj, __FUNCTION__);
 628         kfree(kobj);
 629 }
 630
 631 static struct kobj_type dynamic_kobj_ktype = {
 632         .release        = dynamic_kobj_release,
 633         .sysfs_ops      = &kobj_sysfs_ops,
 634 };
 635
 636 /**
 637  * kobject_create - create a struct kobject dynamically
 638  *
 639  * This function creates a kobject structure dynamically and sets it up
 640  * to be a "dynamic" kobject with a default release function set up.
 641  *
 642  * If the kobject was not able to be created, NULL will be returned.
 643  * The kobject structure returned from here must be cleaned up with a
 644  * call to kobject_put() and not kfree(), as kobject_init() has
 645  * already been called on this structure.
 646  */
 647 struct kobject *kobject_create(void)
 648 {
 649         struct kobject *kobj;
 650
 651         kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
 652         if (!kobj)
 653                 return NULL;
 654
 655         kobject_init(kobj, &dynamic_kobj_ktype);
 656         return kobj;
 657 }
 658
 659 /**
 660  * kobject_create_and_add - create a struct kobject dynamically and register it with sysfs
 661  *
 662  * @name: the name for the kset
 663  * @parent: the parent kobject of this kobject, if any.
 664  *
 665  * This function creates a kset structure dynamically and registers it
 666  * with sysfs.  When you are finished with this structure, call
 667  * kobject_put() and the structure will be dynamically freed when
 668  * it is no longer being used.
 669  *
 670  * If the kobject was not able to be created, NULL will be returned.
 671  */
 672 struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)
 673 {
 674         struct kobject *kobj;
 675         int retval;
 676
 677         kobj = kobject_create();
 678         if (!kobj)
 679                 return NULL;
 680
 681         retval = kobject_add(kobj, parent, "%s", name);
 682         if (retval) {
 683                 printk(KERN_WARNING "%s: kobject_add error: %d\n",
 684                        __FUNCTION__, retval);
 685                 kobject_put(kobj);
 686                 kobj = NULL;
 687         }
 688         return kobj;
 689 }
 690 EXPORT_SYMBOL_GPL(kobject_create_and_add);
 691
 692 /**
 693  *      kset_init - initialize a kset for use
 694  *      @k:     kset
 695  */
 696
 697 void kset_init(struct kset * k)
 698 {
 699         kobject_init_internal(&k->kobj);
 700         INIT_LIST_HEAD(&k->list);
 701         spin_lock_init(&k->list_lock);
 702 }
 703
 704 /* default kobject attribute operations */
 705 static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,
 706                               char *buf)
 707 {
 708         struct kobj_attribute *kattr;
 709         ssize_t ret = -EIO;
 710
 711         kattr = container_of(attr, struct kobj_attribute, attr);
 712         if (kattr->show)
 713                 ret = kattr->show(kobj, kattr, buf);
 714         return ret;
 715 }
 716
 717 static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,
 718                                const char *buf, size_t count)
 719 {
 720         struct kobj_attribute *kattr;
 721         ssize_t ret = -EIO;
 722
 723         kattr = container_of(attr, struct kobj_attribute, attr);
 724         if (kattr->store)
 725                 ret = kattr->store(kobj, kattr, buf, count);
 726         return ret;
 727 }
 728
 729 struct sysfs_ops kobj_sysfs_ops = {
 730         .show   = kobj_attr_show,
 731         .store  = kobj_attr_store,
 732 };
 733
 734 /**
 735  *      kset_register - initialize and add a kset.
 736  *      @k:     kset.
 737  */
 738
 739 int kset_register(struct kset * k)
 740 {
 741         int err;
 742
 743         if (!k)
 744                 return -EINVAL;
 745
 746         kset_init(k);
 747         err = kobject_add_internal(&k->kobj);
 748         if (err)
 749                 return err;
 750         kobject_uevent(&k->kobj, KOBJ_ADD);
 751         return 0;
 752 }
 753
 754
 755 /**
 756  *      kset_unregister - remove a kset.
 757  *      @k:     kset.
 758  */
 759
 760 void kset_unregister(struct kset * k)
 761 {
 762         if (!k)
 763                 return;
 764         kobject_put(&k->kobj);
 765 }
 766
 767
 768 /**
 769  *      kset_find_obj - search for object in kset.
 770  *      @kset:  kset we're looking in.
 771  *      @name:  object's name.
 772  *
 773  *      Lock kset via @kset->subsys, and iterate over @kset->list,
 774  *      looking for a matching kobject. If matching object is found
 775  *      take a reference and return the object.
 776  */
 777
 778 struct kobject * kset_find_obj(struct kset * kset, const char * name)
 779 {
 780         struct list_head * entry;
 781         struct kobject * ret = NULL;
 782
 783         spin_lock(&kset->list_lock);
 784         list_for_each(entry,&kset->list) {
 785                 struct kobject * k = to_kobj(entry);
 786                 if (kobject_name(k) && !strcmp(kobject_name(k),name)) {
 787                         ret = kobject_get(k);
 788                         break;
 789                 }
 790         }
 791         spin_unlock(&kset->list_lock);
 792         return ret;
 793 }
 794
 795 static void kset_release(struct kobject *kobj)
 796 {
 797         struct kset *kset = container_of(kobj, struct kset, kobj);
 798         pr_debug("kobject: '%s' (%p): %s\n",
 799                  kobject_name(kobj), kobj, __FUNCTION__);
 800         kfree(kset);
 801 }
 802
 803 static struct kobj_type kset_ktype = {
 804         .sysfs_ops      = &kobj_sysfs_ops,
 805         .release = kset_release,
 806 };
 807
 808 /**
 809  * kset_create - create a struct kset dynamically
 810  *
 811  * @name: the name for the kset
 812  * @uevent_ops: a struct kset_uevent_ops for the kset
 813  * @parent_kobj: the parent kobject of this kset, if any.
 814  *
 815  * This function creates a kset structure dynamically.  This structure can
 816  * then be registered with the system and show up in sysfs with a call to
 817  * kset_register().  When you are finished with this structure, if
 818  * kset_register() has been called, call kset_unregister() and the
 819  * structure will be dynamically freed when it is no longer being used.
 820  *
 821  * If the kset was not able to be created, NULL will be returned.
 822  */
 823 static struct kset *kset_create(const char *name,
 824                                 struct kset_uevent_ops *uevent_ops,
 825                                 struct kobject *parent_kobj)
 826 {
 827         struct kset *kset;
 828
 829         kset = kzalloc(sizeof(*kset), GFP_KERNEL);
 830         if (!kset)
 831                 return NULL;
 832         kobject_set_name(&kset->kobj, name);
 833         kset->uevent_ops = uevent_ops;
 834         kset->kobj.parent = parent_kobj;
 835
 836         /*
 837          * The kobject of this kset will have a type of kset_ktype and belong to
 838          * no kset itself.  That way we can properly free it when it is
 839          * finished being used.
 840          */
 841         kset->kobj.ktype = &kset_ktype;
 842         kset->kobj.kset = NULL;
 843
 844         return kset;
 845 }
 846
 847 /**
 848  * kset_create_and_add - create a struct kset dynamically and add it to sysfs
 849  *
 850  * @name: the name for the kset
 851  * @uevent_ops: a struct kset_uevent_ops for the kset
 852  * @parent_kobj: the parent kobject of this kset, if any.
 853  *
 854  * This function creates a kset structure dynamically and registers it
 855  * with sysfs.  When you are finished with this structure, call
 856  * kset_unregister() and the structure will be dynamically freed when it
 857  * is no longer being used.
 858  *
 859  * If the kset was not able to be created, NULL will be returned.
 860  */
 861 struct kset *kset_create_and_add(const char *name,
 862                                  struct kset_uevent_ops *uevent_ops,
 863                                  struct kobject *parent_kobj)
 864 {
 865         struct kset *kset;
 866         int error;
 867
 868         kset = kset_create(name, uevent_ops, parent_kobj);
 869         if (!kset)
 870                 return NULL;
 871         error = kset_register(kset);
 872         if (error) {
 873                 kfree(kset);
 874                 return NULL;
 875         }
 876         return kset;
 877 }
 878 EXPORT_SYMBOL_GPL(kset_create_and_add);
 879
 880 EXPORT_SYMBOL(kobject_unregister);
 881 EXPORT_SYMBOL(kobject_get);
 882 EXPORT_SYMBOL(kobject_put);
 883 EXPORT_SYMBOL(kobject_del);
 884
 885 EXPORT_SYMBOL(kset_register);
 886 EXPORT_SYMBOL(kset_unregister);