Merge tag 'upstream-3.15-rc1' of git://git.infradead.org/linux-ubifs
[firefly-linux-kernel-4.4.55.git] / kernel / ksysfs.c
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
11 #include <linux/kobject.h>
12 #include <linux/string.h>
13 #include <linux/sysfs.h>
14 #include <linux/export.h>
15 #include <linux/init.h>
16 #include <linux/kexec.h>
17 #include <linux/profile.h>
18 #include <linux/stat.h>
19 #include <linux/sched.h>
20 #include <linux/capability.h>
21
22 #include <linux/rcupdate.h>     /* rcu_expedited */
23
24 #define KERNEL_ATTR_RO(_name) \
25 static struct kobj_attribute _name##_attr = __ATTR_RO(_name)
26
27 #define KERNEL_ATTR_RW(_name) \
28 static struct kobj_attribute _name##_attr = \
29         __ATTR(_name, 0644, _name##_show, _name##_store)
30
31 /* current uevent sequence number */
32 static ssize_t uevent_seqnum_show(struct kobject *kobj,
33                                   struct kobj_attribute *attr, char *buf)
34 {
35         return sprintf(buf, "%llu\n", (unsigned long long)uevent_seqnum);
36 }
37 KERNEL_ATTR_RO(uevent_seqnum);
38
39 /* uevent helper program, used during early boot */
40 static ssize_t uevent_helper_show(struct kobject *kobj,
41                                   struct kobj_attribute *attr, char *buf)
42 {
43         return sprintf(buf, "%s\n", uevent_helper);
44 }
45 static ssize_t uevent_helper_store(struct kobject *kobj,
46                                    struct kobj_attribute *attr,
47                                    const char *buf, size_t count)
48 {
49         if (count+1 > UEVENT_HELPER_PATH_LEN)
50                 return -ENOENT;
51         memcpy(uevent_helper, buf, count);
52         uevent_helper[count] = '\0';
53         if (count && uevent_helper[count-1] == '\n')
54                 uevent_helper[count-1] = '\0';
55         return count;
56 }
57 KERNEL_ATTR_RW(uevent_helper);
58
59
60 #ifdef CONFIG_PROFILING
61 static ssize_t profiling_show(struct kobject *kobj,
62                                   struct kobj_attribute *attr, char *buf)
63 {
64         return sprintf(buf, "%d\n", prof_on);
65 }
66 static ssize_t profiling_store(struct kobject *kobj,
67                                    struct kobj_attribute *attr,
68                                    const char *buf, size_t count)
69 {
70         int ret;
71
72         if (prof_on)
73                 return -EEXIST;
74         /*
75          * This eventually calls into get_option() which
76          * has a ton of callers and is not const.  It is
77          * easiest to cast it away here.
78          */
79         profile_setup((char *)buf);
80         ret = profile_init();
81         if (ret)
82                 return ret;
83         ret = create_proc_profile();
84         if (ret)
85                 return ret;
86         return count;
87 }
88 KERNEL_ATTR_RW(profiling);
89 #endif
90
91 #ifdef CONFIG_KEXEC
92 static ssize_t kexec_loaded_show(struct kobject *kobj,
93                                  struct kobj_attribute *attr, char *buf)
94 {
95         return sprintf(buf, "%d\n", !!kexec_image);
96 }
97 KERNEL_ATTR_RO(kexec_loaded);
98
99 static ssize_t kexec_crash_loaded_show(struct kobject *kobj,
100                                        struct kobj_attribute *attr, char *buf)
101 {
102         return sprintf(buf, "%d\n", !!kexec_crash_image);
103 }
104 KERNEL_ATTR_RO(kexec_crash_loaded);
105
106 static ssize_t kexec_crash_size_show(struct kobject *kobj,
107                                        struct kobj_attribute *attr, char *buf)
108 {
109         return sprintf(buf, "%zu\n", crash_get_memory_size());
110 }
111 static ssize_t kexec_crash_size_store(struct kobject *kobj,
112                                    struct kobj_attribute *attr,
113                                    const char *buf, size_t count)
114 {
115         unsigned long cnt;
116         int ret;
117
118         if (kstrtoul(buf, 0, &cnt))
119                 return -EINVAL;
120
121         ret = crash_shrink_memory(cnt);
122         return ret < 0 ? ret : count;
123 }
124 KERNEL_ATTR_RW(kexec_crash_size);
125
126 static ssize_t vmcoreinfo_show(struct kobject *kobj,
127                                struct kobj_attribute *attr, char *buf)
128 {
129         return sprintf(buf, "%lx %x\n",
130                        paddr_vmcoreinfo_note(),
131                        (unsigned int)sizeof(vmcoreinfo_note));
132 }
133 KERNEL_ATTR_RO(vmcoreinfo);
134
135 #endif /* CONFIG_KEXEC */
136
137 /* whether file capabilities are enabled */
138 static ssize_t fscaps_show(struct kobject *kobj,
139                                   struct kobj_attribute *attr, char *buf)
140 {
141         return sprintf(buf, "%d\n", file_caps_enabled);
142 }
143 KERNEL_ATTR_RO(fscaps);
144
145 int rcu_expedited;
146 static ssize_t rcu_expedited_show(struct kobject *kobj,
147                                   struct kobj_attribute *attr, char *buf)
148 {
149         return sprintf(buf, "%d\n", rcu_expedited);
150 }
151 static ssize_t rcu_expedited_store(struct kobject *kobj,
152                                    struct kobj_attribute *attr,
153                                    const char *buf, size_t count)
154 {
155         if (kstrtoint(buf, 0, &rcu_expedited))
156                 return -EINVAL;
157
158         return count;
159 }
160 KERNEL_ATTR_RW(rcu_expedited);
161
162 /*
163  * Make /sys/kernel/notes give the raw contents of our kernel .notes section.
164  */
165 extern const void __start_notes __attribute__((weak));
166 extern const void __stop_notes __attribute__((weak));
167 #define notes_size (&__stop_notes - &__start_notes)
168
169 static ssize_t notes_read(struct file *filp, struct kobject *kobj,
170                           struct bin_attribute *bin_attr,
171                           char *buf, loff_t off, size_t count)
172 {
173         memcpy(buf, &__start_notes + off, count);
174         return count;
175 }
176
177 static struct bin_attribute notes_attr = {
178         .attr = {
179                 .name = "notes",
180                 .mode = S_IRUGO,
181         },
182         .read = &notes_read,
183 };
184
185 struct kobject *kernel_kobj;
186 EXPORT_SYMBOL_GPL(kernel_kobj);
187
188 static struct attribute * kernel_attrs[] = {
189         &fscaps_attr.attr,
190         &uevent_seqnum_attr.attr,
191         &uevent_helper_attr.attr,
192 #ifdef CONFIG_PROFILING
193         &profiling_attr.attr,
194 #endif
195 #ifdef CONFIG_KEXEC
196         &kexec_loaded_attr.attr,
197         &kexec_crash_loaded_attr.attr,
198         &kexec_crash_size_attr.attr,
199         &vmcoreinfo_attr.attr,
200 #endif
201         &rcu_expedited_attr.attr,
202         NULL
203 };
204
205 static struct attribute_group kernel_attr_group = {
206         .attrs = kernel_attrs,
207 };
208
209 static int __init ksysfs_init(void)
210 {
211         int error;
212
213         kernel_kobj = kobject_create_and_add("kernel", NULL);
214         if (!kernel_kobj) {
215                 error = -ENOMEM;
216                 goto exit;
217         }
218         error = sysfs_create_group(kernel_kobj, &kernel_attr_group);
219         if (error)
220                 goto kset_exit;
221
222         if (notes_size > 0) {
223                 notes_attr.size = notes_size;
224                 error = sysfs_create_bin_file(kernel_kobj, &notes_attr);
225                 if (error)
226                         goto group_exit;
227         }
228
229         return 0;
230
231 group_exit:
232         sysfs_remove_group(kernel_kobj, &kernel_attr_group);
233 kset_exit:
234         kobject_put(kernel_kobj);
235 exit:
236         return error;
237 }
238
239 core_initcall(ksysfs_init);