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