[mirror_ubuntu-bionic-kernel.git] / kernel / ksysfs.c

/*
 * kernel/ksysfs.c - sysfs attributes in /sys/kernel, which
 * 		     are not related to any other subsystem
 *
 * Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.org>
 * 
 * This file is release under the GPLv2
 *
 */

#include <linux/kobject.h>
#include <linux/string.h>
#include <linux/sysfs.h>
#include <linux/export.h>
#include <linux/init.h>
#include <linux/kexec.h>
#include <linux/profile.h>
#include <linux/stat.h>
#include <linux/sched.h>
#include <linux/capability.h>
#include <linux/compiler.h>

#include <linux/rcupdate.h>	/* rcu_expedited and rcu_normal */

#define KERNEL_ATTR_RO(_name) \
static struct kobj_attribute _name##_attr = __ATTR_RO(_name)

#define KERNEL_ATTR_RW(_name) \
static struct kobj_attribute _name##_attr = \
	__ATTR(_name, 0644, _name##_show, _name##_store)

/* current uevent sequence number */
static ssize_t uevent_seqnum_show(struct kobject *kobj,
				  struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "%llu\n", (unsigned long long)uevent_seqnum);
}
KERNEL_ATTR_RO(uevent_seqnum);

#ifdef CONFIG_UEVENT_HELPER
/* uevent helper program, used during early boot */
static ssize_t uevent_helper_show(struct kobject *kobj,
				  struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "%s\n", uevent_helper);
}
static ssize_t uevent_helper_store(struct kobject *kobj,
				   struct kobj_attribute *attr,
				   const char *buf, size_t count)
{
	if (count+1 > UEVENT_HELPER_PATH_LEN)
		return -ENOENT;
	memcpy(uevent_helper, buf, count);
	uevent_helper[count] = '\0';
	if (count && uevent_helper[count-1] == '\n')
		uevent_helper[count-1] = '\0';
	return count;
}
KERNEL_ATTR_RW(uevent_helper);
#endif

#ifdef CONFIG_PROFILING
static ssize_t profiling_show(struct kobject *kobj,
				  struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", prof_on);
}
static ssize_t profiling_store(struct kobject *kobj,
				   struct kobj_attribute *attr,
				   const char *buf, size_t count)
{
	int ret;

	if (prof_on)
		return -EEXIST;
	/*
	 * This eventually calls into get_option() which
	 * has a ton of callers and is not const.  It is
	 * easiest to cast it away here.
	 */
	profile_setup((char *)buf);
	ret = profile_init();
	if (ret)
		return ret;
	ret = create_proc_profile();
	if (ret)
		return ret;
	return count;
}
KERNEL_ATTR_RW(profiling);
#endif

#ifdef CONFIG_KEXEC_CORE
static ssize_t kexec_loaded_show(struct kobject *kobj,
				 struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", !!kexec_image);
}
KERNEL_ATTR_RO(kexec_loaded);

static ssize_t kexec_crash_loaded_show(struct kobject *kobj,
				       struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", kexec_crash_loaded());
}
KERNEL_ATTR_RO(kexec_crash_loaded);

static ssize_t kexec_crash_size_show(struct kobject *kobj,
				       struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "%zu\n", crash_get_memory_size());
}
static ssize_t kexec_crash_size_store(struct kobject *kobj,
				   struct kobj_attribute *attr,
				   const char *buf, size_t count)
{
	unsigned long cnt;
	int ret;

	if (kstrtoul(buf, 0, &cnt))
		return -EINVAL;

	ret = crash_shrink_memory(cnt);
	return ret < 0 ? ret : count;
}
KERNEL_ATTR_RW(kexec_crash_size);

static ssize_t vmcoreinfo_show(struct kobject *kobj,
			       struct kobj_attribute *attr, char *buf)
{
	phys_addr_t vmcore_base = paddr_vmcoreinfo_note();
	return sprintf(buf, "%pa %x\n", &vmcore_base,
		       (unsigned int)sizeof(vmcoreinfo_note));
}
KERNEL_ATTR_RO(vmcoreinfo);

#endif /* CONFIG_KEXEC_CORE */

/* whether file capabilities are enabled */
static ssize_t fscaps_show(struct kobject *kobj,
				  struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", file_caps_enabled);
}
KERNEL_ATTR_RO(fscaps);

#ifndef CONFIG_TINY_RCU
int rcu_expedited;
static ssize_t rcu_expedited_show(struct kobject *kobj,
				  struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", READ_ONCE(rcu_expedited));
}
static ssize_t rcu_expedited_store(struct kobject *kobj,
				   struct kobj_attribute *attr,
				   const char *buf, size_t count)
{
	if (kstrtoint(buf, 0, &rcu_expedited))
		return -EINVAL;

	return count;
}
KERNEL_ATTR_RW(rcu_expedited);

int rcu_normal;
static ssize_t rcu_normal_show(struct kobject *kobj,
			       struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", READ_ONCE(rcu_normal));
}
static ssize_t rcu_normal_store(struct kobject *kobj,
				struct kobj_attribute *attr,
				const char *buf, size_t count)
{
	if (kstrtoint(buf, 0, &rcu_normal))
		return -EINVAL;

	return count;
}
KERNEL_ATTR_RW(rcu_normal);
#endif /* #ifndef CONFIG_TINY_RCU */

/*
 * Make /sys/kernel/notes give the raw contents of our kernel .notes section.
 */
extern const void __start_notes __weak;
extern const void __stop_notes __weak;
#define	notes_size (&__stop_notes - &__start_notes)

static ssize_t notes_read(struct file *filp, struct kobject *kobj,
			  struct bin_attribute *bin_attr,
			  char *buf, loff_t off, size_t count)
{
	memcpy(buf, &__start_notes + off, count);
	return count;
}

static struct bin_attribute notes_attr __ro_after_init  = {
	.attr = {
		.name = "notes",
		.mode = S_IRUGO,
	},
	.read = &notes_read,
};

struct kobject *kernel_kobj;
EXPORT_SYMBOL_GPL(kernel_kobj);

static struct attribute * kernel_attrs[] = {
	&fscaps_attr.attr,
	&uevent_seqnum_attr.attr,
#ifdef CONFIG_UEVENT_HELPER
	&uevent_helper_attr.attr,
#endif
#ifdef CONFIG_PROFILING
	&profiling_attr.attr,
#endif
#ifdef CONFIG_KEXEC_CORE
	&kexec_loaded_attr.attr,
	&kexec_crash_loaded_attr.attr,
	&kexec_crash_size_attr.attr,
	&vmcoreinfo_attr.attr,
#endif
#ifndef CONFIG_TINY_RCU
	&rcu_expedited_attr.attr,
	&rcu_normal_attr.attr,
#endif
	NULL
};

static struct attribute_group kernel_attr_group = {
	.attrs = kernel_attrs,
};

static int __init ksysfs_init(void)
{
	int error;

	kernel_kobj = kobject_create_and_add("kernel", NULL);
	if (!kernel_kobj) {
		error = -ENOMEM;
		goto exit;
	}
	error = sysfs_create_group(kernel_kobj, &kernel_attr_group);
	if (error)
		goto kset_exit;

	if (notes_size > 0) {
		notes_attr.size = notes_size;
		error = sysfs_create_bin_file(kernel_kobj, &notes_attr);
		if (error)
			goto group_exit;
	}

	return 0;

group_exit:
	sysfs_remove_group(kernel_kobj, &kernel_attr_group);
kset_exit:
	kobject_put(kernel_kobj);
exit:
	return error;
}

core_initcall(ksysfs_init);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* kernel/ksysfs.c - sysfs attributes in /sys/kernel, which
	3	* are not related to any other subsystem
	4	*
	5	* Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.org>
	6	*
	7	* This file is release under the GPLv2
	8	*
	9	*/
	10
1da177e4 LT	11	#include <linux/kobject.h>
	12	#include <linux/string.h>
	13	#include <linux/sysfs.h>
9984de1a	14	#include <linux/export.h>
1da177e4	15	#include <linux/init.h>
c330dda9	16	#include <linux/kexec.h>
22b8ce94	17	#include <linux/profile.h>
1596425f	18	#include <linux/stat.h>
5cb350ba	19	#include <linux/sched.h>
088ab0b4	20	#include <linux/capability.h>
52f5684c	21	#include <linux/compiler.h>
1da177e4	22
5a9be7c6	23	#include <linux/rcupdate.h> /* rcu_expedited and rcu_normal */
7a754743	24
1da177e4	25	#define KERNEL_ATTR_RO(_name) \
386f275f	26	static struct kobj_attribute _name##_attr = __ATTR_RO(_name)
1da177e4 LT	27
1da177e4 LT	28	#define KERNEL_ATTR_RW(_name) \
386f275f	29	static struct kobj_attribute _name##_attr = \
1da177e4 LT	30	__ATTR(_name, 0644, _name##_show, _name##_store)
1da177e4 LT	31
0f76e5ac	32	/* current uevent sequence number */
386f275f KS	33	static ssize_t uevent_seqnum_show(struct kobject *kobj,
386f275f KS	34	struct kobj_attribute attr, char buf)
1da177e4	35	{
386f275f	36	return sprintf(buf, "%llu\n", (unsigned long long)uevent_seqnum);
1da177e4	37	}
0f76e5ac KS	38	KERNEL_ATTR_RO(uevent_seqnum);
0f76e5ac KS	39
86d56134	40	#ifdef CONFIG_UEVENT_HELPER
af665852	41	/* uevent helper program, used during early boot */
386f275f KS	42	static ssize_t uevent_helper_show(struct kobject *kobj,
386f275f KS	43	struct kobj_attribute attr, char buf)
0f76e5ac	44	{
386f275f	45	return sprintf(buf, "%s\n", uevent_helper);
0f76e5ac	46	}
386f275f KS	47	static ssize_t uevent_helper_store(struct kobject *kobj,
	48	struct kobj_attribute *attr,
	49	const char *buf, size_t count)
0f76e5ac	50	{
312c004d	51	if (count+1 > UEVENT_HELPER_PATH_LEN)
0f76e5ac	52	return -ENOENT;
386f275f	53	memcpy(uevent_helper, buf, count);
312c004d KS	54	uevent_helper[count] = '\0';
	55	if (count && uevent_helper[count-1] == '\n')
	56	uevent_helper[count-1] = '\0';
0f76e5ac KS	57	return count;
	58	}
	59	KERNEL_ATTR_RW(uevent_helper);
86d56134	60	#endif
1da177e4	61
22b8ce94 DH	62	#ifdef CONFIG_PROFILING
	63	static ssize_t profiling_show(struct kobject *kobj,
	64	struct kobj_attribute attr, char buf)
	65	{
	66	return sprintf(buf, "%d\n", prof_on);
	67	}
	68	static ssize_t profiling_store(struct kobject *kobj,
	69	struct kobj_attribute *attr,
	70	const char *buf, size_t count)
	71	{
	72	int ret;
	73
	74	if (prof_on)
	75	return -EEXIST;
	76	/*
	77	* This eventually calls into get_option() which
	78	* has a ton of callers and is not const. It is
	79	* easiest to cast it away here.
	80	*/
	81	profile_setup((char *)buf);
	82	ret = profile_init();
	83	if (ret)
	84	return ret;
	85	ret = create_proc_profile();
	86	if (ret)
	87	return ret;
	88	return count;
	89	}
	90	KERNEL_ATTR_RW(profiling);
	91	#endif
	92
2965faa5	93	#ifdef CONFIG_KEXEC_CORE
386f275f KS	94	static ssize_t kexec_loaded_show(struct kobject *kobj,
386f275f KS	95	struct kobj_attribute attr, char buf)
c330dda9	96	{
386f275f	97	return sprintf(buf, "%d\n", !!kexec_image);
c330dda9 JM	98	}
	99	KERNEL_ATTR_RO(kexec_loaded);
	100
386f275f KS	101	static ssize_t kexec_crash_loaded_show(struct kobject *kobj,
386f275f KS	102	struct kobj_attribute attr, char buf)
c330dda9	103	{
21db79e8	104	return sprintf(buf, "%d\n", kexec_crash_loaded());
c330dda9 JM	105	}
c330dda9 JM	106	KERNEL_ATTR_RO(kexec_crash_loaded);
fd59d231	107
06a7f711 AW	108	static ssize_t kexec_crash_size_show(struct kobject *kobj,
	109	struct kobj_attribute attr, char buf)
	110	{
	111	return sprintf(buf, "%zu\n", crash_get_memory_size());
	112	}
	113	static ssize_t kexec_crash_size_store(struct kobject *kobj,
	114	struct kobj_attribute *attr,
	115	const char *buf, size_t count)
	116	{
	117	unsigned long cnt;
	118	int ret;
	119
6072ddc8	120	if (kstrtoul(buf, 0, &cnt))
06a7f711 AW	121	return -EINVAL;
	122
	123	ret = crash_shrink_memory(cnt);
	124	return ret < 0 ? ret : count;
	125	}
	126	KERNEL_ATTR_RW(kexec_crash_size);
	127
386f275f KS	128	static ssize_t vmcoreinfo_show(struct kobject *kobj,
386f275f KS	129	struct kobj_attribute attr, char buf)
fd59d231	130	{
dae28018 RK	131	phys_addr_t vmcore_base = paddr_vmcoreinfo_note();
dae28018 RK	132	return sprintf(buf, "%pa %x\n", &vmcore_base,
77019967	133	(unsigned int)sizeof(vmcoreinfo_note));
fd59d231 KO	134	}
	135	KERNEL_ATTR_RO(vmcoreinfo);
	136
2965faa5	137	#endif /* CONFIG_KEXEC_CORE */
c330dda9	138
088ab0b4 LN	139	/* whether file capabilities are enabled */
	140	static ssize_t fscaps_show(struct kobject *kobj,
	141	struct kobj_attribute attr, char buf)
	142	{
	143	return sprintf(buf, "%d\n", file_caps_enabled);
	144	}
	145	KERNEL_ATTR_RO(fscaps);
	146
79cfea02	147	#ifndef CONFIG_TINY_RCU
3705b88d AM	148	int rcu_expedited;
	149	static ssize_t rcu_expedited_show(struct kobject *kobj,
	150	struct kobj_attribute attr, char buf)
	151	{
5a9be7c6	152	return sprintf(buf, "%d\n", READ_ONCE(rcu_expedited));
3705b88d AM	153	}
	154	static ssize_t rcu_expedited_store(struct kobject *kobj,
	155	struct kobj_attribute *attr,
	156	const char *buf, size_t count)
	157	{
	158	if (kstrtoint(buf, 0, &rcu_expedited))
	159	return -EINVAL;
	160
	161	return count;
	162	}
	163	KERNEL_ATTR_RW(rcu_expedited);
	164
5a9be7c6 PM	165	int rcu_normal;
	166	static ssize_t rcu_normal_show(struct kobject *kobj,
	167	struct kobj_attribute attr, char buf)
	168	{
	169	return sprintf(buf, "%d\n", READ_ONCE(rcu_normal));
	170	}
	171	static ssize_t rcu_normal_store(struct kobject *kobj,
	172	struct kobj_attribute *attr,
	173	const char *buf, size_t count)
	174	{
	175	if (kstrtoint(buf, 0, &rcu_normal))
	176	return -EINVAL;
	177
	178	return count;
	179	}
	180	KERNEL_ATTR_RW(rcu_normal);
79cfea02	181	#endif /* #ifndef CONFIG_TINY_RCU */
5a9be7c6	182
da1a679c RM	183	/*
	184	* Make /sys/kernel/notes give the raw contents of our kernel .notes section.
	185	*/
52f5684c GID	186	extern const void __start_notes __weak;
52f5684c GID	187	extern const void __stop_notes __weak;
da1a679c RM	188	#define notes_size (&__stop_notes - &__start_notes)
da1a679c RM	189
2c3c8bea CW	190	static ssize_t notes_read(struct file filp, struct kobject kobj,
2c3c8bea CW	191	struct bin_attribute *bin_attr,
da1a679c RM	192	char *buf, loff_t off, size_t count)
	193	{
	194	memcpy(buf, &__start_notes + off, count);
	195	return count;
	196	}
	197
738bc38d	198	static struct bin_attribute notes_attr __ro_after_init = {
da1a679c RM	199	.attr = {
	200	.name = "notes",
	201	.mode = S_IRUGO,
	202	},
	203	.read = &notes_read,
	204	};
	205
0ff21e46 GKH	206	struct kobject *kernel_kobj;
0ff21e46 GKH	207	EXPORT_SYMBOL_GPL(kernel_kobj);
1da177e4 LT	208
1da177e4 LT	209	static struct attribute * kernel_attrs[] = {
088ab0b4	210	&fscaps_attr.attr,
0f76e5ac	211	&uevent_seqnum_attr.attr,
86d56134	212	#ifdef CONFIG_UEVENT_HELPER
0f76e5ac	213	&uevent_helper_attr.attr,
86d56134	214	#endif
22b8ce94 DH	215	#ifdef CONFIG_PROFILING
	216	&profiling_attr.attr,
	217	#endif
2965faa5	218	#ifdef CONFIG_KEXEC_CORE
c330dda9 JM	219	&kexec_loaded_attr.attr,
c330dda9 JM	220	&kexec_crash_loaded_attr.attr,
06a7f711	221	&kexec_crash_size_attr.attr,
fd59d231	222	&vmcoreinfo_attr.attr,
1da177e4	223	#endif
79cfea02	224	#ifndef CONFIG_TINY_RCU
3705b88d	225	&rcu_expedited_attr.attr,
5a9be7c6	226	&rcu_normal_attr.attr,
79cfea02	227	#endif
1da177e4 LT	228	NULL
	229	};
	230
	231	static struct attribute_group kernel_attr_group = {
	232	.attrs = kernel_attrs,
	233	};
	234
	235	static int __init ksysfs_init(void)
	236	{
bd35b93d	237	int error;
1da177e4	238
0ff21e46 GKH	239	kernel_kobj = kobject_create_and_add("kernel", NULL);
0ff21e46 GKH	240	if (!kernel_kobj) {
bd35b93d GKH	241	error = -ENOMEM;
	242	goto exit;
	243	}
0ff21e46	244	error = sysfs_create_group(kernel_kobj, &kernel_attr_group);
bd35b93d GKH	245	if (error)
	246	goto kset_exit;
	247
	248	if (notes_size > 0) {
da1a679c	249	notes_attr.size = notes_size;
0ff21e46	250	error = sysfs_create_bin_file(kernel_kobj, &notes_attr);
bd35b93d GKH	251	if (error)
bd35b93d GKH	252	goto group_exit;
da1a679c RM	253	}
da1a679c RM	254
bd35b93d GKH	255	return 0;
bd35b93d GKH	256
bd35b93d	257	group_exit:
0ff21e46	258	sysfs_remove_group(kernel_kobj, &kernel_attr_group);
bd35b93d	259	kset_exit:
78a2d906	260	kobject_put(kernel_kobj);
bd35b93d	261	exit:
1da177e4 LT	262	return error;
	263	}
	264
	265	core_initcall(ksysfs_init);