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/export.h> 18#include <linux/stat.h> 19#include <linux/slab.h> 20#include <linux/random.h> 21 22/** 23 * kobject_namespace - return @kobj's namespace tag 24 * @kobj: kobject in question 25 * 26 * Returns namespace tag of @kobj if its parent has namespace ops enabled 27 * and thus @kobj should have a namespace tag associated with it. Returns 28 * %NULL otherwise. 29 */ 30const void *kobject_namespace(struct kobject *kobj) 31{ 32 const struct kobj_ns_type_operations *ns_ops = kobj_ns_ops(kobj); 33 34 if (!ns_ops || ns_ops->type == KOBJ_NS_TYPE_NONE) 35 return NULL; 36 37 return kobj->ktype->namespace(kobj); 38} 39 40/* 41 * populate_dir - populate directory with attributes. 42 * @kobj: object we're working on. 43 * 44 * Most subsystems have a set of default attributes that are associated 45 * with an object that registers with them. This is a helper called during 46 * object registration that loops through the default attributes of the 47 * subsystem and creates attributes files for them in sysfs. 48 */ 49static int populate_dir(struct kobject *kobj) 50{ 51 struct kobj_type *t = get_ktype(kobj); 52 struct attribute *attr; 53 int error = 0; 54 int i; 55 56 if (t && t->default_attrs) { 57 for (i = 0; (attr = t->default_attrs[i]) != NULL; i++) { 58 error = sysfs_create_file(kobj, attr); 59 if (error) 60 break; 61 } 62 } 63 return error; 64} 65 66static int create_dir(struct kobject *kobj) 67{ 68 const struct kobj_ns_type_operations *ops; 69 int error; 70 71 error = sysfs_create_dir_ns(kobj, kobject_namespace(kobj)); 72 if (error) 73 return error; 74 75 error = populate_dir(kobj); 76 if (error) { 77 sysfs_remove_dir(kobj); 78 return error; 79 } 80 81 /* 82 * @kobj->sd may be deleted by an ancestor going away. Hold an 83 * extra reference so that it stays until @kobj is gone. 84 */ 85 sysfs_get(kobj->sd); 86 87 /* 88 * If @kobj has ns_ops, its children need to be filtered based on 89 * their namespace tags. Enable namespace support on @kobj->sd. 90 */ 91 ops = kobj_child_ns_ops(kobj); 92 if (ops) { 93 BUG_ON(ops->type <= KOBJ_NS_TYPE_NONE); 94 BUG_ON(ops->type >= KOBJ_NS_TYPES); 95 BUG_ON(!kobj_ns_type_registered(ops->type)); 96 97 sysfs_enable_ns(kobj->sd); 98 } 99 100 return 0; 101} 102 103static int get_kobj_path_length(struct kobject *kobj) 104{ 105 int length = 1; 106 struct kobject *parent = kobj; 107 108 /* walk up the ancestors until we hit the one pointing to the 109 * root. 110 * Add 1 to strlen for leading '/' of each level. 111 */ 112 do { 113 if (kobject_name(parent) == NULL) 114 return 0; 115 length += strlen(kobject_name(parent)) + 1; 116 parent = parent->parent; 117 } while (parent); 118 return length; 119} 120 121static void fill_kobj_path(struct kobject *kobj, char *path, int length) 122{ 123 struct kobject *parent; 124 125 --length; 126 for (parent = kobj; parent; parent = parent->parent) { 127 int cur = strlen(kobject_name(parent)); 128 /* back up enough to print this name with '/' */ 129 length -= cur; 130 strncpy(path + length, kobject_name(parent), cur); 131 *(path + --length) = '/'; 132 } 133 134 pr_debug("kobject: '%s' (%p): %s: path = '%s'\n", kobject_name(kobj), 135 kobj, __func__, path); 136} 137 138/** 139 * kobject_get_path - generate and return the path associated with a given kobj and kset pair. 140 * 141 * @kobj: kobject in question, with which to build the path 142 * @gfp_mask: the allocation type used to allocate the path 143 * 144 * The result must be freed by the caller with kfree(). 145 */ 146char *kobject_get_path(struct kobject *kobj, gfp_t gfp_mask) 147{ 148 char *path; 149 int len; 150 151 len = get_kobj_path_length(kobj); 152 if (len == 0) 153 return NULL; 154 path = kzalloc(len, gfp_mask); 155 if (!path) 156 return NULL; 157 fill_kobj_path(kobj, path, len); 158 159 return path; 160} 161EXPORT_SYMBOL_GPL(kobject_get_path); 162 163/* add the kobject to its kset's list */ 164static void kobj_kset_join(struct kobject *kobj) 165{ 166 if (!kobj->kset) 167 return; 168 169 kset_get(kobj->kset); 170 spin_lock(&kobj->kset->list_lock); 171 list_add_tail(&kobj->entry, &kobj->kset->list); 172 spin_unlock(&kobj->kset->list_lock); 173} 174 175/* remove the kobject from its kset's list */ 176static void kobj_kset_leave(struct kobject *kobj) 177{ 178 if (!kobj->kset) 179 return; 180 181 spin_lock(&kobj->kset->list_lock); 182 list_del_init(&kobj->entry); 183 spin_unlock(&kobj->kset->list_lock); 184 kset_put(kobj->kset); 185} 186 187static void kobject_init_internal(struct kobject *kobj) 188{ 189 if (!kobj) 190 return; 191 kref_init(&kobj->kref); 192 INIT_LIST_HEAD(&kobj->entry); 193 kobj->state_in_sysfs = 0; 194 kobj->state_add_uevent_sent = 0; 195 kobj->state_remove_uevent_sent = 0; 196 kobj->state_initialized = 1; 197} 198 199 200static int kobject_add_internal(struct kobject *kobj) 201{ 202 int error = 0; 203 struct kobject *parent; 204 205 if (!kobj) 206 return -ENOENT; 207 208 if (!kobj->name || !kobj->name[0]) { 209 WARN(1, "kobject: (%p): attempted to be registered with empty " 210 "name!\n", kobj); 211 return -EINVAL; 212 } 213 214 parent = kobject_get(kobj->parent); 215 216 /* join kset if set, use it as parent if we do not already have one */ 217 if (kobj->kset) { 218 if (!parent) 219 parent = kobject_get(&kobj->kset->kobj); 220 kobj_kset_join(kobj); 221 kobj->parent = parent; 222 } 223 224 pr_debug("kobject: '%s' (%p): %s: parent: '%s', set: '%s'\n", 225 kobject_name(kobj), kobj, __func__, 226 parent ? kobject_name(parent) : "<NULL>", 227 kobj->kset ? kobject_name(&kobj->kset->kobj) : "<NULL>"); 228 229 error = create_dir(kobj); 230 if (error) { 231 kobj_kset_leave(kobj); 232 kobject_put(parent); 233 kobj->parent = NULL; 234 235 /* be noisy on error issues */ 236 if (error == -EEXIST) 237 WARN(1, "%s failed for %s with " 238 "-EEXIST, don't try to register things with " 239 "the same name in the same directory.\n", 240 __func__, kobject_name(kobj)); 241 else 242 WARN(1, "%s failed for %s (error: %d parent: %s)\n", 243 __func__, kobject_name(kobj), error, 244 parent ? kobject_name(parent) : "'none'"); 245 } else 246 kobj->state_in_sysfs = 1; 247 248 return error; 249} 250 251/** 252 * kobject_set_name_vargs - Set the name of an kobject 253 * @kobj: struct kobject to set the name of 254 * @fmt: format string used to build the name 255 * @vargs: vargs to format the string. 256 */ 257int kobject_set_name_vargs(struct kobject *kobj, const char *fmt, 258 va_list vargs) 259{ 260 const char *old_name = kobj->name; 261 char *s; 262 263 if (kobj->name && !fmt) 264 return 0; 265 266 kobj->name = kvasprintf(GFP_KERNEL, fmt, vargs); 267 if (!kobj->name) { 268 kobj->name = old_name; 269 return -ENOMEM; 270 } 271 272 /* ewww... some of these buggers have '/' in the name ... */ 273 while ((s = strchr(kobj->name, '/'))) 274 s[0] = '!'; 275 276 kfree(old_name); 277 return 0; 278} 279 280/** 281 * kobject_set_name - Set the name of a kobject 282 * @kobj: struct kobject to set the name of 283 * @fmt: format string used to build the name 284 * 285 * This sets the name of the kobject. If you have already added the 286 * kobject to the system, you must call kobject_rename() in order to 287 * change the name of the kobject. 288 */ 289int kobject_set_name(struct kobject *kobj, const char *fmt, ...) 290{ 291 va_list vargs; 292 int retval; 293 294 va_start(vargs, fmt); 295 retval = kobject_set_name_vargs(kobj, fmt, vargs); 296 va_end(vargs); 297 298 return retval; 299} 300EXPORT_SYMBOL(kobject_set_name); 301 302/** 303 * kobject_init - initialize a kobject structure 304 * @kobj: pointer to the kobject to initialize 305 * @ktype: pointer to the ktype for this kobject. 306 * 307 * This function will properly initialize a kobject such that it can then 308 * be passed to the kobject_add() call. 309 * 310 * After this function is called, the kobject MUST be cleaned up by a call 311 * to kobject_put(), not by a call to kfree directly to ensure that all of 312 * the memory is cleaned up properly. 313 */ 314void kobject_init(struct kobject *kobj, struct kobj_type *ktype) 315{ 316 char *err_str; 317 318 if (!kobj) { 319 err_str = "invalid kobject pointer!"; 320 goto error; 321 } 322 if (!ktype) { 323 err_str = "must have a ktype to be initialized properly!\n"; 324 goto error; 325 } 326 if (kobj->state_initialized) { 327 /* do not error out as sometimes we can recover */ 328 printk(KERN_ERR "kobject (%p): tried to init an initialized " 329 "object, something is seriously wrong.\n", kobj); 330 dump_stack(); 331 } 332 333 kobject_init_internal(kobj); 334 kobj->ktype = ktype; 335 return; 336 337error: 338 printk(KERN_ERR "kobject (%p): %s\n", kobj, err_str); 339 dump_stack(); 340} 341EXPORT_SYMBOL(kobject_init); 342 343static int kobject_add_varg(struct kobject *kobj, struct kobject *parent, 344 const char *fmt, va_list vargs) 345{ 346 int retval; 347 348 retval = kobject_set_name_vargs(kobj, fmt, vargs); 349 if (retval) { 350 printk(KERN_ERR "kobject: can not set name properly!\n"); 351 return retval; 352 } 353 kobj->parent = parent; 354 return kobject_add_internal(kobj); 355} 356 357/** 358 * kobject_add - the main kobject add function 359 * @kobj: the kobject to add 360 * @parent: pointer to the parent of the kobject. 361 * @fmt: format to name the kobject with. 362 * 363 * The kobject name is set and added to the kobject hierarchy in this 364 * function. 365 * 366 * If @parent is set, then the parent of the @kobj will be set to it. 367 * If @parent is NULL, then the parent of the @kobj will be set to the 368 * kobject associated with the kset assigned to this kobject. If no kset 369 * is assigned to the kobject, then the kobject will be located in the 370 * root of the sysfs tree. 371 * 372 * If this function returns an error, kobject_put() must be called to 373 * properly clean up the memory associated with the object. 374 * Under no instance should the kobject that is passed to this function 375 * be directly freed with a call to kfree(), that can leak memory. 376 * 377 * Note, no "add" uevent will be created with this call, the caller should set 378 * up all of the necessary sysfs files for the object and then call 379 * kobject_uevent() with the UEVENT_ADD parameter to ensure that 380 * userspace is properly notified of this kobject's creation. 381 */ 382int kobject_add(struct kobject *kobj, struct kobject *parent, 383 const char *fmt, ...) 384{ 385 va_list args; 386 int retval; 387 388 if (!kobj) 389 return -EINVAL; 390 391 if (!kobj->state_initialized) { 392 printk(KERN_ERR "kobject '%s' (%p): tried to add an " 393 "uninitialized object, something is seriously wrong.\n", 394 kobject_name(kobj), kobj); 395 dump_stack(); 396 return -EINVAL; 397 } 398 va_start(args, fmt); 399 retval = kobject_add_varg(kobj, parent, fmt, args); 400 va_end(args); 401 402 return retval; 403} 404EXPORT_SYMBOL(kobject_add); 405 406/** 407 * kobject_init_and_add - initialize a kobject structure and add it to the kobject hierarchy 408 * @kobj: pointer to the kobject to initialize 409 * @ktype: pointer to the ktype for this kobject. 410 * @parent: pointer to the parent of this kobject. 411 * @fmt: the name of the kobject. 412 * 413 * This function combines the call to kobject_init() and 414 * kobject_add(). The same type of error handling after a call to 415 * kobject_add() and kobject lifetime rules are the same here. 416 */ 417int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype, 418 struct kobject *parent, const char *fmt, ...) 419{ 420 va_list args; 421 int retval; 422 423 kobject_init(kobj, ktype); 424 425 va_start(args, fmt); 426 retval = kobject_add_varg(kobj, parent, fmt, args); 427 va_end(args); 428 429 return retval; 430} 431EXPORT_SYMBOL_GPL(kobject_init_and_add); 432 433/** 434 * kobject_rename - change the name of an object 435 * @kobj: object in question. 436 * @new_name: object's new name 437 * 438 * It is the responsibility of the caller to provide mutual 439 * exclusion between two different calls of kobject_rename 440 * on the same kobject and to ensure that new_name is valid and 441 * won't conflict with other kobjects. 442 */ 443int kobject_rename(struct kobject *kobj, const char *new_name) 444{ 445 int error = 0; 446 const char *devpath = NULL; 447 const char *dup_name = NULL, *name; 448 char *devpath_string = NULL; 449 char *envp[2]; 450 451 kobj = kobject_get(kobj); 452 if (!kobj) 453 return -EINVAL; 454 if (!kobj->parent) 455 return -EINVAL; 456 457 devpath = kobject_get_path(kobj, GFP_KERNEL); 458 if (!devpath) { 459 error = -ENOMEM; 460 goto out; 461 } 462 devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL); 463 if (!devpath_string) { 464 error = -ENOMEM; 465 goto out; 466 } 467 sprintf(devpath_string, "DEVPATH_OLD=%s", devpath); 468 envp[0] = devpath_string; 469 envp[1] = NULL; 470 471 name = dup_name = kstrdup(new_name, GFP_KERNEL); 472 if (!name) { 473 error = -ENOMEM; 474 goto out; 475 } 476 477 error = sysfs_rename_dir_ns(kobj, new_name, kobject_namespace(kobj)); 478 if (error) 479 goto out; 480 481 /* Install the new kobject name */ 482 dup_name = kobj->name; 483 kobj->name = name; 484 485 /* This function is mostly/only used for network interface. 486 * Some hotplug package track interfaces by their name and 487 * therefore want to know when the name is changed by the user. */ 488 kobject_uevent_env(kobj, KOBJ_MOVE, envp); 489 490out: 491 kfree(dup_name); 492 kfree(devpath_string); 493 kfree(devpath); 494 kobject_put(kobj); 495 496 return error; 497} 498EXPORT_SYMBOL_GPL(kobject_rename); 499 500/** 501 * kobject_move - move object to another parent 502 * @kobj: object in question. 503 * @new_parent: object's new parent (can be NULL) 504 */ 505int kobject_move(struct kobject *kobj, struct kobject *new_parent) 506{ 507 int error; 508 struct kobject *old_parent; 509 const char *devpath = NULL; 510 char *devpath_string = NULL; 511 char *envp[2]; 512 513 kobj = kobject_get(kobj); 514 if (!kobj) 515 return -EINVAL; 516 new_parent = kobject_get(new_parent); 517 if (!new_parent) { 518 if (kobj->kset) 519 new_parent = kobject_get(&kobj->kset->kobj); 520 } 521 522 /* old object path */ 523 devpath = kobject_get_path(kobj, GFP_KERNEL); 524 if (!devpath) { 525 error = -ENOMEM; 526 goto out; 527 } 528 devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL); 529 if (!devpath_string) { 530 error = -ENOMEM; 531 goto out; 532 } 533 sprintf(devpath_string, "DEVPATH_OLD=%s", devpath); 534 envp[0] = devpath_string; 535 envp[1] = NULL; 536 error = sysfs_move_dir_ns(kobj, new_parent, kobject_namespace(kobj)); 537 if (error) 538 goto out; 539 old_parent = kobj->parent; 540 kobj->parent = new_parent; 541 new_parent = NULL; 542 kobject_put(old_parent); 543 kobject_uevent_env(kobj, KOBJ_MOVE, envp); 544out: 545 kobject_put(new_parent); 546 kobject_put(kobj); 547 kfree(devpath_string); 548 kfree(devpath); 549 return error; 550} 551 552/** 553 * kobject_del - unlink kobject from hierarchy. 554 * @kobj: object. 555 */ 556void kobject_del(struct kobject *kobj) 557{ 558 struct kernfs_node *sd; 559 560 if (!kobj) 561 return; 562 563 sd = kobj->sd; 564 sysfs_remove_dir(kobj); 565 sysfs_put(sd); 566 567 kobj->state_in_sysfs = 0; 568 kobj_kset_leave(kobj); 569 kobject_put(kobj->parent); 570 kobj->parent = NULL; 571} 572 573/** 574 * kobject_get - increment refcount for object. 575 * @kobj: object. 576 */ 577struct kobject *kobject_get(struct kobject *kobj) 578{ 579 if (kobj) { 580 if (!kobj->state_initialized) 581 WARN(1, KERN_WARNING "kobject: '%s' (%p): is not " 582 "initialized, yet kobject_get() is being " 583 "called.\n", kobject_name(kobj), kobj); 584 kref_get(&kobj->kref); 585 } 586 return kobj; 587} 588 589static struct kobject * __must_check kobject_get_unless_zero(struct kobject *kobj) 590{ 591 if (!kref_get_unless_zero(&kobj->kref)) 592 kobj = NULL; 593 return kobj; 594} 595 596/* 597 * kobject_cleanup - free kobject resources. 598 * @kobj: object to cleanup 599 */ 600static void kobject_cleanup(struct kobject *kobj) 601{ 602 struct kobj_type *t = get_ktype(kobj); 603 const char *name = kobj->name; 604 605 pr_debug("kobject: '%s' (%p): %s, parent %p\n", 606 kobject_name(kobj), kobj, __func__, kobj->parent); 607 608 if (t && !t->release) 609 pr_debug("kobject: '%s' (%p): does not have a release() " 610 "function, it is broken and must be fixed.\n", 611 kobject_name(kobj), kobj); 612 613 /* send "remove" if the caller did not do it but sent "add" */ 614 if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) { 615 pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n", 616 kobject_name(kobj), kobj); 617 kobject_uevent(kobj, KOBJ_REMOVE); 618 } 619 620 /* remove from sysfs if the caller did not do it */ 621 if (kobj->state_in_sysfs) { 622 pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n", 623 kobject_name(kobj), kobj); 624 kobject_del(kobj); 625 } 626 627 if (t && t->release) { 628 pr_debug("kobject: '%s' (%p): calling ktype release\n", 629 kobject_name(kobj), kobj); 630 t->release(kobj); 631 } 632 633 /* free name if we allocated it */ 634 if (name) { 635 pr_debug("kobject: '%s': free name\n", name); 636 kfree(name); 637 } 638} 639 640#ifdef CONFIG_DEBUG_KOBJECT_RELEASE 641static void kobject_delayed_cleanup(struct work_struct *work) 642{ 643 kobject_cleanup(container_of(to_delayed_work(work), 644 struct kobject, release)); 645} 646#endif 647 648static void kobject_release(struct kref *kref) 649{ 650 struct kobject *kobj = container_of(kref, struct kobject, kref); 651#ifdef CONFIG_DEBUG_KOBJECT_RELEASE 652 unsigned long delay = HZ + HZ * (get_random_int() & 0x3); 653 pr_info("kobject: '%s' (%p): %s, parent %p (delayed %ld)\n", 654 kobject_name(kobj), kobj, __func__, kobj->parent, delay); 655 INIT_DELAYED_WORK(&kobj->release, kobject_delayed_cleanup); 656 657 schedule_delayed_work(&kobj->release, delay); 658#else 659 kobject_cleanup(kobj); 660#endif 661} 662 663/** 664 * kobject_put - decrement refcount for object. 665 * @kobj: object. 666 * 667 * Decrement the refcount, and if 0, call kobject_cleanup(). 668 */ 669void kobject_put(struct kobject *kobj) 670{ 671 if (kobj) { 672 if (!kobj->state_initialized) 673 WARN(1, KERN_WARNING "kobject: '%s' (%p): is not " 674 "initialized, yet kobject_put() is being " 675 "called.\n", kobject_name(kobj), kobj); 676 kref_put(&kobj->kref, kobject_release); 677 } 678} 679 680static void dynamic_kobj_release(struct kobject *kobj) 681{ 682 pr_debug("kobject: (%p): %s\n", kobj, __func__); 683 kfree(kobj); 684} 685 686static struct kobj_type dynamic_kobj_ktype = { 687 .release = dynamic_kobj_release, 688 .sysfs_ops = &kobj_sysfs_ops, 689}; 690 691/** 692 * kobject_create - create a struct kobject dynamically 693 * 694 * This function creates a kobject structure dynamically and sets it up 695 * to be a "dynamic" kobject with a default release function set up. 696 * 697 * If the kobject was not able to be created, NULL will be returned. 698 * The kobject structure returned from here must be cleaned up with a 699 * call to kobject_put() and not kfree(), as kobject_init() has 700 * already been called on this structure. 701 */ 702struct kobject *kobject_create(void) 703{ 704 struct kobject *kobj; 705 706 kobj = kzalloc(sizeof(*kobj), GFP_KERNEL); 707 if (!kobj) 708 return NULL; 709 710 kobject_init(kobj, &dynamic_kobj_ktype); 711 return kobj; 712} 713 714/** 715 * kobject_create_and_add - create a struct kobject dynamically and register it with sysfs 716 * 717 * @name: the name for the kobject 718 * @parent: the parent kobject of this kobject, if any. 719 * 720 * This function creates a kobject structure dynamically and registers it 721 * with sysfs. When you are finished with this structure, call 722 * kobject_put() and the structure will be dynamically freed when 723 * it is no longer being used. 724 * 725 * If the kobject was not able to be created, NULL will be returned. 726 */ 727struct kobject *kobject_create_and_add(const char *name, struct kobject *parent) 728{ 729 struct kobject *kobj; 730 int retval; 731 732 kobj = kobject_create(); 733 if (!kobj) 734 return NULL; 735 736 retval = kobject_add(kobj, parent, "%s", name); 737 if (retval) { 738 printk(KERN_WARNING "%s: kobject_add error: %d\n", 739 __func__, retval); 740 kobject_put(kobj); 741 kobj = NULL; 742 } 743 return kobj; 744} 745EXPORT_SYMBOL_GPL(kobject_create_and_add); 746 747/** 748 * kset_init - initialize a kset for use 749 * @k: kset 750 */ 751void kset_init(struct kset *k) 752{ 753 kobject_init_internal(&k->kobj); 754 INIT_LIST_HEAD(&k->list); 755 spin_lock_init(&k->list_lock); 756} 757 758/* default kobject attribute operations */ 759static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr, 760 char *buf) 761{ 762 struct kobj_attribute *kattr; 763 ssize_t ret = -EIO; 764 765 kattr = container_of(attr, struct kobj_attribute, attr); 766 if (kattr->show) 767 ret = kattr->show(kobj, kattr, buf); 768 return ret; 769} 770 771static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr, 772 const char *buf, size_t count) 773{ 774 struct kobj_attribute *kattr; 775 ssize_t ret = -EIO; 776 777 kattr = container_of(attr, struct kobj_attribute, attr); 778 if (kattr->store) 779 ret = kattr->store(kobj, kattr, buf, count); 780 return ret; 781} 782 783const struct sysfs_ops kobj_sysfs_ops = { 784 .show = kobj_attr_show, 785 .store = kobj_attr_store, 786}; 787EXPORT_SYMBOL_GPL(kobj_sysfs_ops); 788 789/** 790 * kset_register - initialize and add a kset. 791 * @k: kset. 792 */ 793int kset_register(struct kset *k) 794{ 795 int err; 796 797 if (!k) 798 return -EINVAL; 799 800 kset_init(k); 801 err = kobject_add_internal(&k->kobj); 802 if (err) 803 return err; 804 kobject_uevent(&k->kobj, KOBJ_ADD); 805 return 0; 806} 807 808/** 809 * kset_unregister - remove a kset. 810 * @k: kset. 811 */ 812void kset_unregister(struct kset *k) 813{ 814 if (!k) 815 return; 816 kobject_del(&k->kobj); 817 kobject_put(&k->kobj); 818} 819 820/** 821 * kset_find_obj - search for object in kset. 822 * @kset: kset we're looking in. 823 * @name: object's name. 824 * 825 * Lock kset via @kset->subsys, and iterate over @kset->list, 826 * looking for a matching kobject. If matching object is found 827 * take a reference and return the object. 828 */ 829struct kobject *kset_find_obj(struct kset *kset, const char *name) 830{ 831 struct kobject *k; 832 struct kobject *ret = NULL; 833 834 spin_lock(&kset->list_lock); 835 836 list_for_each_entry(k, &kset->list, entry) { 837 if (kobject_name(k) && !strcmp(kobject_name(k), name)) { 838 ret = kobject_get_unless_zero(k); 839 break; 840 } 841 } 842 843 spin_unlock(&kset->list_lock); 844 return ret; 845} 846 847static void kset_release(struct kobject *kobj) 848{ 849 struct kset *kset = container_of(kobj, struct kset, kobj); 850 pr_debug("kobject: '%s' (%p): %s\n", 851 kobject_name(kobj), kobj, __func__); 852 kfree(kset); 853} 854 855static struct kobj_type kset_ktype = { 856 .sysfs_ops = &kobj_sysfs_ops, 857 .release = kset_release, 858}; 859 860/** 861 * kset_create - create a struct kset dynamically 862 * 863 * @name: the name for the kset 864 * @uevent_ops: a struct kset_uevent_ops for the kset 865 * @parent_kobj: the parent kobject of this kset, if any. 866 * 867 * This function creates a kset structure dynamically. This structure can 868 * then be registered with the system and show up in sysfs with a call to 869 * kset_register(). When you are finished with this structure, if 870 * kset_register() has been called, call kset_unregister() and the 871 * structure will be dynamically freed when it is no longer being used. 872 * 873 * If the kset was not able to be created, NULL will be returned. 874 */ 875static struct kset *kset_create(const char *name, 876 const struct kset_uevent_ops *uevent_ops, 877 struct kobject *parent_kobj) 878{ 879 struct kset *kset; 880 int retval; 881 882 kset = kzalloc(sizeof(*kset), GFP_KERNEL); 883 if (!kset) 884 return NULL; 885 retval = kobject_set_name(&kset->kobj, "%s", name); 886 if (retval) { 887 kfree(kset); 888 return NULL; 889 } 890 kset->uevent_ops = uevent_ops; 891 kset->kobj.parent = parent_kobj; 892 893 /* 894 * The kobject of this kset will have a type of kset_ktype and belong to 895 * no kset itself. That way we can properly free it when it is 896 * finished being used. 897 */ 898 kset->kobj.ktype = &kset_ktype; 899 kset->kobj.kset = NULL; 900 901 return kset; 902} 903 904/** 905 * kset_create_and_add - create a struct kset dynamically and add it to sysfs 906 * 907 * @name: the name for the kset 908 * @uevent_ops: a struct kset_uevent_ops for the kset 909 * @parent_kobj: the parent kobject of this kset, if any. 910 * 911 * This function creates a kset structure dynamically and registers it 912 * with sysfs. When you are finished with this structure, call 913 * kset_unregister() and the structure will be dynamically freed when it 914 * is no longer being used. 915 * 916 * If the kset was not able to be created, NULL will be returned. 917 */ 918struct kset *kset_create_and_add(const char *name, 919 const struct kset_uevent_ops *uevent_ops, 920 struct kobject *parent_kobj) 921{ 922 struct kset *kset; 923 int error; 924 925 kset = kset_create(name, uevent_ops, parent_kobj); 926 if (!kset) 927 return NULL; 928 error = kset_register(kset); 929 if (error) { 930 kfree(kset); 931 return NULL; 932 } 933 return kset; 934} 935EXPORT_SYMBOL_GPL(kset_create_and_add); 936 937 938static DEFINE_SPINLOCK(kobj_ns_type_lock); 939static const struct kobj_ns_type_operations *kobj_ns_ops_tbl[KOBJ_NS_TYPES]; 940 941int kobj_ns_type_register(const struct kobj_ns_type_operations *ops) 942{ 943 enum kobj_ns_type type = ops->type; 944 int error; 945 946 spin_lock(&kobj_ns_type_lock); 947 948 error = -EINVAL; 949 if (type >= KOBJ_NS_TYPES) 950 goto out; 951 952 error = -EINVAL; 953 if (type <= KOBJ_NS_TYPE_NONE) 954 goto out; 955 956 error = -EBUSY; 957 if (kobj_ns_ops_tbl[type]) 958 goto out; 959 960 error = 0; 961 kobj_ns_ops_tbl[type] = ops; 962 963out: 964 spin_unlock(&kobj_ns_type_lock); 965 return error; 966} 967 968int kobj_ns_type_registered(enum kobj_ns_type type) 969{ 970 int registered = 0; 971 972 spin_lock(&kobj_ns_type_lock); 973 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES)) 974 registered = kobj_ns_ops_tbl[type] != NULL; 975 spin_unlock(&kobj_ns_type_lock); 976 977 return registered; 978} 979 980const struct kobj_ns_type_operations *kobj_child_ns_ops(struct kobject *parent) 981{ 982 const struct kobj_ns_type_operations *ops = NULL; 983 984 if (parent && parent->ktype && parent->ktype->child_ns_type) 985 ops = parent->ktype->child_ns_type(parent); 986 987 return ops; 988} 989 990const struct kobj_ns_type_operations *kobj_ns_ops(struct kobject *kobj) 991{ 992 return kobj_child_ns_ops(kobj->parent); 993} 994 995bool kobj_ns_current_may_mount(enum kobj_ns_type type) 996{ 997 bool may_mount = true; 998 999 spin_lock(&kobj_ns_type_lock); 1000 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) && 1001 kobj_ns_ops_tbl[type]) 1002 may_mount = kobj_ns_ops_tbl[type]->current_may_mount(); 1003 spin_unlock(&kobj_ns_type_lock); 1004 1005 return may_mount; 1006} 1007 1008void *kobj_ns_grab_current(enum kobj_ns_type type) 1009{ 1010 void *ns = NULL; 1011 1012 spin_lock(&kobj_ns_type_lock); 1013 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) && 1014 kobj_ns_ops_tbl[type]) 1015 ns = kobj_ns_ops_tbl[type]->grab_current_ns(); 1016 spin_unlock(&kobj_ns_type_lock); 1017 1018 return ns; 1019} 1020 1021const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk) 1022{ 1023 const void *ns = NULL; 1024 1025 spin_lock(&kobj_ns_type_lock); 1026 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) && 1027 kobj_ns_ops_tbl[type]) 1028 ns = kobj_ns_ops_tbl[type]->netlink_ns(sk); 1029 spin_unlock(&kobj_ns_type_lock); 1030 1031 return ns; 1032} 1033 1034const void *kobj_ns_initial(enum kobj_ns_type type) 1035{ 1036 const void *ns = NULL; 1037 1038 spin_lock(&kobj_ns_type_lock); 1039 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) && 1040 kobj_ns_ops_tbl[type]) 1041 ns = kobj_ns_ops_tbl[type]->initial_ns(); 1042 spin_unlock(&kobj_ns_type_lock); 1043 1044 return ns; 1045} 1046 1047void kobj_ns_drop(enum kobj_ns_type type, void *ns) 1048{ 1049 spin_lock(&kobj_ns_type_lock); 1050 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) && 1051 kobj_ns_ops_tbl[type] && kobj_ns_ops_tbl[type]->drop_ns) 1052 kobj_ns_ops_tbl[type]->drop_ns(ns); 1053 spin_unlock(&kobj_ns_type_lock); 1054} 1055 1056EXPORT_SYMBOL(kobject_get); 1057EXPORT_SYMBOL(kobject_put); 1058EXPORT_SYMBOL(kobject_del); 1059 1060EXPORT_SYMBOL(kset_register); 1061EXPORT_SYMBOL(kset_unregister); 1062