sysfs.h

  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#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 */
105struct 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)				\
285static const struct attribute_group *_name##_groups[] = {	\
286	&_name##_group,						\
287	NULL,							\
288}
289
290#define ATTRIBUTE_GROUPS(_name)					\
291static 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)				\
302static const struct attribute_group _name##_group = {		\
303	.bin_attrs = _name##_attrs,				\
304};								\
305__ATTRIBUTE_GROUPS(_name)
306
307struct file;
308struct vm_area_struct;
309struct address_space;
310
311struct 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)			\
358struct bin_attribute bin_attr_##_name = __BIN_ATTR(_name, _mode, _read,	\
359					_write, _size)
360
361#define BIN_ATTR_RO(_name, _size)					\
362struct bin_attribute bin_attr_##_name = __BIN_ATTR_RO(_name, _size)
363
364#define BIN_ATTR_WO(_name, _size)					\
365struct bin_attribute bin_attr_##_name = __BIN_ATTR_WO(_name, _size)
366
367#define BIN_ATTR_RW(_name, _size)					\
368struct 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)					\
378struct bin_attribute bin_attr_##_name = __BIN_ATTR_ADMIN_RO(_name, _size)
379
380#define BIN_ATTR_ADMIN_RW(_name, _size)					\
381struct 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)					\
387struct bin_attribute bin_attr_##_name = __BIN_ATTR_SIMPLE_RO(_name, 0444)
388
389#define BIN_ATTR_SIMPLE_ADMIN_RO(_name)					\
390struct bin_attribute bin_attr_##_name = __BIN_ATTR_SIMPLE_RO(_name, 0400)
391
392struct 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
399int __must_check sysfs_create_dir_ns(struct kobject *kobj, const void *ns);
400void sysfs_remove_dir(struct kobject *kobj);
401int __must_check sysfs_rename_dir_ns(struct kobject *kobj, const char *new_name,
402				     const void *new_ns);
403int __must_check sysfs_move_dir_ns(struct kobject *kobj,
404				   struct kobject *new_parent_kobj,
405				   const void *new_ns);
406int __must_check sysfs_create_mount_point(struct kobject *parent_kobj,
407					  const char *name);
408void sysfs_remove_mount_point(struct kobject *parent_kobj,
409			      const char *name);
410
411int __must_check sysfs_create_file_ns(struct kobject *kobj,
412				      const struct attribute *attr,
413				      const void *ns);
414int __must_check sysfs_create_files(struct kobject *kobj,
415				   const struct attribute * const *attr);
416int __must_check sysfs_chmod_file(struct kobject *kobj,
417				  const struct attribute *attr, umode_t mode);
418struct kernfs_node *sysfs_break_active_protection(struct kobject *kobj,
419						  const struct attribute *attr);
420void sysfs_unbreak_active_protection(struct kernfs_node *kn);
421void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr,
422			  const void *ns);
423bool sysfs_remove_file_self(struct kobject *kobj, const struct attribute *attr);
424void sysfs_remove_files(struct kobject *kobj, const struct attribute * const *attr);
425
426int __must_check sysfs_create_bin_file(struct kobject *kobj,
427				       const struct bin_attribute *attr);
428void sysfs_remove_bin_file(struct kobject *kobj,
429			   const struct bin_attribute *attr);
430
431int __must_check sysfs_create_link(struct kobject *kobj, struct kobject *target,
432				   const char *name);
433int __must_check sysfs_create_link_nowarn(struct kobject *kobj,
434					  struct kobject *target,
435					  const char *name);
436void sysfs_remove_link(struct kobject *kobj, const char *name);
437
438int 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
442void sysfs_delete_link(struct kobject *dir, struct kobject *targ,
443			const char *name);
444
445int __must_check sysfs_create_group(struct kobject *kobj,
446				    const struct attribute_group *grp);
447int __must_check sysfs_create_groups(struct kobject *kobj,
448				     const struct attribute_group **groups);
449int __must_check sysfs_update_groups(struct kobject *kobj,
450				     const struct attribute_group **groups);
451int sysfs_update_group(struct kobject *kobj,
452		       const struct attribute_group *grp);
453void sysfs_remove_group(struct kobject *kobj,
454			const struct attribute_group *grp);
455void sysfs_remove_groups(struct kobject *kobj,
456			 const struct attribute_group **groups);
457int sysfs_add_file_to_group(struct kobject *kobj,
458			const struct attribute *attr, const char *group);
459void sysfs_remove_file_from_group(struct kobject *kobj,
460			const struct attribute *attr, const char *group);
461int sysfs_merge_group(struct kobject *kobj,
462		       const struct attribute_group *grp);
463void sysfs_unmerge_group(struct kobject *kobj,
464		       const struct attribute_group *grp);
465int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name,
466			    struct kobject *target, const char *link_name);
467void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name,
468				  const char *link_name);
469int 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
474void sysfs_notify(struct kobject *kobj, const char *dir, const char *attr);
475
476int __must_check sysfs_init(void);
477
478static inline void sysfs_enable_ns(struct kernfs_node *kn)
479{
480	return kernfs_enable_ns(kn);
481}
482
483int sysfs_file_change_owner(struct kobject *kobj, const char *name, kuid_t kuid,
484			    kgid_t kgid);
485int sysfs_change_owner(struct kobject *kobj, kuid_t kuid, kgid_t kgid);
486int sysfs_link_change_owner(struct kobject *kobj, struct kobject *targ,
487			    const char *name, kuid_t kuid, kgid_t kgid);
488int sysfs_groups_change_owner(struct kobject *kobj,
489			      const struct attribute_group **groups,
490			      kuid_t kuid, kgid_t kgid);
491int sysfs_group_change_owner(struct kobject *kobj,
492			     const struct attribute_group *groups, kuid_t kuid,
493			     kgid_t kgid);
494__printf(2, 3)
495int sysfs_emit(char *buf, const char *fmt, ...);
496__printf(3, 4)
497int sysfs_emit_at(char *buf, int at, const char *fmt, ...);
498
499ssize_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
505static inline int sysfs_create_dir_ns(struct kobject *kobj, const void *ns)
506{
507	return 0;
508}
509
510static inline void sysfs_remove_dir(struct kobject *kobj)
511{
512}
513
514static inline int sysfs_rename_dir_ns(struct kobject *kobj,
515				      const char *new_name, const void *new_ns)
516{
517	return 0;
518}
519
520static 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
527static inline int sysfs_create_mount_point(struct kobject *parent_kobj,
528					   const char *name)
529{
530	return 0;
531}
532
533static inline void sysfs_remove_mount_point(struct kobject *parent_kobj,
534					    const char *name)
535{
536}
537
538static inline int sysfs_create_file_ns(struct kobject *kobj,
539				       const struct attribute *attr,
540				       const void *ns)
541{
542	return 0;
543}
544
545static inline int sysfs_create_files(struct kobject *kobj,
546				    const struct attribute * const *attr)
547{
548	return 0;
549}
550
551static inline int sysfs_chmod_file(struct kobject *kobj,
552				   const struct attribute *attr, umode_t mode)
553{
554	return 0;
555}
556
557static inline struct kernfs_node *
558sysfs_break_active_protection(struct kobject *kobj,
559			      const struct attribute *attr)
560{
561	return NULL;
562}
563
564static inline void sysfs_unbreak_active_protection(struct kernfs_node *kn)
565{
566}
567
568static inline void sysfs_remove_file_ns(struct kobject *kobj,
569					const struct attribute *attr,
570					const void *ns)
571{
572}
573
574static inline bool sysfs_remove_file_self(struct kobject *kobj,
575					  const struct attribute *attr)
576{
577	return false;
578}
579
580static inline void sysfs_remove_files(struct kobject *kobj,
581				     const struct attribute * const *attr)
582{
583}
584
585static inline int sysfs_create_bin_file(struct kobject *kobj,
586					const struct bin_attribute *attr)
587{
588	return 0;
589}
590
591static inline void sysfs_remove_bin_file(struct kobject *kobj,
592					 const struct bin_attribute *attr)
593{
594}
595
596static inline int sysfs_create_link(struct kobject *kobj,
597				    struct kobject *target, const char *name)
598{
599	return 0;
600}
601
602static inline int sysfs_create_link_nowarn(struct kobject *kobj,
603					   struct kobject *target,
604					   const char *name)
605{
606	return 0;
607}
608
609static inline void sysfs_remove_link(struct kobject *kobj, const char *name)
610{
611}
612
613static 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
620static inline void sysfs_delete_link(struct kobject *k, struct kobject *t,
621				     const char *name)
622{
623}
624
625static inline int sysfs_create_group(struct kobject *kobj,
626				     const struct attribute_group *grp)
627{
628	return 0;
629}
630
631static inline int sysfs_create_groups(struct kobject *kobj,
632				      const struct attribute_group **groups)
633{
634	return 0;
635}
636
637static inline int sysfs_update_groups(struct kobject *kobj,
638				      const struct attribute_group **groups)
639{
640	return 0;
641}
642
643static inline int sysfs_update_group(struct kobject *kobj,
644				const struct attribute_group *grp)
645{
646	return 0;
647}
648
649static inline void sysfs_remove_group(struct kobject *kobj,
650				      const struct attribute_group *grp)
651{
652}
653
654static inline void sysfs_remove_groups(struct kobject *kobj,
655				       const struct attribute_group **groups)
656{
657}
658
659static inline int sysfs_add_file_to_group(struct kobject *kobj,
660		const struct attribute *attr, const char *group)
661{
662	return 0;
663}
664
665static inline void sysfs_remove_file_from_group(struct kobject *kobj,
666		const struct attribute *attr, const char *group)
667{
668}
669
670static inline int sysfs_merge_group(struct kobject *kobj,
671		       const struct attribute_group *grp)
672{
673	return 0;
674}
675
676static inline void sysfs_unmerge_group(struct kobject *kobj,
677		       const struct attribute_group *grp)
678{
679}
680
681static 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
688static inline void sysfs_remove_link_from_group(struct kobject *kobj,
689		const char *group_name, const char *link_name)
690{
691}
692
693static 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
701static inline void sysfs_notify(struct kobject *kobj, const char *dir,
702				const char *attr)
703{
704}
705
706static inline int __must_check sysfs_init(void)
707{
708	return 0;
709}
710
711static inline void sysfs_enable_ns(struct kernfs_node *kn)
712{
713}
714
715static 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
722static 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
730static inline int sysfs_change_owner(struct kobject *kobj, kuid_t kuid, kgid_t kgid)
731{
732	return 0;
733}
734
735static 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
742static 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)
750static inline int sysfs_emit(char *buf, const char *fmt, ...)
751{
752	return 0;
753}
754
755__printf(3, 4)
756static inline int sysfs_emit_at(char *buf, int at, const char *fmt, ...)
757{
758	return 0;
759}
760
761static 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
771static 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
777static inline void sysfs_remove_file(struct kobject *kobj,
778				     const struct attribute *attr)
779{
780	sysfs_remove_file_ns(kobj, attr, NULL);
781}
782
783static 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
789static inline void sysfs_notify_dirent(struct kernfs_node *kn)
790{
791	kernfs_notify(kn);
792}
793
794static 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
800static inline struct kernfs_node *sysfs_get(struct kernfs_node *kn)
801{
802	kernfs_get(kn);
803	return kn;
804}
805
806static inline void sysfs_put(struct kernfs_node *kn)
807{
808	kernfs_put(kn);
809}
810
811#endif /* _SYSFS_H_ */