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 */ 30 const 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 */ 49 static 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 66 static 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 103 static 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 121 static 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 */ 146 char *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 } 161 EXPORT_SYMBOL_GPL(kobject_get_path); 162 163 /* add the kobject to its kset's list */ 164 static 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 */ 176 static 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 187 static 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 200 static 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 */ 257 int kobject_set_name_vargs(struct kobject *kobj, const char *fmt, 258 va_list vargs) 259 { 260 char *s; 261 262 if (kobj->name && !fmt) 263 return 0; 264 265 s = kvasprintf(GFP_KERNEL, fmt, vargs); 266 if (!s) 267 return -ENOMEM; 268 269 /* ewww... some of these buggers have '/' in the name ... */ 270 strreplace(s, '/', '!'); 271 kfree(kobj->name); 272 kobj->name = s; 273 274 return 0; 275 } 276 277 /** 278 * kobject_set_name - Set the name of a kobject 279 * @kobj: struct kobject to set the name of 280 * @fmt: format string used to build the name 281 * 282 * This sets the name of the kobject. If you have already added the 283 * kobject to the system, you must call kobject_rename() in order to 284 * change the name of the kobject. 285 */ 286 int kobject_set_name(struct kobject *kobj, const char *fmt, ...) 287 { 288 va_list vargs; 289 int retval; 290 291 va_start(vargs, fmt); 292 retval = kobject_set_name_vargs(kobj, fmt, vargs); 293 va_end(vargs); 294 295 return retval; 296 } 297 EXPORT_SYMBOL(kobject_set_name); 298 299 /** 300 * kobject_init - initialize a kobject structure 301 * @kobj: pointer to the kobject to initialize 302 * @ktype: pointer to the ktype for this kobject. 303 * 304 * This function will properly initialize a kobject such that it can then 305 * be passed to the kobject_add() call. 306 * 307 * After this function is called, the kobject MUST be cleaned up by a call 308 * to kobject_put(), not by a call to kfree directly to ensure that all of 309 * the memory is cleaned up properly. 310 */ 311 void kobject_init(struct kobject *kobj, struct kobj_type *ktype) 312 { 313 char *err_str; 314 315 if (!kobj) { 316 err_str = "invalid kobject pointer!"; 317 goto error; 318 } 319 if (!ktype) { 320 err_str = "must have a ktype to be initialized properly!\n"; 321 goto error; 322 } 323 if (kobj->state_initialized) { 324 /* do not error out as sometimes we can recover */ 325 printk(KERN_ERR "kobject (%p): tried to init an initialized " 326 "object, something is seriously wrong.\n", kobj); 327 dump_stack(); 328 } 329 330 kobject_init_internal(kobj); 331 kobj->ktype = ktype; 332 return; 333 334 error: 335 printk(KERN_ERR "kobject (%p): %s\n", kobj, err_str); 336 dump_stack(); 337 } 338 EXPORT_SYMBOL(kobject_init); 339 340 static int kobject_add_varg(struct kobject *kobj, struct kobject *parent, 341 const char *fmt, va_list vargs) 342 { 343 int retval; 344 345 retval = kobject_set_name_vargs(kobj, fmt, vargs); 346 if (retval) { 347 printk(KERN_ERR "kobject: can not set name properly!\n"); 348 return retval; 349 } 350 kobj->parent = parent; 351 return kobject_add_internal(kobj); 352 } 353 354 /** 355 * kobject_add - the main kobject add function 356 * @kobj: the kobject to add 357 * @parent: pointer to the parent of the kobject. 358 * @fmt: format to name the kobject with. 359 * 360 * The kobject name is set and added to the kobject hierarchy in this 361 * function. 362 * 363 * If @parent is set, then the parent of the @kobj will be set to it. 364 * If @parent is NULL, then the parent of the @kobj will be set to the 365 * kobject associated with the kset assigned to this kobject. If no kset 366 * is assigned to the kobject, then the kobject will be located in the 367 * root of the sysfs tree. 368 * 369 * If this function returns an error, kobject_put() must be called to 370 * properly clean up the memory associated with the object. 371 * Under no instance should the kobject that is passed to this function 372 * be directly freed with a call to kfree(), that can leak memory. 373 * 374 * Note, no "add" uevent will be created with this call, the caller should set 375 * up all of the necessary sysfs files for the object and then call 376 * kobject_uevent() with the UEVENT_ADD parameter to ensure that 377 * userspace is properly notified of this kobject's creation. 378 */ 379 int kobject_add(struct kobject *kobj, struct kobject *parent, 380 const char *fmt, ...) 381 { 382 va_list args; 383 int retval; 384 385 if (!kobj) 386 return -EINVAL; 387 388 if (!kobj->state_initialized) { 389 printk(KERN_ERR "kobject '%s' (%p): tried to add an " 390 "uninitialized object, something is seriously wrong.\n", 391 kobject_name(kobj), kobj); 392 dump_stack(); 393 return -EINVAL; 394 } 395 va_start(args, fmt); 396 retval = kobject_add_varg(kobj, parent, fmt, args); 397 va_end(args); 398 399 return retval; 400 } 401 EXPORT_SYMBOL(kobject_add); 402 403 /** 404 * kobject_init_and_add - initialize a kobject structure and add it to the kobject hierarchy 405 * @kobj: pointer to the kobject to initialize 406 * @ktype: pointer to the ktype for this kobject. 407 * @parent: pointer to the parent of this kobject. 408 * @fmt: the name of the kobject. 409 * 410 * This function combines the call to kobject_init() and 411 * kobject_add(). The same type of error handling after a call to 412 * kobject_add() and kobject lifetime rules are the same here. 413 */ 414 int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype, 415 struct kobject *parent, const char *fmt, ...) 416 { 417 va_list args; 418 int retval; 419 420 kobject_init(kobj, ktype); 421 422 va_start(args, fmt); 423 retval = kobject_add_varg(kobj, parent, fmt, args); 424 va_end(args); 425 426 return retval; 427 } 428 EXPORT_SYMBOL_GPL(kobject_init_and_add); 429 430 /** 431 * kobject_rename - change the name of an object 432 * @kobj: object in question. 433 * @new_name: object's new name 434 * 435 * It is the responsibility of the caller to provide mutual 436 * exclusion between two different calls of kobject_rename 437 * on the same kobject and to ensure that new_name is valid and 438 * won't conflict with other kobjects. 439 */ 440 int kobject_rename(struct kobject *kobj, const char *new_name) 441 { 442 int error = 0; 443 const char *devpath = NULL; 444 const char *dup_name = NULL, *name; 445 char *devpath_string = NULL; 446 char *envp[2]; 447 448 kobj = kobject_get(kobj); 449 if (!kobj) 450 return -EINVAL; 451 if (!kobj->parent) 452 return -EINVAL; 453 454 devpath = kobject_get_path(kobj, GFP_KERNEL); 455 if (!devpath) { 456 error = -ENOMEM; 457 goto out; 458 } 459 devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL); 460 if (!devpath_string) { 461 error = -ENOMEM; 462 goto out; 463 } 464 sprintf(devpath_string, "DEVPATH_OLD=%s", devpath); 465 envp[0] = devpath_string; 466 envp[1] = NULL; 467 468 name = dup_name = kstrdup(new_name, GFP_KERNEL); 469 if (!name) { 470 error = -ENOMEM; 471 goto out; 472 } 473 474 error = sysfs_rename_dir_ns(kobj, new_name, kobject_namespace(kobj)); 475 if (error) 476 goto out; 477 478 /* Install the new kobject name */ 479 dup_name = kobj->name; 480 kobj->name = name; 481 482 /* This function is mostly/only used for network interface. 483 * Some hotplug package track interfaces by their name and 484 * therefore want to know when the name is changed by the user. */ 485 kobject_uevent_env(kobj, KOBJ_MOVE, envp); 486 487 out: 488 kfree(dup_name); 489 kfree(devpath_string); 490 kfree(devpath); 491 kobject_put(kobj); 492 493 return error; 494 } 495 EXPORT_SYMBOL_GPL(kobject_rename); 496 497 /** 498 * kobject_move - move object to another parent 499 * @kobj: object in question. 500 * @new_parent: object's new parent (can be NULL) 501 */ 502 int kobject_move(struct kobject *kobj, struct kobject *new_parent) 503 { 504 int error; 505 struct kobject *old_parent; 506 const char *devpath = NULL; 507 char *devpath_string = NULL; 508 char *envp[2]; 509 510 kobj = kobject_get(kobj); 511 if (!kobj) 512 return -EINVAL; 513 new_parent = kobject_get(new_parent); 514 if (!new_parent) { 515 if (kobj->kset) 516 new_parent = kobject_get(&kobj->kset->kobj); 517 } 518 519 /* old object path */ 520 devpath = kobject_get_path(kobj, GFP_KERNEL); 521 if (!devpath) { 522 error = -ENOMEM; 523 goto out; 524 } 525 devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL); 526 if (!devpath_string) { 527 error = -ENOMEM; 528 goto out; 529 } 530 sprintf(devpath_string, "DEVPATH_OLD=%s", devpath); 531 envp[0] = devpath_string; 532 envp[1] = NULL; 533 error = sysfs_move_dir_ns(kobj, new_parent, kobject_namespace(kobj)); 534 if (error) 535 goto out; 536 old_parent = kobj->parent; 537 kobj->parent = new_parent; 538 new_parent = NULL; 539 kobject_put(old_parent); 540 kobject_uevent_env(kobj, KOBJ_MOVE, envp); 541 out: 542 kobject_put(new_parent); 543 kobject_put(kobj); 544 kfree(devpath_string); 545 kfree(devpath); 546 return error; 547 } 548 EXPORT_SYMBOL_GPL(kobject_move); 549 550 /** 551 * kobject_del - unlink kobject from hierarchy. 552 * @kobj: object. 553 */ 554 void kobject_del(struct kobject *kobj) 555 { 556 struct kernfs_node *sd; 557 558 if (!kobj) 559 return; 560 561 sd = kobj->sd; 562 sysfs_remove_dir(kobj); 563 sysfs_put(sd); 564 565 kobj->state_in_sysfs = 0; 566 kobj_kset_leave(kobj); 567 kobject_put(kobj->parent); 568 kobj->parent = NULL; 569 } 570 571 /** 572 * kobject_get - increment refcount for object. 573 * @kobj: object. 574 */ 575 struct kobject *kobject_get(struct kobject *kobj) 576 { 577 if (kobj) { 578 if (!kobj->state_initialized) 579 WARN(1, KERN_WARNING "kobject: '%s' (%p): is not " 580 "initialized, yet kobject_get() is being " 581 "called.\n", kobject_name(kobj), kobj); 582 kref_get(&kobj->kref); 583 } 584 return kobj; 585 } 586 587 static struct kobject * __must_check kobject_get_unless_zero(struct kobject *kobj) 588 { 589 if (!kref_get_unless_zero(&kobj->kref)) 590 kobj = NULL; 591 return kobj; 592 } 593 594 /* 595 * kobject_cleanup - free kobject resources. 596 * @kobj: object to cleanup 597 */ 598 static void kobject_cleanup(struct kobject *kobj) 599 { 600 struct kobj_type *t = get_ktype(kobj); 601 const char *name = kobj->name; 602 603 pr_debug("kobject: '%s' (%p): %s, parent %p\n", 604 kobject_name(kobj), kobj, __func__, kobj->parent); 605 606 if (t && !t->release) 607 pr_debug("kobject: '%s' (%p): does not have a release() " 608 "function, it is broken and must be fixed.\n", 609 kobject_name(kobj), kobj); 610 611 /* send "remove" if the caller did not do it but sent "add" */ 612 if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) { 613 pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n", 614 kobject_name(kobj), kobj); 615 kobject_uevent(kobj, KOBJ_REMOVE); 616 } 617 618 /* remove from sysfs if the caller did not do it */ 619 if (kobj->state_in_sysfs) { 620 pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n", 621 kobject_name(kobj), kobj); 622 kobject_del(kobj); 623 } 624 625 if (t && t->release) { 626 pr_debug("kobject: '%s' (%p): calling ktype release\n", 627 kobject_name(kobj), kobj); 628 t->release(kobj); 629 } 630 631 /* free name if we allocated it */ 632 if (name) { 633 pr_debug("kobject: '%s': free name\n", name); 634 kfree(name); 635 } 636 } 637 638 #ifdef CONFIG_DEBUG_KOBJECT_RELEASE 639 static void kobject_delayed_cleanup(struct work_struct *work) 640 { 641 kobject_cleanup(container_of(to_delayed_work(work), 642 struct kobject, release)); 643 } 644 #endif 645 646 static void kobject_release(struct kref *kref) 647 { 648 struct kobject *kobj = container_of(kref, struct kobject, kref); 649 #ifdef CONFIG_DEBUG_KOBJECT_RELEASE 650 unsigned long delay = HZ + HZ * (get_random_int() & 0x3); 651 pr_info("kobject: '%s' (%p): %s, parent %p (delayed %ld)\n", 652 kobject_name(kobj), kobj, __func__, kobj->parent, delay); 653 INIT_DELAYED_WORK(&kobj->release, kobject_delayed_cleanup); 654 655 schedule_delayed_work(&kobj->release, delay); 656 #else 657 kobject_cleanup(kobj); 658 #endif 659 } 660 661 /** 662 * kobject_put - decrement refcount for object. 663 * @kobj: object. 664 * 665 * Decrement the refcount, and if 0, call kobject_cleanup(). 666 */ 667 void kobject_put(struct kobject *kobj) 668 { 669 if (kobj) { 670 if (!kobj->state_initialized) 671 WARN(1, KERN_WARNING "kobject: '%s' (%p): is not " 672 "initialized, yet kobject_put() is being " 673 "called.\n", kobject_name(kobj), kobj); 674 kref_put(&kobj->kref, kobject_release); 675 } 676 } 677 678 static void dynamic_kobj_release(struct kobject *kobj) 679 { 680 pr_debug("kobject: (%p): %s\n", kobj, __func__); 681 kfree(kobj); 682 } 683 684 static struct kobj_type dynamic_kobj_ktype = { 685 .release = dynamic_kobj_release, 686 .sysfs_ops = &kobj_sysfs_ops, 687 }; 688 689 /** 690 * kobject_create - create a struct kobject dynamically 691 * 692 * This function creates a kobject structure dynamically and sets it up 693 * to be a "dynamic" kobject with a default release function set up. 694 * 695 * If the kobject was not able to be created, NULL will be returned. 696 * The kobject structure returned from here must be cleaned up with a 697 * call to kobject_put() and not kfree(), as kobject_init() has 698 * already been called on this structure. 699 */ 700 struct kobject *kobject_create(void) 701 { 702 struct kobject *kobj; 703 704 kobj = kzalloc(sizeof(*kobj), GFP_KERNEL); 705 if (!kobj) 706 return NULL; 707 708 kobject_init(kobj, &dynamic_kobj_ktype); 709 return kobj; 710 } 711 712 /** 713 * kobject_create_and_add - create a struct kobject dynamically and register it with sysfs 714 * 715 * @name: the name for the kobject 716 * @parent: the parent kobject of this kobject, if any. 717 * 718 * This function creates a kobject structure dynamically and registers it 719 * with sysfs. When you are finished with this structure, call 720 * kobject_put() and the structure will be dynamically freed when 721 * it is no longer being used. 722 * 723 * If the kobject was not able to be created, NULL will be returned. 724 */ 725 struct kobject *kobject_create_and_add(const char *name, struct kobject *parent) 726 { 727 struct kobject *kobj; 728 int retval; 729 730 kobj = kobject_create(); 731 if (!kobj) 732 return NULL; 733 734 retval = kobject_add(kobj, parent, "%s", name); 735 if (retval) { 736 printk(KERN_WARNING "%s: kobject_add error: %d\n", 737 __func__, retval); 738 kobject_put(kobj); 739 kobj = NULL; 740 } 741 return kobj; 742 } 743 EXPORT_SYMBOL_GPL(kobject_create_and_add); 744 745 /** 746 * kset_init - initialize a kset for use 747 * @k: kset 748 */ 749 void kset_init(struct kset *k) 750 { 751 kobject_init_internal(&k->kobj); 752 INIT_LIST_HEAD(&k->list); 753 spin_lock_init(&k->list_lock); 754 } 755 756 /* default kobject attribute operations */ 757 static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr, 758 char *buf) 759 { 760 struct kobj_attribute *kattr; 761 ssize_t ret = -EIO; 762 763 kattr = container_of(attr, struct kobj_attribute, attr); 764 if (kattr->show) 765 ret = kattr->show(kobj, kattr, buf); 766 return ret; 767 } 768 769 static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr, 770 const char *buf, size_t count) 771 { 772 struct kobj_attribute *kattr; 773 ssize_t ret = -EIO; 774 775 kattr = container_of(attr, struct kobj_attribute, attr); 776 if (kattr->store) 777 ret = kattr->store(kobj, kattr, buf, count); 778 return ret; 779 } 780 781 const struct sysfs_ops kobj_sysfs_ops = { 782 .show = kobj_attr_show, 783 .store = kobj_attr_store, 784 }; 785 EXPORT_SYMBOL_GPL(kobj_sysfs_ops); 786 787 /** 788 * kset_register - initialize and add a kset. 789 * @k: kset. 790 */ 791 int kset_register(struct kset *k) 792 { 793 int err; 794 795 if (!k) 796 return -EINVAL; 797 798 kset_init(k); 799 err = kobject_add_internal(&k->kobj); 800 if (err) 801 return err; 802 kobject_uevent(&k->kobj, KOBJ_ADD); 803 return 0; 804 } 805 806 /** 807 * kset_unregister - remove a kset. 808 * @k: kset. 809 */ 810 void kset_unregister(struct kset *k) 811 { 812 if (!k) 813 return; 814 kobject_del(&k->kobj); 815 kobject_put(&k->kobj); 816 } 817 818 /** 819 * kset_find_obj - search for object in kset. 820 * @kset: kset we're looking in. 821 * @name: object's name. 822 * 823 * Lock kset via @kset->subsys, and iterate over @kset->list, 824 * looking for a matching kobject. If matching object is found 825 * take a reference and return the object. 826 */ 827 struct kobject *kset_find_obj(struct kset *kset, const char *name) 828 { 829 struct kobject *k; 830 struct kobject *ret = NULL; 831 832 spin_lock(&kset->list_lock); 833 834 list_for_each_entry(k, &kset->list, entry) { 835 if (kobject_name(k) && !strcmp(kobject_name(k), name)) { 836 ret = kobject_get_unless_zero(k); 837 break; 838 } 839 } 840 841 spin_unlock(&kset->list_lock); 842 return ret; 843 } 844 845 static void kset_release(struct kobject *kobj) 846 { 847 struct kset *kset = container_of(kobj, struct kset, kobj); 848 pr_debug("kobject: '%s' (%p): %s\n", 849 kobject_name(kobj), kobj, __func__); 850 kfree(kset); 851 } 852 853 static struct kobj_type kset_ktype = { 854 .sysfs_ops = &kobj_sysfs_ops, 855 .release = kset_release, 856 }; 857 858 /** 859 * kset_create - create a struct kset dynamically 860 * 861 * @name: the name for the kset 862 * @uevent_ops: a struct kset_uevent_ops for the kset 863 * @parent_kobj: the parent kobject of this kset, if any. 864 * 865 * This function creates a kset structure dynamically. This structure can 866 * then be registered with the system and show up in sysfs with a call to 867 * kset_register(). When you are finished with this structure, if 868 * kset_register() has been called, call kset_unregister() and the 869 * structure will be dynamically freed when it is no longer being used. 870 * 871 * If the kset was not able to be created, NULL will be returned. 872 */ 873 static struct kset *kset_create(const char *name, 874 const struct kset_uevent_ops *uevent_ops, 875 struct kobject *parent_kobj) 876 { 877 struct kset *kset; 878 int retval; 879 880 kset = kzalloc(sizeof(*kset), GFP_KERNEL); 881 if (!kset) 882 return NULL; 883 retval = kobject_set_name(&kset->kobj, "%s", name); 884 if (retval) { 885 kfree(kset); 886 return NULL; 887 } 888 kset->uevent_ops = uevent_ops; 889 kset->kobj.parent = parent_kobj; 890 891 /* 892 * The kobject of this kset will have a type of kset_ktype and belong to 893 * no kset itself. That way we can properly free it when it is 894 * finished being used. 895 */ 896 kset->kobj.ktype = &kset_ktype; 897 kset->kobj.kset = NULL; 898 899 return kset; 900 } 901 902 /** 903 * kset_create_and_add - create a struct kset dynamically and add it to sysfs 904 * 905 * @name: the name for the kset 906 * @uevent_ops: a struct kset_uevent_ops for the kset 907 * @parent_kobj: the parent kobject of this kset, if any. 908 * 909 * This function creates a kset structure dynamically and registers it 910 * with sysfs. When you are finished with this structure, call 911 * kset_unregister() and the structure will be dynamically freed when it 912 * is no longer being used. 913 * 914 * If the kset was not able to be created, NULL will be returned. 915 */ 916 struct kset *kset_create_and_add(const char *name, 917 const struct kset_uevent_ops *uevent_ops, 918 struct kobject *parent_kobj) 919 { 920 struct kset *kset; 921 int error; 922 923 kset = kset_create(name, uevent_ops, parent_kobj); 924 if (!kset) 925 return NULL; 926 error = kset_register(kset); 927 if (error) { 928 kfree(kset); 929 return NULL; 930 } 931 return kset; 932 } 933 EXPORT_SYMBOL_GPL(kset_create_and_add); 934 935 936 static DEFINE_SPINLOCK(kobj_ns_type_lock); 937 static const struct kobj_ns_type_operations *kobj_ns_ops_tbl[KOBJ_NS_TYPES]; 938 939 int kobj_ns_type_register(const struct kobj_ns_type_operations *ops) 940 { 941 enum kobj_ns_type type = ops->type; 942 int error; 943 944 spin_lock(&kobj_ns_type_lock); 945 946 error = -EINVAL; 947 if (type >= KOBJ_NS_TYPES) 948 goto out; 949 950 error = -EINVAL; 951 if (type <= KOBJ_NS_TYPE_NONE) 952 goto out; 953 954 error = -EBUSY; 955 if (kobj_ns_ops_tbl[type]) 956 goto out; 957 958 error = 0; 959 kobj_ns_ops_tbl[type] = ops; 960 961 out: 962 spin_unlock(&kobj_ns_type_lock); 963 return error; 964 } 965 966 int kobj_ns_type_registered(enum kobj_ns_type type) 967 { 968 int registered = 0; 969 970 spin_lock(&kobj_ns_type_lock); 971 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES)) 972 registered = kobj_ns_ops_tbl[type] != NULL; 973 spin_unlock(&kobj_ns_type_lock); 974 975 return registered; 976 } 977 978 const struct kobj_ns_type_operations *kobj_child_ns_ops(struct kobject *parent) 979 { 980 const struct kobj_ns_type_operations *ops = NULL; 981 982 if (parent && parent->ktype && parent->ktype->child_ns_type) 983 ops = parent->ktype->child_ns_type(parent); 984 985 return ops; 986 } 987 988 const struct kobj_ns_type_operations *kobj_ns_ops(struct kobject *kobj) 989 { 990 return kobj_child_ns_ops(kobj->parent); 991 } 992 993 bool kobj_ns_current_may_mount(enum kobj_ns_type type) 994 { 995 bool may_mount = true; 996 997 spin_lock(&kobj_ns_type_lock); 998 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) && 999 kobj_ns_ops_tbl[type]) 1000 may_mount = kobj_ns_ops_tbl[type]->current_may_mount(); 1001 spin_unlock(&kobj_ns_type_lock); 1002 1003 return may_mount; 1004 } 1005 1006 void *kobj_ns_grab_current(enum kobj_ns_type type) 1007 { 1008 void *ns = NULL; 1009 1010 spin_lock(&kobj_ns_type_lock); 1011 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) && 1012 kobj_ns_ops_tbl[type]) 1013 ns = kobj_ns_ops_tbl[type]->grab_current_ns(); 1014 spin_unlock(&kobj_ns_type_lock); 1015 1016 return ns; 1017 } 1018 1019 const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk) 1020 { 1021 const void *ns = NULL; 1022 1023 spin_lock(&kobj_ns_type_lock); 1024 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) && 1025 kobj_ns_ops_tbl[type]) 1026 ns = kobj_ns_ops_tbl[type]->netlink_ns(sk); 1027 spin_unlock(&kobj_ns_type_lock); 1028 1029 return ns; 1030 } 1031 1032 const void *kobj_ns_initial(enum kobj_ns_type type) 1033 { 1034 const void *ns = NULL; 1035 1036 spin_lock(&kobj_ns_type_lock); 1037 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) && 1038 kobj_ns_ops_tbl[type]) 1039 ns = kobj_ns_ops_tbl[type]->initial_ns(); 1040 spin_unlock(&kobj_ns_type_lock); 1041 1042 return ns; 1043 } 1044 1045 void kobj_ns_drop(enum kobj_ns_type type, void *ns) 1046 { 1047 spin_lock(&kobj_ns_type_lock); 1048 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) && 1049 kobj_ns_ops_tbl[type] && kobj_ns_ops_tbl[type]->drop_ns) 1050 kobj_ns_ops_tbl[type]->drop_ns(ns); 1051 spin_unlock(&kobj_ns_type_lock); 1052 } 1053 1054 EXPORT_SYMBOL(kobject_get); 1055 EXPORT_SYMBOL(kobject_put); 1056 EXPORT_SYMBOL(kobject_del); 1057 1058 EXPORT_SYMBOL(kset_register); 1059 EXPORT_SYMBOL(kset_unregister); 1060