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