1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * sysfs.h - definitions for the device driver filesystem 4 * 5 * Copyright (c) 2001,2002 Patrick Mochel 6 * Copyright (c) 2004 Silicon Graphics, Inc. 7 * Copyright (c) 2007 SUSE Linux Products GmbH 8 * Copyright (c) 2007 Tejun Heo <teheo@suse.de> 9 * 10 * Please see Documentation/filesystems/sysfs.rst for more information. 11 */ 12 13 #ifndef _SYSFS_H_ 14 #define _SYSFS_H_ 15 16 #include <linux/kernfs.h> 17 #include <linux/compiler.h> 18 #include <linux/errno.h> 19 #include <linux/list.h> 20 #include <linux/lockdep.h> 21 #include <linux/kobject_ns.h> 22 #include <linux/stat.h> 23 #include <linux/atomic.h> 24 25 struct kobject; 26 struct module; 27 struct bin_attribute; 28 enum kobj_ns_type; 29 30 struct attribute { 31 const char *name; 32 umode_t mode; 33 #ifdef CONFIG_DEBUG_LOCK_ALLOC 34 bool ignore_lockdep:1; 35 struct lock_class_key *key; 36 struct lock_class_key skey; 37 #endif 38 }; 39 40 /** 41 * sysfs_attr_init - initialize a dynamically allocated sysfs attribute 42 * @attr: struct attribute to initialize 43 * 44 * Initialize a dynamically allocated struct attribute so we can 45 * make lockdep happy. This is a new requirement for attributes 46 * and initially this is only needed when lockdep is enabled. 47 * Lockdep gives a nice error when your attribute is added to 48 * sysfs if you don't have this. 49 */ 50 #ifdef CONFIG_DEBUG_LOCK_ALLOC 51 #define sysfs_attr_init(attr) \ 52 do { \ 53 static struct lock_class_key __key; \ 54 \ 55 (attr)->key = &__key; \ 56 } while (0) 57 #else 58 #define sysfs_attr_init(attr) do {} while (0) 59 #endif 60 61 /** 62 * struct attribute_group - data structure used to declare an attribute group. 63 * @name: Optional: Attribute group name 64 * If specified, the attribute group will be created in a 65 * new subdirectory with this name. Additionally when a 66 * group is named, @is_visible and @is_bin_visible may 67 * return SYSFS_GROUP_INVISIBLE to control visibility of 68 * the directory itself. 69 * @is_visible: Optional: Function to return permissions associated with an 70 * attribute of the group. Will be called repeatedly for 71 * each non-binary attribute in the group. Only read/write 72 * permissions as well as SYSFS_PREALLOC are accepted. Must 73 * return 0 if an attribute is not visible. The returned 74 * value will replace static permissions defined in struct 75 * attribute. Use SYSFS_GROUP_VISIBLE() when assigning this 76 * callback to specify separate _group_visible() and 77 * _attr_visible() handlers. 78 * @is_bin_visible: 79 * Optional: Function to return permissions associated with a 80 * binary attribute of the group. Will be called repeatedly 81 * for each binary attribute in the group. Only read/write 82 * permissions as well as SYSFS_PREALLOC (and the 83 * visibility flags for named groups) are accepted. Must 84 * return 0 if a binary attribute is not visible. The 85 * returned value will replace static permissions defined 86 * in struct bin_attribute. If @is_visible is not set, Use 87 * SYSFS_GROUP_VISIBLE() when assigning this callback to 88 * specify separate _group_visible() and _attr_visible() 89 * handlers. 90 * @bin_size: 91 * Optional: Function to return the size of a binary attribute 92 * of the group. Will be called repeatedly for each binary 93 * attribute in the group. Overwrites the size field embedded 94 * inside the attribute itself. 95 * @attrs: Pointer to NULL terminated list of attributes. 96 * @bin_attrs: Pointer to NULL terminated list of binary attributes. 97 * Either attrs or bin_attrs or both must be provided. 98 */ 99 struct attribute_group { 100 const char *name; 101 umode_t (*is_visible)(struct kobject *, 102 struct attribute *, int); 103 umode_t (*is_bin_visible)(struct kobject *, 104 const struct bin_attribute *, int); 105 size_t (*bin_size)(struct kobject *, 106 const struct bin_attribute *, 107 int); 108 struct attribute **attrs; 109 const struct bin_attribute *const *bin_attrs; 110 }; 111 112 #define SYSFS_PREALLOC 010000 113 #define SYSFS_GROUP_INVISIBLE 020000 114 115 /* 116 * DEFINE_SYSFS_GROUP_VISIBLE(name): 117 * A helper macro to pair with the assignment of ".is_visible = 118 * SYSFS_GROUP_VISIBLE(name)", that arranges for the directory 119 * associated with a named attribute_group to optionally be hidden. 120 * This allows for static declaration of attribute_groups, and the 121 * simplification of attribute visibility lifetime that implies, 122 * without polluting sysfs with empty attribute directories. 123 * Ex. 124 * 125 * static umode_t example_attr_visible(struct kobject *kobj, 126 * struct attribute *attr, int n) 127 * { 128 * if (example_attr_condition) 129 * return 0; 130 * else if (ro_attr_condition) 131 * return 0444; 132 * return a->mode; 133 * } 134 * 135 * static bool example_group_visible(struct kobject *kobj) 136 * { 137 * if (example_group_condition) 138 * return false; 139 * return true; 140 * } 141 * 142 * DEFINE_SYSFS_GROUP_VISIBLE(example); 143 * 144 * static struct attribute_group example_group = { 145 * .name = "example", 146 * .is_visible = SYSFS_GROUP_VISIBLE(example), 147 * .attrs = &example_attrs, 148 * }; 149 * 150 * Note that it expects <name>_attr_visible and <name>_group_visible to 151 * be defined. For cases where individual attributes do not need 152 * separate visibility consideration, only entire group visibility at 153 * once, see DEFINE_SIMPLE_SYSFS_GROUP_VISIBLE(). 154 */ 155 #define DEFINE_SYSFS_GROUP_VISIBLE(name) \ 156 static inline umode_t sysfs_group_visible_##name( \ 157 struct kobject *kobj, struct attribute *attr, int n) \ 158 { \ 159 if (n == 0 && !name##_group_visible(kobj)) \ 160 return SYSFS_GROUP_INVISIBLE; \ 161 return name##_attr_visible(kobj, attr, n); \ 162 } 163 164 /* 165 * DEFINE_SIMPLE_SYSFS_GROUP_VISIBLE(name): 166 * A helper macro to pair with SYSFS_GROUP_VISIBLE() that like 167 * DEFINE_SYSFS_GROUP_VISIBLE() controls group visibility, but does 168 * not require the implementation of a per-attribute visibility 169 * callback. 170 * Ex. 171 * 172 * static bool example_group_visible(struct kobject *kobj) 173 * { 174 * if (example_group_condition) 175 * return false; 176 * return true; 177 * } 178 * 179 * DEFINE_SIMPLE_SYSFS_GROUP_VISIBLE(example); 180 * 181 * static struct attribute_group example_group = { 182 * .name = "example", 183 * .is_visible = SYSFS_GROUP_VISIBLE(example), 184 * .attrs = &example_attrs, 185 * }; 186 */ 187 #define DEFINE_SIMPLE_SYSFS_GROUP_VISIBLE(name) \ 188 static inline umode_t sysfs_group_visible_##name( \ 189 struct kobject *kobj, struct attribute *a, int n) \ 190 { \ 191 if (n == 0 && !name##_group_visible(kobj)) \ 192 return SYSFS_GROUP_INVISIBLE; \ 193 return a->mode; \ 194 } 195 196 /* 197 * Same as DEFINE_SYSFS_GROUP_VISIBLE, but for groups with only binary 198 * attributes. If an attribute_group defines both text and binary 199 * attributes, the group visibility is determined by the function 200 * specified to is_visible() not is_bin_visible() 201 */ 202 #define DEFINE_SYSFS_BIN_GROUP_VISIBLE(name) \ 203 static inline umode_t sysfs_group_visible_##name( \ 204 struct kobject *kobj, const struct bin_attribute *attr, int n) \ 205 { \ 206 if (n == 0 && !name##_group_visible(kobj)) \ 207 return SYSFS_GROUP_INVISIBLE; \ 208 return name##_attr_visible(kobj, attr, n); \ 209 } 210 211 #define DEFINE_SIMPLE_SYSFS_BIN_GROUP_VISIBLE(name) \ 212 static inline umode_t sysfs_group_visible_##name( \ 213 struct kobject *kobj, const struct bin_attribute *a, int n) \ 214 { \ 215 if (n == 0 && !name##_group_visible(kobj)) \ 216 return SYSFS_GROUP_INVISIBLE; \ 217 return a->mode; \ 218 } 219 220 #define SYSFS_GROUP_VISIBLE(fn) sysfs_group_visible_##fn 221 222 /* 223 * Use these macros to make defining attributes easier. 224 * See include/linux/device.h for examples.. 225 */ 226 227 #define __ATTR(_name, _mode, _show, _store) { \ 228 .attr = {.name = __stringify(_name), \ 229 .mode = VERIFY_OCTAL_PERMISSIONS(_mode) }, \ 230 .show = _show, \ 231 .store = _store, \ 232 } 233 234 #define __ATTR_PREALLOC(_name, _mode, _show, _store) { \ 235 .attr = {.name = __stringify(_name), \ 236 .mode = SYSFS_PREALLOC | VERIFY_OCTAL_PERMISSIONS(_mode) },\ 237 .show = _show, \ 238 .store = _store, \ 239 } 240 241 #define __ATTR_RO(_name) { \ 242 .attr = { .name = __stringify(_name), .mode = 0444 }, \ 243 .show = _name##_show, \ 244 } 245 246 #define __ATTR_RO_MODE(_name, _mode) { \ 247 .attr = { .name = __stringify(_name), \ 248 .mode = VERIFY_OCTAL_PERMISSIONS(_mode) }, \ 249 .show = _name##_show, \ 250 } 251 252 #define __ATTR_RW_MODE(_name, _mode) { \ 253 .attr = { .name = __stringify(_name), \ 254 .mode = VERIFY_OCTAL_PERMISSIONS(_mode) }, \ 255 .show = _name##_show, \ 256 .store = _name##_store, \ 257 } 258 259 #define __ATTR_WO(_name) { \ 260 .attr = { .name = __stringify(_name), .mode = 0200 }, \ 261 .store = _name##_store, \ 262 } 263 264 #define __ATTR_RW(_name) __ATTR(_name, 0644, _name##_show, _name##_store) 265 266 #define __ATTR_NULL { .attr = { .name = NULL } } 267 268 #ifdef CONFIG_DEBUG_LOCK_ALLOC 269 #define __ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) { \ 270 .attr = {.name = __stringify(_name), .mode = _mode, \ 271 .ignore_lockdep = true }, \ 272 .show = _show, \ 273 .store = _store, \ 274 } 275 #else 276 #define __ATTR_IGNORE_LOCKDEP __ATTR 277 #endif 278 279 #define __ATTRIBUTE_GROUPS(_name) \ 280 static const struct attribute_group *_name##_groups[] = { \ 281 &_name##_group, \ 282 NULL, \ 283 } 284 285 #define ATTRIBUTE_GROUPS(_name) \ 286 static const struct attribute_group _name##_group = { \ 287 .attrs = _name##_attrs, \ 288 }; \ 289 __ATTRIBUTE_GROUPS(_name) 290 291 #define BIN_ATTRIBUTE_GROUPS(_name) \ 292 static const struct attribute_group _name##_group = { \ 293 .bin_attrs = _name##_attrs, \ 294 }; \ 295 __ATTRIBUTE_GROUPS(_name) 296 297 struct file; 298 struct vm_area_struct; 299 struct address_space; 300 301 struct bin_attribute { 302 struct attribute attr; 303 size_t size; 304 void *private; 305 struct address_space *(*f_mapping)(void); 306 ssize_t (*read)(struct file *, struct kobject *, const struct bin_attribute *, 307 char *, loff_t, size_t); 308 ssize_t (*write)(struct file *, struct kobject *, const struct bin_attribute *, 309 char *, loff_t, size_t); 310 loff_t (*llseek)(struct file *, struct kobject *, const struct bin_attribute *, 311 loff_t, int); 312 int (*mmap)(struct file *, struct kobject *, const struct bin_attribute *attr, 313 struct vm_area_struct *vma); 314 }; 315 316 /** 317 * sysfs_bin_attr_init - initialize a dynamically allocated bin_attribute 318 * @attr: struct bin_attribute to initialize 319 * 320 * Initialize a dynamically allocated struct bin_attribute so we 321 * can make lockdep happy. This is a new requirement for 322 * attributes and initially this is only needed when lockdep is 323 * enabled. Lockdep gives a nice error when your attribute is 324 * added to sysfs if you don't have this. 325 */ 326 #define sysfs_bin_attr_init(bin_attr) sysfs_attr_init(&(bin_attr)->attr) 327 328 /* macros to create static binary attributes easier */ 329 #define __BIN_ATTR(_name, _mode, _read, _write, _size) { \ 330 .attr = { .name = __stringify(_name), .mode = _mode }, \ 331 .read = _read, \ 332 .write = _write, \ 333 .size = _size, \ 334 } 335 336 #define __BIN_ATTR_RO(_name, _size) \ 337 __BIN_ATTR(_name, 0444, _name##_read, NULL, _size) 338 339 #define __BIN_ATTR_WO(_name, _size) \ 340 __BIN_ATTR(_name, 0200, NULL, _name##_write, _size) 341 342 #define __BIN_ATTR_RW(_name, _size) \ 343 __BIN_ATTR(_name, 0644, _name##_read, _name##_write, _size) 344 345 #define __BIN_ATTR_NULL __ATTR_NULL 346 347 #define BIN_ATTR(_name, _mode, _read, _write, _size) \ 348 struct bin_attribute bin_attr_##_name = __BIN_ATTR(_name, _mode, _read, \ 349 _write, _size) 350 351 #define BIN_ATTR_RO(_name, _size) \ 352 struct bin_attribute bin_attr_##_name = __BIN_ATTR_RO(_name, _size) 353 354 #define BIN_ATTR_WO(_name, _size) \ 355 struct bin_attribute bin_attr_##_name = __BIN_ATTR_WO(_name, _size) 356 357 #define BIN_ATTR_RW(_name, _size) \ 358 struct bin_attribute bin_attr_##_name = __BIN_ATTR_RW(_name, _size) 359 360 361 #define __BIN_ATTR_ADMIN_RO(_name, _size) \ 362 __BIN_ATTR(_name, 0400, _name##_read, NULL, _size) 363 364 #define __BIN_ATTR_ADMIN_RW(_name, _size) \ 365 __BIN_ATTR(_name, 0600, _name##_read, _name##_write, _size) 366 367 #define BIN_ATTR_ADMIN_RO(_name, _size) \ 368 struct bin_attribute bin_attr_##_name = __BIN_ATTR_ADMIN_RO(_name, _size) 369 370 #define BIN_ATTR_ADMIN_RW(_name, _size) \ 371 struct bin_attribute bin_attr_##_name = __BIN_ATTR_ADMIN_RW(_name, _size) 372 373 #define __BIN_ATTR_SIMPLE_RO(_name, _mode) \ 374 __BIN_ATTR(_name, _mode, sysfs_bin_attr_simple_read, NULL, 0) 375 376 #define BIN_ATTR_SIMPLE_RO(_name) \ 377 struct bin_attribute bin_attr_##_name = __BIN_ATTR_SIMPLE_RO(_name, 0444) 378 379 #define BIN_ATTR_SIMPLE_ADMIN_RO(_name) \ 380 struct bin_attribute bin_attr_##_name = __BIN_ATTR_SIMPLE_RO(_name, 0400) 381 382 struct sysfs_ops { 383 ssize_t (*show)(struct kobject *, struct attribute *, char *); 384 ssize_t (*store)(struct kobject *, struct attribute *, const char *, size_t); 385 }; 386 387 #ifdef CONFIG_SYSFS 388 389 int __must_check sysfs_create_dir_ns(struct kobject *kobj, const void *ns); 390 void sysfs_remove_dir(struct kobject *kobj); 391 int __must_check sysfs_rename_dir_ns(struct kobject *kobj, const char *new_name, 392 const void *new_ns); 393 int __must_check sysfs_move_dir_ns(struct kobject *kobj, 394 struct kobject *new_parent_kobj, 395 const void *new_ns); 396 int __must_check sysfs_create_mount_point(struct kobject *parent_kobj, 397 const char *name); 398 void sysfs_remove_mount_point(struct kobject *parent_kobj, 399 const char *name); 400 401 int __must_check sysfs_create_file_ns(struct kobject *kobj, 402 const struct attribute *attr, 403 const void *ns); 404 int __must_check sysfs_create_files(struct kobject *kobj, 405 const struct attribute * const *attr); 406 int __must_check sysfs_chmod_file(struct kobject *kobj, 407 const struct attribute *attr, umode_t mode); 408 struct kernfs_node *sysfs_break_active_protection(struct kobject *kobj, 409 const struct attribute *attr); 410 void sysfs_unbreak_active_protection(struct kernfs_node *kn); 411 void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr, 412 const void *ns); 413 bool sysfs_remove_file_self(struct kobject *kobj, const struct attribute *attr); 414 void sysfs_remove_files(struct kobject *kobj, const struct attribute * const *attr); 415 416 int __must_check sysfs_create_bin_file(struct kobject *kobj, 417 const struct bin_attribute *attr); 418 void sysfs_remove_bin_file(struct kobject *kobj, 419 const struct bin_attribute *attr); 420 421 int __must_check sysfs_create_link(struct kobject *kobj, struct kobject *target, 422 const char *name); 423 int __must_check sysfs_create_link_nowarn(struct kobject *kobj, 424 struct kobject *target, 425 const char *name); 426 void sysfs_remove_link(struct kobject *kobj, const char *name); 427 428 int sysfs_rename_link_ns(struct kobject *kobj, struct kobject *target, 429 const char *old_name, const char *new_name, 430 const void *new_ns); 431 432 void sysfs_delete_link(struct kobject *dir, struct kobject *targ, 433 const char *name); 434 435 int __must_check sysfs_create_group(struct kobject *kobj, 436 const struct attribute_group *grp); 437 int __must_check sysfs_create_groups(struct kobject *kobj, 438 const struct attribute_group **groups); 439 int __must_check sysfs_update_groups(struct kobject *kobj, 440 const struct attribute_group **groups); 441 int sysfs_update_group(struct kobject *kobj, 442 const struct attribute_group *grp); 443 void sysfs_remove_group(struct kobject *kobj, 444 const struct attribute_group *grp); 445 void sysfs_remove_groups(struct kobject *kobj, 446 const struct attribute_group **groups); 447 int sysfs_add_file_to_group(struct kobject *kobj, 448 const struct attribute *attr, const char *group); 449 void sysfs_remove_file_from_group(struct kobject *kobj, 450 const struct attribute *attr, const char *group); 451 int sysfs_merge_group(struct kobject *kobj, 452 const struct attribute_group *grp); 453 void sysfs_unmerge_group(struct kobject *kobj, 454 const struct attribute_group *grp); 455 int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name, 456 struct kobject *target, const char *link_name); 457 void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name, 458 const char *link_name); 459 int compat_only_sysfs_link_entry_to_kobj(struct kobject *kobj, 460 struct kobject *target_kobj, 461 const char *target_name, 462 const char *symlink_name); 463 464 void sysfs_notify(struct kobject *kobj, const char *dir, const char *attr); 465 466 int __must_check sysfs_init(void); 467 468 static inline void sysfs_enable_ns(struct kernfs_node *kn) 469 { 470 return kernfs_enable_ns(kn); 471 } 472 473 int sysfs_file_change_owner(struct kobject *kobj, const char *name, kuid_t kuid, 474 kgid_t kgid); 475 int sysfs_change_owner(struct kobject *kobj, kuid_t kuid, kgid_t kgid); 476 int sysfs_link_change_owner(struct kobject *kobj, struct kobject *targ, 477 const char *name, kuid_t kuid, kgid_t kgid); 478 int sysfs_groups_change_owner(struct kobject *kobj, 479 const struct attribute_group **groups, 480 kuid_t kuid, kgid_t kgid); 481 int sysfs_group_change_owner(struct kobject *kobj, 482 const struct attribute_group *groups, kuid_t kuid, 483 kgid_t kgid); 484 __printf(2, 3) 485 int sysfs_emit(char *buf, const char *fmt, ...); 486 __printf(3, 4) 487 int sysfs_emit_at(char *buf, int at, const char *fmt, ...); 488 489 ssize_t sysfs_bin_attr_simple_read(struct file *file, struct kobject *kobj, 490 const struct bin_attribute *attr, char *buf, 491 loff_t off, size_t count); 492 493 #else /* CONFIG_SYSFS */ 494 495 static inline int sysfs_create_dir_ns(struct kobject *kobj, const void *ns) 496 { 497 return 0; 498 } 499 500 static inline void sysfs_remove_dir(struct kobject *kobj) 501 { 502 } 503 504 static inline int sysfs_rename_dir_ns(struct kobject *kobj, 505 const char *new_name, const void *new_ns) 506 { 507 return 0; 508 } 509 510 static inline int sysfs_move_dir_ns(struct kobject *kobj, 511 struct kobject *new_parent_kobj, 512 const void *new_ns) 513 { 514 return 0; 515 } 516 517 static inline int sysfs_create_mount_point(struct kobject *parent_kobj, 518 const char *name) 519 { 520 return 0; 521 } 522 523 static inline void sysfs_remove_mount_point(struct kobject *parent_kobj, 524 const char *name) 525 { 526 } 527 528 static inline int sysfs_create_file_ns(struct kobject *kobj, 529 const struct attribute *attr, 530 const void *ns) 531 { 532 return 0; 533 } 534 535 static inline int sysfs_create_files(struct kobject *kobj, 536 const struct attribute * const *attr) 537 { 538 return 0; 539 } 540 541 static inline int sysfs_chmod_file(struct kobject *kobj, 542 const struct attribute *attr, umode_t mode) 543 { 544 return 0; 545 } 546 547 static inline struct kernfs_node * 548 sysfs_break_active_protection(struct kobject *kobj, 549 const struct attribute *attr) 550 { 551 return NULL; 552 } 553 554 static inline void sysfs_unbreak_active_protection(struct kernfs_node *kn) 555 { 556 } 557 558 static inline void sysfs_remove_file_ns(struct kobject *kobj, 559 const struct attribute *attr, 560 const void *ns) 561 { 562 } 563 564 static inline bool sysfs_remove_file_self(struct kobject *kobj, 565 const struct attribute *attr) 566 { 567 return false; 568 } 569 570 static inline void sysfs_remove_files(struct kobject *kobj, 571 const struct attribute * const *attr) 572 { 573 } 574 575 static inline int sysfs_create_bin_file(struct kobject *kobj, 576 const struct bin_attribute *attr) 577 { 578 return 0; 579 } 580 581 static inline void sysfs_remove_bin_file(struct kobject *kobj, 582 const struct bin_attribute *attr) 583 { 584 } 585 586 static inline int sysfs_create_link(struct kobject *kobj, 587 struct kobject *target, const char *name) 588 { 589 return 0; 590 } 591 592 static inline int sysfs_create_link_nowarn(struct kobject *kobj, 593 struct kobject *target, 594 const char *name) 595 { 596 return 0; 597 } 598 599 static inline void sysfs_remove_link(struct kobject *kobj, const char *name) 600 { 601 } 602 603 static inline int sysfs_rename_link_ns(struct kobject *k, struct kobject *t, 604 const char *old_name, 605 const char *new_name, const void *ns) 606 { 607 return 0; 608 } 609 610 static inline void sysfs_delete_link(struct kobject *k, struct kobject *t, 611 const char *name) 612 { 613 } 614 615 static inline int sysfs_create_group(struct kobject *kobj, 616 const struct attribute_group *grp) 617 { 618 return 0; 619 } 620 621 static inline int sysfs_create_groups(struct kobject *kobj, 622 const struct attribute_group **groups) 623 { 624 return 0; 625 } 626 627 static inline int sysfs_update_groups(struct kobject *kobj, 628 const struct attribute_group **groups) 629 { 630 return 0; 631 } 632 633 static inline int sysfs_update_group(struct kobject *kobj, 634 const struct attribute_group *grp) 635 { 636 return 0; 637 } 638 639 static inline void sysfs_remove_group(struct kobject *kobj, 640 const struct attribute_group *grp) 641 { 642 } 643 644 static inline void sysfs_remove_groups(struct kobject *kobj, 645 const struct attribute_group **groups) 646 { 647 } 648 649 static inline int sysfs_add_file_to_group(struct kobject *kobj, 650 const struct attribute *attr, const char *group) 651 { 652 return 0; 653 } 654 655 static inline void sysfs_remove_file_from_group(struct kobject *kobj, 656 const struct attribute *attr, const char *group) 657 { 658 } 659 660 static inline int sysfs_merge_group(struct kobject *kobj, 661 const struct attribute_group *grp) 662 { 663 return 0; 664 } 665 666 static inline void sysfs_unmerge_group(struct kobject *kobj, 667 const struct attribute_group *grp) 668 { 669 } 670 671 static inline int sysfs_add_link_to_group(struct kobject *kobj, 672 const char *group_name, struct kobject *target, 673 const char *link_name) 674 { 675 return 0; 676 } 677 678 static inline void sysfs_remove_link_from_group(struct kobject *kobj, 679 const char *group_name, const char *link_name) 680 { 681 } 682 683 static inline int compat_only_sysfs_link_entry_to_kobj(struct kobject *kobj, 684 struct kobject *target_kobj, 685 const char *target_name, 686 const char *symlink_name) 687 { 688 return 0; 689 } 690 691 static inline void sysfs_notify(struct kobject *kobj, const char *dir, 692 const char *attr) 693 { 694 } 695 696 static inline int __must_check sysfs_init(void) 697 { 698 return 0; 699 } 700 701 static inline void sysfs_enable_ns(struct kernfs_node *kn) 702 { 703 } 704 705 static inline int sysfs_file_change_owner(struct kobject *kobj, 706 const char *name, kuid_t kuid, 707 kgid_t kgid) 708 { 709 return 0; 710 } 711 712 static inline int sysfs_link_change_owner(struct kobject *kobj, 713 struct kobject *targ, 714 const char *name, kuid_t kuid, 715 kgid_t kgid) 716 { 717 return 0; 718 } 719 720 static inline int sysfs_change_owner(struct kobject *kobj, kuid_t kuid, kgid_t kgid) 721 { 722 return 0; 723 } 724 725 static inline int sysfs_groups_change_owner(struct kobject *kobj, 726 const struct attribute_group **groups, 727 kuid_t kuid, kgid_t kgid) 728 { 729 return 0; 730 } 731 732 static inline int sysfs_group_change_owner(struct kobject *kobj, 733 const struct attribute_group *groups, 734 kuid_t kuid, kgid_t kgid) 735 { 736 return 0; 737 } 738 739 __printf(2, 3) 740 static inline int sysfs_emit(char *buf, const char *fmt, ...) 741 { 742 return 0; 743 } 744 745 __printf(3, 4) 746 static inline int sysfs_emit_at(char *buf, int at, const char *fmt, ...) 747 { 748 return 0; 749 } 750 751 static inline ssize_t sysfs_bin_attr_simple_read(struct file *file, 752 struct kobject *kobj, 753 const struct bin_attribute *attr, 754 char *buf, loff_t off, 755 size_t count) 756 { 757 return 0; 758 } 759 #endif /* CONFIG_SYSFS */ 760 761 static inline int __must_check sysfs_create_file(struct kobject *kobj, 762 const struct attribute *attr) 763 { 764 return sysfs_create_file_ns(kobj, attr, NULL); 765 } 766 767 static inline void sysfs_remove_file(struct kobject *kobj, 768 const struct attribute *attr) 769 { 770 sysfs_remove_file_ns(kobj, attr, NULL); 771 } 772 773 static inline int sysfs_rename_link(struct kobject *kobj, struct kobject *target, 774 const char *old_name, const char *new_name) 775 { 776 return sysfs_rename_link_ns(kobj, target, old_name, new_name, NULL); 777 } 778 779 static inline void sysfs_notify_dirent(struct kernfs_node *kn) 780 { 781 kernfs_notify(kn); 782 } 783 784 static inline struct kernfs_node *sysfs_get_dirent(struct kernfs_node *parent, 785 const char *name) 786 { 787 return kernfs_find_and_get(parent, name); 788 } 789 790 static inline struct kernfs_node *sysfs_get(struct kernfs_node *kn) 791 { 792 kernfs_get(kn); 793 return kn; 794 } 795 796 static inline void sysfs_put(struct kernfs_node *kn) 797 { 798 kernfs_put(kn); 799 } 800 801 #endif /* _SYSFS_H_ */ 802