[linux-block.git] / fs / erofs / sysfs.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C), 2008-2021, OPPO Mobile Comm Corp., Ltd.
 *             https://www.oppo.com/
 */
#include <linux/sysfs.h>
#include <linux/kobject.h>

#include "internal.h"

enum {
	attr_feature,
	attr_pointer_ui,
	attr_pointer_bool,
};

enum {
	struct_erofs_sb_info,
	struct_erofs_mount_opts,
};

struct erofs_attr {
	struct attribute attr;
	short attr_id;
	int struct_type, offset;
};

#define EROFS_ATTR(_name, _mode, _id)					\
static struct erofs_attr erofs_attr_##_name = {				\
	.attr = {.name = __stringify(_name), .mode = _mode },		\
	.attr_id = attr_##_id,						\
}
#define EROFS_ATTR_FUNC(_name, _mode)	EROFS_ATTR(_name, _mode, _name)
#define EROFS_ATTR_FEATURE(_name)	EROFS_ATTR(_name, 0444, feature)

#define EROFS_ATTR_OFFSET(_name, _mode, _id, _struct)	\
static struct erofs_attr erofs_attr_##_name = {			\
	.attr = {.name = __stringify(_name), .mode = _mode },	\
	.attr_id = attr_##_id,					\
	.struct_type = struct_##_struct,			\
	.offset = offsetof(struct _struct, _name),\
}

#define EROFS_ATTR_RW(_name, _id, _struct)	\
	EROFS_ATTR_OFFSET(_name, 0644, _id, _struct)

#define EROFS_RO_ATTR(_name, _id, _struct)	\
	EROFS_ATTR_OFFSET(_name, 0444, _id, _struct)

#define EROFS_ATTR_RW_UI(_name, _struct)	\
	EROFS_ATTR_RW(_name, pointer_ui, _struct)

#define EROFS_ATTR_RW_BOOL(_name, _struct)	\
	EROFS_ATTR_RW(_name, pointer_bool, _struct)

#define ATTR_LIST(name) (&erofs_attr_##name.attr)

#ifdef CONFIG_EROFS_FS_ZIP
EROFS_ATTR_RW_UI(sync_decompress, erofs_mount_opts);
#endif

static struct attribute *erofs_attrs[] = {
#ifdef CONFIG_EROFS_FS_ZIP
	ATTR_LIST(sync_decompress),
#endif
	NULL,
};
ATTRIBUTE_GROUPS(erofs);

/* Features this copy of erofs supports */
EROFS_ATTR_FEATURE(zero_padding);
EROFS_ATTR_FEATURE(compr_cfgs);
EROFS_ATTR_FEATURE(big_pcluster);
EROFS_ATTR_FEATURE(chunked_file);
EROFS_ATTR_FEATURE(device_table);
EROFS_ATTR_FEATURE(compr_head2);
EROFS_ATTR_FEATURE(sb_chksum);
EROFS_ATTR_FEATURE(ztailpacking);

static struct attribute *erofs_feat_attrs[] = {
	ATTR_LIST(zero_padding),
	ATTR_LIST(compr_cfgs),
	ATTR_LIST(big_pcluster),
	ATTR_LIST(chunked_file),
	ATTR_LIST(device_table),
	ATTR_LIST(compr_head2),
	ATTR_LIST(sb_chksum),
	ATTR_LIST(ztailpacking),
	NULL,
};
ATTRIBUTE_GROUPS(erofs_feat);

static unsigned char *__struct_ptr(struct erofs_sb_info *sbi,
					  int struct_type, int offset)
{
	if (struct_type == struct_erofs_sb_info)
		return (unsigned char *)sbi + offset;
	if (struct_type == struct_erofs_mount_opts)
		return (unsigned char *)&sbi->opt + offset;
	return NULL;
}

static ssize_t erofs_attr_show(struct kobject *kobj,
				struct attribute *attr, char *buf)
{
	struct erofs_sb_info *sbi = container_of(kobj, struct erofs_sb_info,
						s_kobj);
	struct erofs_attr *a = container_of(attr, struct erofs_attr, attr);
	unsigned char *ptr = __struct_ptr(sbi, a->struct_type, a->offset);

	switch (a->attr_id) {
	case attr_feature:
		return sysfs_emit(buf, "supported\n");
	case attr_pointer_ui:
		if (!ptr)
			return 0;
		return sysfs_emit(buf, "%u\n", *(unsigned int *)ptr);
	case attr_pointer_bool:
		if (!ptr)
			return 0;
		return sysfs_emit(buf, "%d\n", *(bool *)ptr);
	}
	return 0;
}

static ssize_t erofs_attr_store(struct kobject *kobj, struct attribute *attr,
						const char *buf, size_t len)
{
	struct erofs_sb_info *sbi = container_of(kobj, struct erofs_sb_info,
						s_kobj);
	struct erofs_attr *a = container_of(attr, struct erofs_attr, attr);
	unsigned char *ptr = __struct_ptr(sbi, a->struct_type, a->offset);
	unsigned long t;
	int ret;

	switch (a->attr_id) {
	case attr_pointer_ui:
		if (!ptr)
			return 0;
		ret = kstrtoul(skip_spaces(buf), 0, &t);
		if (ret)
			return ret;
		if (t != (unsigned int)t)
			return -ERANGE;
#ifdef CONFIG_EROFS_FS_ZIP
		if (!strcmp(a->attr.name, "sync_decompress") &&
		    (t > EROFS_SYNC_DECOMPRESS_FORCE_OFF))
			return -EINVAL;
#endif
		*(unsigned int *)ptr = t;
		return len;
	case attr_pointer_bool:
		if (!ptr)
			return 0;
		ret = kstrtoul(skip_spaces(buf), 0, &t);
		if (ret)
			return ret;
		if (t != 0 && t != 1)
			return -EINVAL;
		*(bool *)ptr = !!t;
		return len;
	}
	return 0;
}

static void erofs_sb_release(struct kobject *kobj)
{
	struct erofs_sb_info *sbi = container_of(kobj, struct erofs_sb_info,
						 s_kobj);
	complete(&sbi->s_kobj_unregister);
}

static const struct sysfs_ops erofs_attr_ops = {
	.show	= erofs_attr_show,
	.store	= erofs_attr_store,
};

static struct kobj_type erofs_sb_ktype = {
	.default_groups = erofs_groups,
	.sysfs_ops	= &erofs_attr_ops,
	.release	= erofs_sb_release,
};

static struct kobj_type erofs_ktype = {
	.sysfs_ops	= &erofs_attr_ops,
};

static struct kset erofs_root = {
	.kobj	= {.ktype = &erofs_ktype},
};

static struct kobj_type erofs_feat_ktype = {
	.default_groups = erofs_feat_groups,
	.sysfs_ops	= &erofs_attr_ops,
};

static struct kobject erofs_feat = {
	.kset	= &erofs_root,
};

int erofs_register_sysfs(struct super_block *sb)
{
	struct erofs_sb_info *sbi = EROFS_SB(sb);
	int err;

	sbi->s_kobj.kset = &erofs_root;
	init_completion(&sbi->s_kobj_unregister);
	err = kobject_init_and_add(&sbi->s_kobj, &erofs_sb_ktype, NULL, "%s",
			erofs_is_fscache_mode(sb) ? sbi->opt.fsid : sb->s_id);
	if (err)
		goto put_sb_kobj;
	return 0;

put_sb_kobj:
	kobject_put(&sbi->s_kobj);
	wait_for_completion(&sbi->s_kobj_unregister);
	return err;
}

void erofs_unregister_sysfs(struct super_block *sb)
{
	struct erofs_sb_info *sbi = EROFS_SB(sb);

	if (sbi->s_kobj.state_in_sysfs) {
		kobject_del(&sbi->s_kobj);
		kobject_put(&sbi->s_kobj);
		wait_for_completion(&sbi->s_kobj_unregister);
	}
}

int __init erofs_init_sysfs(void)
{
	int ret;

	kobject_set_name(&erofs_root.kobj, "erofs");
	erofs_root.kobj.parent = fs_kobj;
	ret = kset_register(&erofs_root);
	if (ret)
		goto root_err;

	ret = kobject_init_and_add(&erofs_feat, &erofs_feat_ktype,
				   NULL, "features");
	if (ret)
		goto feat_err;
	return ret;

feat_err:
	kobject_put(&erofs_feat);
	kset_unregister(&erofs_root);
root_err:
	return ret;
}

void erofs_exit_sysfs(void)
{
	kobject_put(&erofs_feat);
	kset_unregister(&erofs_root);
}
Commit	Line	Data
168e9a76 HJ	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* Copyright (C), 2008-2021, OPPO Mobile Comm Corp., Ltd.
	4	* https://www.oppo.com/
	5	*/
	6	#include <linux/sysfs.h>
	7	#include <linux/kobject.h>
	8
	9	#include "internal.h"
	10
	11	enum {
	12	attr_feature,
	13	attr_pointer_ui,
	14	attr_pointer_bool,
	15	};
	16
	17	enum {
	18	struct_erofs_sb_info,
40452ffc	19	struct_erofs_mount_opts,
168e9a76 HJ	20	};
	21
	22	struct erofs_attr {
	23	struct attribute attr;
	24	short attr_id;
	25	int struct_type, offset;
	26	};
	27
	28	#define EROFS_ATTR(_name, _mode, _id) \
	29	static struct erofs_attr erofs_attr_##_name = { \
	30	.attr = {.name = __stringify(_name), .mode = _mode }, \
	31	.attr_id = attr_##_id, \
	32	}
	33	#define EROFS_ATTR_FUNC(_name, _mode) EROFS_ATTR(_name, _mode, _name)
	34	#define EROFS_ATTR_FEATURE(_name) EROFS_ATTR(_name, 0444, feature)
	35
	36	#define EROFS_ATTR_OFFSET(_name, _mode, _id, _struct) \
	37	static struct erofs_attr erofs_attr_##_name = { \
	38	.attr = {.name = __stringify(_name), .mode = _mode }, \
	39	.attr_id = attr_##_id, \
	40	.struct_type = struct_##_struct, \
	41	.offset = offsetof(struct _struct, _name),\
	42	}
	43
	44	#define EROFS_ATTR_RW(_name, _id, _struct) \
	45	EROFS_ATTR_OFFSET(_name, 0644, _id, _struct)
	46
	47	#define EROFS_RO_ATTR(_name, _id, _struct) \
	48	EROFS_ATTR_OFFSET(_name, 0444, _id, _struct)
	49
	50	#define EROFS_ATTR_RW_UI(_name, _struct) \
	51	EROFS_ATTR_RW(_name, pointer_ui, _struct)
	52
	53	#define EROFS_ATTR_RW_BOOL(_name, _struct) \
	54	EROFS_ATTR_RW(_name, pointer_bool, _struct)
	55
	56	#define ATTR_LIST(name) (&erofs_attr_##name.attr)
	57
40452ffc HJ	58	#ifdef CONFIG_EROFS_FS_ZIP
	59	EROFS_ATTR_RW_UI(sync_decompress, erofs_mount_opts);
	60	#endif
	61
168e9a76	62	static struct attribute *erofs_attrs[] = {
40452ffc HJ	63	#ifdef CONFIG_EROFS_FS_ZIP
	64	ATTR_LIST(sync_decompress),
	65	#endif
168e9a76 HJ	66	NULL,
	67	};
	68	ATTRIBUTE_GROUPS(erofs);
	69
	70	/* Features this copy of erofs supports */
	71	EROFS_ATTR_FEATURE(zero_padding);
	72	EROFS_ATTR_FEATURE(compr_cfgs);
	73	EROFS_ATTR_FEATURE(big_pcluster);
	74	EROFS_ATTR_FEATURE(chunked_file);
	75	EROFS_ATTR_FEATURE(device_table);
	76	EROFS_ATTR_FEATURE(compr_head2);
	77	EROFS_ATTR_FEATURE(sb_chksum);
ab92184f	78	EROFS_ATTR_FEATURE(ztailpacking);
168e9a76 HJ	79
	80	static struct attribute *erofs_feat_attrs[] = {
	81	ATTR_LIST(zero_padding),
	82	ATTR_LIST(compr_cfgs),
	83	ATTR_LIST(big_pcluster),
	84	ATTR_LIST(chunked_file),
	85	ATTR_LIST(device_table),
	86	ATTR_LIST(compr_head2),
	87	ATTR_LIST(sb_chksum),
ab92184f	88	ATTR_LIST(ztailpacking),
168e9a76 HJ	89	NULL,
	90	};
	91	ATTRIBUTE_GROUPS(erofs_feat);
	92
	93	static unsigned char __struct_ptr(struct erofs_sb_info sbi,
	94	int struct_type, int offset)
	95	{
	96	if (struct_type == struct_erofs_sb_info)
	97	return (unsigned char *)sbi + offset;
40452ffc HJ	98	if (struct_type == struct_erofs_mount_opts)
40452ffc HJ	99	return (unsigned char *)&sbi->opt + offset;
168e9a76 HJ	100	return NULL;
	101	}
	102
	103	static ssize_t erofs_attr_show(struct kobject *kobj,
	104	struct attribute attr, char buf)
	105	{
	106	struct erofs_sb_info *sbi = container_of(kobj, struct erofs_sb_info,
	107	s_kobj);
	108	struct erofs_attr *a = container_of(attr, struct erofs_attr, attr);
	109	unsigned char *ptr = __struct_ptr(sbi, a->struct_type, a->offset);
	110
	111	switch (a->attr_id) {
	112	case attr_feature:
	113	return sysfs_emit(buf, "supported\n");
	114	case attr_pointer_ui:
	115	if (!ptr)
	116	return 0;
	117	return sysfs_emit(buf, "%u\n", (unsigned int )ptr);
	118	case attr_pointer_bool:
	119	if (!ptr)
	120	return 0;
	121	return sysfs_emit(buf, "%d\n", (bool )ptr);
	122	}
	123	return 0;
	124	}
	125
	126	static ssize_t erofs_attr_store(struct kobject kobj, struct attribute attr,
	127	const char *buf, size_t len)
	128	{
	129	struct erofs_sb_info *sbi = container_of(kobj, struct erofs_sb_info,
	130	s_kobj);
	131	struct erofs_attr *a = container_of(attr, struct erofs_attr, attr);
	132	unsigned char *ptr = __struct_ptr(sbi, a->struct_type, a->offset);
	133	unsigned long t;
	134	int ret;
	135
	136	switch (a->attr_id) {
	137	case attr_pointer_ui:
	138	if (!ptr)
	139	return 0;
	140	ret = kstrtoul(skip_spaces(buf), 0, &t);
	141	if (ret)
	142	return ret;
	143	if (t != (unsigned int)t)
	144	return -ERANGE;
40452ffc HJ	145	#ifdef CONFIG_EROFS_FS_ZIP
	146	if (!strcmp(a->attr.name, "sync_decompress") &&
	147	(t > EROFS_SYNC_DECOMPRESS_FORCE_OFF))
	148	return -EINVAL;
	149	#endif
168e9a76 HJ	150	(unsigned int )ptr = t;
	151	return len;
	152	case attr_pointer_bool:
	153	if (!ptr)
	154	return 0;
	155	ret = kstrtoul(skip_spaces(buf), 0, &t);
	156	if (ret)
	157	return ret;
	158	if (t != 0 && t != 1)
	159	return -EINVAL;
	160	(bool )ptr = !!t;
	161	return len;
	162	}
	163	return 0;
	164	}
	165
	166	static void erofs_sb_release(struct kobject *kobj)
	167	{
	168	struct erofs_sb_info *sbi = container_of(kobj, struct erofs_sb_info,
	169	s_kobj);
	170	complete(&sbi->s_kobj_unregister);
	171	}
	172
	173	static const struct sysfs_ops erofs_attr_ops = {
	174	.show = erofs_attr_show,
	175	.store = erofs_attr_store,
	176	};
	177
	178	static struct kobj_type erofs_sb_ktype = {
	179	.default_groups = erofs_groups,
	180	.sysfs_ops = &erofs_attr_ops,
	181	.release = erofs_sb_release,
	182	};
	183
	184	static struct kobj_type erofs_ktype = {
	185	.sysfs_ops = &erofs_attr_ops,
	186	};
	187
	188	static struct kset erofs_root = {
	189	.kobj = {.ktype = &erofs_ktype},
	190	};
	191
	192	static struct kobj_type erofs_feat_ktype = {
	193	.default_groups = erofs_feat_groups,
	194	.sysfs_ops = &erofs_attr_ops,
	195	};
	196
	197	static struct kobject erofs_feat = {
	198	.kset = &erofs_root,
	199	};
	200
	201	int erofs_register_sysfs(struct super_block *sb)
	202	{
	203	struct erofs_sb_info *sbi = EROFS_SB(sb);
	204	int err;
	205
	206	sbi->s_kobj.kset = &erofs_root;
	207	init_completion(&sbi->s_kobj_unregister);
9c0cc9c7 JX	208	err = kobject_init_and_add(&sbi->s_kobj, &erofs_sb_ktype, NULL, "%s",
9c0cc9c7 JX	209	erofs_is_fscache_mode(sb) ? sbi->opt.fsid : sb->s_id);
168e9a76 HJ	210	if (err)
	211	goto put_sb_kobj;
	212	return 0;
	213
	214	put_sb_kobj:
	215	kobject_put(&sbi->s_kobj);
	216	wait_for_completion(&sbi->s_kobj_unregister);
	217	return err;
	218	}
	219
	220	void erofs_unregister_sysfs(struct super_block *sb)
	221	{
	222	struct erofs_sb_info *sbi = EROFS_SB(sb);
	223
a942da24 DM	224	if (sbi->s_kobj.state_in_sysfs) {
	225	kobject_del(&sbi->s_kobj);
	226	kobject_put(&sbi->s_kobj);
	227	wait_for_completion(&sbi->s_kobj_unregister);
	228	}
168e9a76 HJ	229	}
	230
	231	int __init erofs_init_sysfs(void)
	232	{
	233	int ret;
	234
	235	kobject_set_name(&erofs_root.kobj, "erofs");
	236	erofs_root.kobj.parent = fs_kobj;
	237	ret = kset_register(&erofs_root);
	238	if (ret)
	239	goto root_err;
	240
	241	ret = kobject_init_and_add(&erofs_feat, &erofs_feat_ktype,
	242	NULL, "features");
	243	if (ret)
	244	goto feat_err;
	245	return ret;
	246
	247	feat_err:
	248	kobject_put(&erofs_feat);
	249	kset_unregister(&erofs_root);
	250	root_err:
	251	return ret;
	252	}
	253
	254	void erofs_exit_sysfs(void)
	255	{
	256	kobject_put(&erofs_feat);
	257	kset_unregister(&erofs_root);
	258	}