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 * @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 */
94 struct 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) \
272 static const struct attribute_group *_name##_groups[] = { \
273 &_name##_group, \
274 NULL, \
275 }
276
277 #define ATTRIBUTE_GROUPS(_name) \
278 static const struct attribute_group _name##_group = { \
279 .attrs = _name##_attrs, \
280 }; \
281 __ATTRIBUTE_GROUPS(_name)
282
283 #define BIN_ATTRIBUTE_GROUPS(_name) \
284 static const struct attribute_group _name##_group = { \
285 .bin_attrs = _name##_attrs, \
286 }; \
287 __ATTRIBUTE_GROUPS(_name)
288
289 struct file;
290 struct vm_area_struct;
291 struct address_space;
292
293 struct 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) \
346 struct bin_attribute bin_attr_##_name = __BIN_ATTR(_name, _mode, _read, \
347 _write, _size)
348
349 #define BIN_ATTR_RO(_name, _size) \
350 struct bin_attribute bin_attr_##_name = __BIN_ATTR_RO(_name, _size)
351
352 #define BIN_ATTR_WO(_name, _size) \
353 struct bin_attribute bin_attr_##_name = __BIN_ATTR_WO(_name, _size)
354
355 #define BIN_ATTR_RW(_name, _size) \
356 struct 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) \
369 struct bin_attribute bin_attr_##_name = __BIN_ATTR_ADMIN_RO(_name, _size)
370
371 #define BIN_ATTR_ADMIN_RW(_name, _size) \
372 struct bin_attribute bin_attr_##_name = __BIN_ATTR_ADMIN_RW(_name, _size)
373
374 #define __BIN_ATTR_SIMPLE_RO(_name, _mode) { \
375 .attr = { .name = __stringify(_name), .mode = _mode }, \
376 .read = sysfs_bin_attr_simple_read, \
377 }
378
379 #define BIN_ATTR_SIMPLE_RO(_name) \
380 struct bin_attribute bin_attr_##_name = __BIN_ATTR_SIMPLE_RO(_name, 0444)
381
382 #define BIN_ATTR_SIMPLE_ADMIN_RO(_name) \
383 struct bin_attribute bin_attr_##_name = __BIN_ATTR_SIMPLE_RO(_name, 0400)
384
385 struct sysfs_ops {
386 ssize_t (*show)(struct kobject *, struct attribute *, char *);
387 ssize_t (*store)(struct kobject *, struct attribute *, const char *, size_t);
388 };
389
390 #ifdef CONFIG_SYSFS
391
392 int __must_check sysfs_create_dir_ns(struct kobject *kobj, const void *ns);
393 void sysfs_remove_dir(struct kobject *kobj);
394 int __must_check sysfs_rename_dir_ns(struct kobject *kobj, const char *new_name,
395 const void *new_ns);
396 int __must_check sysfs_move_dir_ns(struct kobject *kobj,
397 struct kobject *new_parent_kobj,
398 const void *new_ns);
399 int __must_check sysfs_create_mount_point(struct kobject *parent_kobj,
400 const char *name);
401 void sysfs_remove_mount_point(struct kobject *parent_kobj,
402 const char *name);
403
404 int __must_check sysfs_create_file_ns(struct kobject *kobj,
405 const struct attribute *attr,
406 const void *ns);
407 int __must_check sysfs_create_files(struct kobject *kobj,
408 const struct attribute * const *attr);
409 int __must_check sysfs_chmod_file(struct kobject *kobj,
410 const struct attribute *attr, umode_t mode);
411 struct kernfs_node *sysfs_break_active_protection(struct kobject *kobj,
412 const struct attribute *attr);
413 void sysfs_unbreak_active_protection(struct kernfs_node *kn);
414 void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr,
415 const void *ns);
416 bool sysfs_remove_file_self(struct kobject *kobj, const struct attribute *attr);
417 void sysfs_remove_files(struct kobject *kobj, const struct attribute * const *attr);
418
419 int __must_check sysfs_create_bin_file(struct kobject *kobj,
420 const struct bin_attribute *attr);
421 void sysfs_remove_bin_file(struct kobject *kobj,
422 const struct bin_attribute *attr);
423
424 int __must_check sysfs_create_link(struct kobject *kobj, struct kobject *target,
425 const char *name);
426 int __must_check sysfs_create_link_nowarn(struct kobject *kobj,
427 struct kobject *target,
428 const char *name);
429 void sysfs_remove_link(struct kobject *kobj, const char *name);
430
431 int sysfs_rename_link_ns(struct kobject *kobj, struct kobject *target,
432 const char *old_name, const char *new_name,
433 const void *new_ns);
434
435 void sysfs_delete_link(struct kobject *dir, struct kobject *targ,
436 const char *name);
437
438 int __must_check sysfs_create_group(struct kobject *kobj,
439 const struct attribute_group *grp);
440 int __must_check sysfs_create_groups(struct kobject *kobj,
441 const struct attribute_group **groups);
442 int __must_check sysfs_update_groups(struct kobject *kobj,
443 const struct attribute_group **groups);
444 int sysfs_update_group(struct kobject *kobj,
445 const struct attribute_group *grp);
446 void sysfs_remove_group(struct kobject *kobj,
447 const struct attribute_group *grp);
448 void sysfs_remove_groups(struct kobject *kobj,
449 const struct attribute_group **groups);
450 int sysfs_add_file_to_group(struct kobject *kobj,
451 const struct attribute *attr, const char *group);
452 void sysfs_remove_file_from_group(struct kobject *kobj,
453 const struct attribute *attr, const char *group);
454 int sysfs_merge_group(struct kobject *kobj,
455 const struct attribute_group *grp);
456 void sysfs_unmerge_group(struct kobject *kobj,
457 const struct attribute_group *grp);
458 int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name,
459 struct kobject *target, const char *link_name);
460 void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name,
461 const char *link_name);
462 int compat_only_sysfs_link_entry_to_kobj(struct kobject *kobj,
463 struct kobject *target_kobj,
464 const char *target_name,
465 const char *symlink_name);
466
467 void sysfs_notify(struct kobject *kobj, const char *dir, const char *attr);
468
469 int __must_check sysfs_init(void);
470
471 static inline void sysfs_enable_ns(struct kernfs_node *kn)
472 {
473 return kernfs_enable_ns(kn);
474 }
475
476 int sysfs_file_change_owner(struct kobject *kobj, const char *name, kuid_t kuid,
477 kgid_t kgid);
478 int sysfs_change_owner(struct kobject *kobj, kuid_t kuid, kgid_t kgid);
479 int sysfs_link_change_owner(struct kobject *kobj, struct kobject *targ,
480 const char *name, kuid_t kuid, kgid_t kgid);
481 int sysfs_groups_change_owner(struct kobject *kobj,
482 const struct attribute_group **groups,
483 kuid_t kuid, kgid_t kgid);
484 int sysfs_group_change_owner(struct kobject *kobj,
485 const struct attribute_group *groups, kuid_t kuid,
486 kgid_t kgid);
487 __printf(2, 3)
488 int sysfs_emit(char *buf, const char *fmt, ...);
489 __printf(3, 4)
490 int sysfs_emit_at(char *buf, int at, const char *fmt, ...);
491
492 ssize_t sysfs_bin_attr_simple_read(struct file *file, struct kobject *kobj,
493 struct bin_attribute *attr, char *buf,
494 loff_t off, size_t count);
495
496 #else /* CONFIG_SYSFS */
497
498 static inline int sysfs_create_dir_ns(struct kobject *kobj, const void *ns)
499 {
500 return 0;
501 }
502
503 static inline void sysfs_remove_dir(struct kobject *kobj)
504 {
505 }
506
507 static inline int sysfs_rename_dir_ns(struct kobject *kobj,
508 const char *new_name, const void *new_ns)
509 {
510 return 0;
511 }
512
513 static inline int sysfs_move_dir_ns(struct kobject *kobj,
514 struct kobject *new_parent_kobj,
515 const void *new_ns)
516 {
517 return 0;
518 }
519
520 static inline int sysfs_create_mount_point(struct kobject *parent_kobj,
521 const char *name)
522 {
523 return 0;
524 }
525
526 static inline void sysfs_remove_mount_point(struct kobject *parent_kobj,
527 const char *name)
528 {
529 }
530
531 static inline int sysfs_create_file_ns(struct kobject *kobj,
532 const struct attribute *attr,
533 const void *ns)
534 {
535 return 0;
536 }
537
538 static inline int sysfs_create_files(struct kobject *kobj,
539 const struct attribute * const *attr)
540 {
541 return 0;
542 }
543
544 static inline int sysfs_chmod_file(struct kobject *kobj,
545 const struct attribute *attr, umode_t mode)
546 {
547 return 0;
548 }
549
550 static inline struct kernfs_node *
551 sysfs_break_active_protection(struct kobject *kobj,
552 const struct attribute *attr)
553 {
554 return NULL;
555 }
556
557 static inline void sysfs_unbreak_active_protection(struct kernfs_node *kn)
558 {
559 }
560
561 static inline void sysfs_remove_file_ns(struct kobject *kobj,
562 const struct attribute *attr,
563 const void *ns)
564 {
565 }
566
567 static inline bool sysfs_remove_file_self(struct kobject *kobj,
568 const struct attribute *attr)
569 {
570 return false;
571 }
572
573 static inline void sysfs_remove_files(struct kobject *kobj,
574 const struct attribute * const *attr)
575 {
576 }
577
578 static inline int sysfs_create_bin_file(struct kobject *kobj,
579 const struct bin_attribute *attr)
580 {
581 return 0;
582 }
583
584 static inline void sysfs_remove_bin_file(struct kobject *kobj,
585 const struct bin_attribute *attr)
586 {
587 }
588
589 static inline int sysfs_create_link(struct kobject *kobj,
590 struct kobject *target, const char *name)
591 {
592 return 0;
593 }
594
595 static inline int sysfs_create_link_nowarn(struct kobject *kobj,
596 struct kobject *target,
597 const char *name)
598 {
599 return 0;
600 }
601
602 static inline void sysfs_remove_link(struct kobject *kobj, const char *name)
603 {
604 }
605
606 static inline int sysfs_rename_link_ns(struct kobject *k, struct kobject *t,
607 const char *old_name,
608 const char *new_name, const void *ns)
609 {
610 return 0;
611 }
612
613 static inline void sysfs_delete_link(struct kobject *k, struct kobject *t,
614 const char *name)
615 {
616 }
617
618 static inline int sysfs_create_group(struct kobject *kobj,
619 const struct attribute_group *grp)
620 {
621 return 0;
622 }
623
624 static inline int sysfs_create_groups(struct kobject *kobj,
625 const struct attribute_group **groups)
626 {
627 return 0;
628 }
629
630 static inline int sysfs_update_groups(struct kobject *kobj,
631 const struct attribute_group **groups)
632 {
633 return 0;
634 }
635
636 static inline int sysfs_update_group(struct kobject *kobj,
637 const struct attribute_group *grp)
638 {
639 return 0;
640 }
641
642 static inline void sysfs_remove_group(struct kobject *kobj,
643 const struct attribute_group *grp)
644 {
645 }
646
647 static inline void sysfs_remove_groups(struct kobject *kobj,
648 const struct attribute_group **groups)
649 {
650 }
651
652 static inline int sysfs_add_file_to_group(struct kobject *kobj,
653 const struct attribute *attr, const char *group)
654 {
655 return 0;
656 }
657
658 static inline void sysfs_remove_file_from_group(struct kobject *kobj,
659 const struct attribute *attr, const char *group)
660 {
661 }
662
663 static inline int sysfs_merge_group(struct kobject *kobj,
664 const struct attribute_group *grp)
665 {
666 return 0;
667 }
668
669 static inline void sysfs_unmerge_group(struct kobject *kobj,
670 const struct attribute_group *grp)
671 {
672 }
673
674 static inline int sysfs_add_link_to_group(struct kobject *kobj,
675 const char *group_name, struct kobject *target,
676 const char *link_name)
677 {
678 return 0;
679 }
680
681 static inline void sysfs_remove_link_from_group(struct kobject *kobj,
682 const char *group_name, const char *link_name)
683 {
684 }
685
686 static inline int compat_only_sysfs_link_entry_to_kobj(struct kobject *kobj,
687 struct kobject *target_kobj,
688 const char *target_name,
689 const char *symlink_name)
690 {
691 return 0;
692 }
693
694 static inline void sysfs_notify(struct kobject *kobj, const char *dir,
695 const char *attr)
696 {
697 }
698
699 static inline int __must_check sysfs_init(void)
700 {
701 return 0;
702 }
703
704 static inline void sysfs_enable_ns(struct kernfs_node *kn)
705 {
706 }
707
708 static inline int sysfs_file_change_owner(struct kobject *kobj,
709 const char *name, kuid_t kuid,
710 kgid_t kgid)
711 {
712 return 0;
713 }
714
715 static inline int sysfs_link_change_owner(struct kobject *kobj,
716 struct kobject *targ,
717 const char *name, kuid_t kuid,
718 kgid_t kgid)
719 {
720 return 0;
721 }
722
723 static inline int sysfs_change_owner(struct kobject *kobj, kuid_t kuid, kgid_t kgid)
724 {
725 return 0;
726 }
727
728 static inline int sysfs_groups_change_owner(struct kobject *kobj,
729 const struct attribute_group **groups,
730 kuid_t kuid, kgid_t kgid)
731 {
732 return 0;
733 }
734
735 static inline int sysfs_group_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 __printf(2, 3)
743 static inline int sysfs_emit(char *buf, const char *fmt, ...)
744 {
745 return 0;
746 }
747
748 __printf(3, 4)
749 static inline int sysfs_emit_at(char *buf, int at, const char *fmt, ...)
750 {
751 return 0;
752 }
753
754 static inline ssize_t sysfs_bin_attr_simple_read(struct file *file,
755 struct kobject *kobj,
756 struct bin_attribute *attr,
757 char *buf, loff_t off,
758 size_t count)
759 {
760 return 0;
761 }
762 #endif /* CONFIG_SYSFS */
763
764 static inline int __must_check sysfs_create_file(struct kobject *kobj,
765 const struct attribute *attr)
766 {
767 return sysfs_create_file_ns(kobj, attr, NULL);
768 }
769
770 static inline void sysfs_remove_file(struct kobject *kobj,
771 const struct attribute *attr)
772 {
773 sysfs_remove_file_ns(kobj, attr, NULL);
774 }
775
776 static inline int sysfs_rename_link(struct kobject *kobj, struct kobject *target,
777 const char *old_name, const char *new_name)
778 {
779 return sysfs_rename_link_ns(kobj, target, old_name, new_name, NULL);
780 }
781
782 static inline void sysfs_notify_dirent(struct kernfs_node *kn)
783 {
784 kernfs_notify(kn);
785 }
786
787 static inline struct kernfs_node *sysfs_get_dirent(struct kernfs_node *parent,
788 const char *name)
789 {
790 return kernfs_find_and_get(parent, name);
791 }
792
793 static inline struct kernfs_node *sysfs_get(struct kernfs_node *kn)
794 {
795 kernfs_get(kn);
796 return kn;
797 }
798
799 static inline void sysfs_put(struct kernfs_node *kn)
800 {
801 kernfs_put(kn);
802 }
803
804 #endif /* _SYSFS_H_ */
805
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.