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