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