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