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