[mirror_ubuntu-artful-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);

#endif /* CONFIG_KEXEC_CORE */

#ifdef CONFIG_CRASH_CORE

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)VMCOREINFO_NOTE_SIZE);
}
KERNEL_ATTR_RO(vmcoreinfo);

#endif /* CONFIG_CRASH_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,
#endif
#ifdef CONFIG_CRASH_CORE
	&vmcoreinfo_attr.attr,
#endif
#ifndef CONFIG_TINY_RCU
	&rcu_expedited_attr.attr,
	&rcu_normal_attr.attr,
#endif
	NULL
};

static const 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
692f66f2 HB	128	#endif /* CONFIG_KEXEC_CORE */
	129
	130	#ifdef CONFIG_CRASH_CORE
	131
386f275f KS	132	static ssize_t vmcoreinfo_show(struct kobject *kobj,
386f275f KS	133	struct kobj_attribute attr, char buf)
fd59d231	134	{
dae28018 RK	135	phys_addr_t vmcore_base = paddr_vmcoreinfo_note();
dae28018 RK	136	return sprintf(buf, "%pa %x\n", &vmcore_base,
203e9e41	137	(unsigned int)VMCOREINFO_NOTE_SIZE);
fd59d231 KO	138	}
	139	KERNEL_ATTR_RO(vmcoreinfo);
	140
692f66f2	141	#endif /* CONFIG_CRASH_CORE */
c330dda9	142
088ab0b4 LN	143	/* whether file capabilities are enabled */
	144	static ssize_t fscaps_show(struct kobject *kobj,
	145	struct kobj_attribute attr, char buf)
	146	{
	147	return sprintf(buf, "%d\n", file_caps_enabled);
	148	}
	149	KERNEL_ATTR_RO(fscaps);
	150
79cfea02	151	#ifndef CONFIG_TINY_RCU
3705b88d AM	152	int rcu_expedited;
	153	static ssize_t rcu_expedited_show(struct kobject *kobj,
	154	struct kobj_attribute attr, char buf)
	155	{
5a9be7c6	156	return sprintf(buf, "%d\n", READ_ONCE(rcu_expedited));
3705b88d AM	157	}
	158	static ssize_t rcu_expedited_store(struct kobject *kobj,
	159	struct kobj_attribute *attr,
	160	const char *buf, size_t count)
	161	{
	162	if (kstrtoint(buf, 0, &rcu_expedited))
	163	return -EINVAL;
	164
	165	return count;
	166	}
	167	KERNEL_ATTR_RW(rcu_expedited);
	168
5a9be7c6 PM	169	int rcu_normal;
	170	static ssize_t rcu_normal_show(struct kobject *kobj,
	171	struct kobj_attribute attr, char buf)
	172	{
	173	return sprintf(buf, "%d\n", READ_ONCE(rcu_normal));
	174	}
	175	static ssize_t rcu_normal_store(struct kobject *kobj,
	176	struct kobj_attribute *attr,
	177	const char *buf, size_t count)
	178	{
	179	if (kstrtoint(buf, 0, &rcu_normal))
	180	return -EINVAL;
	181
	182	return count;
	183	}
	184	KERNEL_ATTR_RW(rcu_normal);
79cfea02	185	#endif /* #ifndef CONFIG_TINY_RCU */
5a9be7c6	186
da1a679c RM	187	/*
	188	* Make /sys/kernel/notes give the raw contents of our kernel .notes section.
	189	*/
52f5684c GID	190	extern const void __start_notes __weak;
52f5684c GID	191	extern const void __stop_notes __weak;
da1a679c RM	192	#define notes_size (&__stop_notes - &__start_notes)
da1a679c RM	193
2c3c8bea CW	194	static ssize_t notes_read(struct file filp, struct kobject kobj,
2c3c8bea CW	195	struct bin_attribute *bin_attr,
da1a679c RM	196	char *buf, loff_t off, size_t count)
	197	{
	198	memcpy(buf, &__start_notes + off, count);
	199	return count;
	200	}
	201
738bc38d	202	static struct bin_attribute notes_attr __ro_after_init = {
da1a679c RM	203	.attr = {
	204	.name = "notes",
	205	.mode = S_IRUGO,
	206	},
	207	.read = &notes_read,
	208	};
	209
0ff21e46 GKH	210	struct kobject *kernel_kobj;
0ff21e46 GKH	211	EXPORT_SYMBOL_GPL(kernel_kobj);
1da177e4 LT	212
1da177e4 LT	213	static struct attribute * kernel_attrs[] = {
088ab0b4	214	&fscaps_attr.attr,
0f76e5ac	215	&uevent_seqnum_attr.attr,
86d56134	216	#ifdef CONFIG_UEVENT_HELPER
0f76e5ac	217	&uevent_helper_attr.attr,
86d56134	218	#endif
22b8ce94 DH	219	#ifdef CONFIG_PROFILING
	220	&profiling_attr.attr,
	221	#endif
2965faa5	222	#ifdef CONFIG_KEXEC_CORE
c330dda9 JM	223	&kexec_loaded_attr.attr,
c330dda9 JM	224	&kexec_crash_loaded_attr.attr,
06a7f711	225	&kexec_crash_size_attr.attr,
692f66f2 HB	226	#endif
692f66f2 HB	227	#ifdef CONFIG_CRASH_CORE
fd59d231	228	&vmcoreinfo_attr.attr,
1da177e4	229	#endif
79cfea02	230	#ifndef CONFIG_TINY_RCU
3705b88d	231	&rcu_expedited_attr.attr,
5a9be7c6	232	&rcu_normal_attr.attr,
79cfea02	233	#endif
1da177e4 LT	234	NULL
	235	};
	236
9dcdcea1	237	static const struct attribute_group kernel_attr_group = {
1da177e4 LT	238	.attrs = kernel_attrs,
	239	};
	240
	241	static int __init ksysfs_init(void)
	242	{
bd35b93d	243	int error;
1da177e4	244
0ff21e46 GKH	245	kernel_kobj = kobject_create_and_add("kernel", NULL);
0ff21e46 GKH	246	if (!kernel_kobj) {
bd35b93d GKH	247	error = -ENOMEM;
	248	goto exit;
	249	}
0ff21e46	250	error = sysfs_create_group(kernel_kobj, &kernel_attr_group);
bd35b93d GKH	251	if (error)
	252	goto kset_exit;
	253
	254	if (notes_size > 0) {
da1a679c	255	notes_attr.size = notes_size;
0ff21e46	256	error = sysfs_create_bin_file(kernel_kobj, &notes_attr);
bd35b93d GKH	257	if (error)
bd35b93d GKH	258	goto group_exit;
da1a679c RM	259	}
da1a679c RM	260
bd35b93d GKH	261	return 0;
bd35b93d GKH	262
bd35b93d	263	group_exit:
0ff21e46	264	sysfs_remove_group(kernel_kobj, &kernel_attr_group);
bd35b93d	265	kset_exit:
78a2d906	266	kobject_put(kernel_kobj);
bd35b93d	267	exit:
1da177e4 LT	268	return error;
	269	}
	270
	271	core_initcall(ksysfs_init);