Loading...
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (C) 2019 IBM Corporation <nayna@linux.ibm.com>
4 *
5 * This code exposes secure variables to user via sysfs
6 */
7
8#define pr_fmt(fmt) "secvar-sysfs: "fmt
9
10#include <linux/slab.h>
11#include <linux/compat.h>
12#include <linux/string.h>
13#include <linux/of.h>
14#include <asm/secvar.h>
15
16#define NAME_MAX_SIZE 1024
17
18static struct kobject *secvar_kobj;
19static struct kset *secvar_kset;
20
21static ssize_t format_show(struct kobject *kobj, struct kobj_attribute *attr,
22 char *buf)
23{
24 ssize_t rc = 0;
25 struct device_node *node;
26 const char *format;
27
28 node = of_find_compatible_node(NULL, NULL, "ibm,secvar-backend");
29 if (!of_device_is_available(node)) {
30 rc = -ENODEV;
31 goto out;
32 }
33
34 rc = of_property_read_string(node, "format", &format);
35 if (rc)
36 goto out;
37
38 rc = sprintf(buf, "%s\n", format);
39
40out:
41 of_node_put(node);
42
43 return rc;
44}
45
46
47static ssize_t size_show(struct kobject *kobj, struct kobj_attribute *attr,
48 char *buf)
49{
50 uint64_t dsize;
51 int rc;
52
53 rc = secvar_ops->get(kobj->name, strlen(kobj->name) + 1, NULL, &dsize);
54 if (rc) {
55 pr_err("Error retrieving %s variable size %d\n", kobj->name,
56 rc);
57 return rc;
58 }
59
60 return sprintf(buf, "%llu\n", dsize);
61}
62
63static ssize_t data_read(struct file *filep, struct kobject *kobj,
64 struct bin_attribute *attr, char *buf, loff_t off,
65 size_t count)
66{
67 uint64_t dsize;
68 char *data;
69 int rc;
70
71 rc = secvar_ops->get(kobj->name, strlen(kobj->name) + 1, NULL, &dsize);
72 if (rc) {
73 pr_err("Error getting %s variable size %d\n", kobj->name, rc);
74 return rc;
75 }
76 pr_debug("dsize is %llu\n", dsize);
77
78 data = kzalloc(dsize, GFP_KERNEL);
79 if (!data)
80 return -ENOMEM;
81
82 rc = secvar_ops->get(kobj->name, strlen(kobj->name) + 1, data, &dsize);
83 if (rc) {
84 pr_err("Error getting %s variable %d\n", kobj->name, rc);
85 goto data_fail;
86 }
87
88 rc = memory_read_from_buffer(buf, count, &off, data, dsize);
89
90data_fail:
91 kfree(data);
92 return rc;
93}
94
95static ssize_t update_write(struct file *filep, struct kobject *kobj,
96 struct bin_attribute *attr, char *buf, loff_t off,
97 size_t count)
98{
99 int rc;
100
101 pr_debug("count is %ld\n", count);
102 rc = secvar_ops->set(kobj->name, strlen(kobj->name) + 1, buf, count);
103 if (rc) {
104 pr_err("Error setting the %s variable %d\n", kobj->name, rc);
105 return rc;
106 }
107
108 return count;
109}
110
111static struct kobj_attribute format_attr = __ATTR_RO(format);
112
113static struct kobj_attribute size_attr = __ATTR_RO(size);
114
115static struct bin_attribute data_attr = __BIN_ATTR_RO(data, 0);
116
117static struct bin_attribute update_attr = __BIN_ATTR_WO(update, 0);
118
119static struct bin_attribute *secvar_bin_attrs[] = {
120 &data_attr,
121 &update_attr,
122 NULL,
123};
124
125static struct attribute *secvar_attrs[] = {
126 &size_attr.attr,
127 NULL,
128};
129
130static const struct attribute_group secvar_attr_group = {
131 .attrs = secvar_attrs,
132 .bin_attrs = secvar_bin_attrs,
133};
134__ATTRIBUTE_GROUPS(secvar_attr);
135
136static struct kobj_type secvar_ktype = {
137 .sysfs_ops = &kobj_sysfs_ops,
138 .default_groups = secvar_attr_groups,
139};
140
141static int update_kobj_size(void)
142{
143
144 struct device_node *node;
145 u64 varsize;
146 int rc = 0;
147
148 node = of_find_compatible_node(NULL, NULL, "ibm,secvar-backend");
149 if (!of_device_is_available(node)) {
150 rc = -ENODEV;
151 goto out;
152 }
153
154 rc = of_property_read_u64(node, "max-var-size", &varsize);
155 if (rc)
156 goto out;
157
158 data_attr.size = varsize;
159 update_attr.size = varsize;
160
161out:
162 of_node_put(node);
163
164 return rc;
165}
166
167static int secvar_sysfs_load(void)
168{
169 char *name;
170 uint64_t namesize = 0;
171 struct kobject *kobj;
172 int rc;
173
174 name = kzalloc(NAME_MAX_SIZE, GFP_KERNEL);
175 if (!name)
176 return -ENOMEM;
177
178 do {
179 rc = secvar_ops->get_next(name, &namesize, NAME_MAX_SIZE);
180 if (rc) {
181 if (rc != -ENOENT)
182 pr_err("error getting secvar from firmware %d\n",
183 rc);
184 break;
185 }
186
187 kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
188 if (!kobj) {
189 rc = -ENOMEM;
190 break;
191 }
192
193 kobject_init(kobj, &secvar_ktype);
194
195 rc = kobject_add(kobj, &secvar_kset->kobj, "%s", name);
196 if (rc) {
197 pr_warn("kobject_add error %d for attribute: %s\n", rc,
198 name);
199 kobject_put(kobj);
200 kobj = NULL;
201 }
202
203 if (kobj)
204 kobject_uevent(kobj, KOBJ_ADD);
205
206 } while (!rc);
207
208 kfree(name);
209 return rc;
210}
211
212static int secvar_sysfs_init(void)
213{
214 int rc;
215
216 if (!secvar_ops) {
217 pr_warn("secvar: failed to retrieve secvar operations.\n");
218 return -ENODEV;
219 }
220
221 secvar_kobj = kobject_create_and_add("secvar", firmware_kobj);
222 if (!secvar_kobj) {
223 pr_err("secvar: Failed to create firmware kobj\n");
224 return -ENOMEM;
225 }
226
227 rc = sysfs_create_file(secvar_kobj, &format_attr.attr);
228 if (rc) {
229 kobject_put(secvar_kobj);
230 return -ENOMEM;
231 }
232
233 secvar_kset = kset_create_and_add("vars", NULL, secvar_kobj);
234 if (!secvar_kset) {
235 pr_err("secvar: sysfs kobject registration failed.\n");
236 kobject_put(secvar_kobj);
237 return -ENOMEM;
238 }
239
240 rc = update_kobj_size();
241 if (rc) {
242 pr_err("Cannot read the size of the attribute\n");
243 return rc;
244 }
245
246 secvar_sysfs_load();
247
248 return 0;
249}
250
251late_initcall(secvar_sysfs_init);
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (C) 2019 IBM Corporation <nayna@linux.ibm.com>
4 *
5 * This code exposes secure variables to user via sysfs
6 */
7
8#define pr_fmt(fmt) "secvar-sysfs: "fmt
9
10#include <linux/slab.h>
11#include <linux/compat.h>
12#include <linux/string.h>
13#include <linux/of.h>
14#include <asm/secvar.h>
15
16#define NAME_MAX_SIZE 1024
17
18static struct kobject *secvar_kobj;
19static struct kset *secvar_kset;
20
21static ssize_t format_show(struct kobject *kobj, struct kobj_attribute *attr,
22 char *buf)
23{
24 char tmp[32];
25 ssize_t len = secvar_ops->format(tmp, sizeof(tmp));
26
27 if (len > 0)
28 return sysfs_emit(buf, "%s\n", tmp);
29 else if (len < 0)
30 pr_err("Error %zd reading format string\n", len);
31 else
32 pr_err("Got empty format string from backend\n");
33
34 return -EIO;
35}
36
37
38static ssize_t size_show(struct kobject *kobj, struct kobj_attribute *attr,
39 char *buf)
40{
41 u64 dsize;
42 int rc;
43
44 rc = secvar_ops->get(kobj->name, strlen(kobj->name) + 1, NULL, &dsize);
45 if (rc) {
46 if (rc != -ENOENT)
47 pr_err("Error retrieving %s variable size %d\n", kobj->name, rc);
48 return rc;
49 }
50
51 return sysfs_emit(buf, "%llu\n", dsize);
52}
53
54static ssize_t data_read(struct file *filep, struct kobject *kobj,
55 struct bin_attribute *attr, char *buf, loff_t off,
56 size_t count)
57{
58 char *data;
59 u64 dsize;
60 int rc;
61
62 rc = secvar_ops->get(kobj->name, strlen(kobj->name) + 1, NULL, &dsize);
63 if (rc) {
64 if (rc != -ENOENT)
65 pr_err("Error getting %s variable size %d\n", kobj->name, rc);
66 return rc;
67 }
68 pr_debug("dsize is %llu\n", dsize);
69
70 data = kzalloc(dsize, GFP_KERNEL);
71 if (!data)
72 return -ENOMEM;
73
74 rc = secvar_ops->get(kobj->name, strlen(kobj->name) + 1, data, &dsize);
75 if (rc) {
76 pr_err("Error getting %s variable %d\n", kobj->name, rc);
77 goto data_fail;
78 }
79
80 rc = memory_read_from_buffer(buf, count, &off, data, dsize);
81
82data_fail:
83 kfree(data);
84 return rc;
85}
86
87static ssize_t update_write(struct file *filep, struct kobject *kobj,
88 struct bin_attribute *attr, char *buf, loff_t off,
89 size_t count)
90{
91 int rc;
92
93 pr_debug("count is %ld\n", count);
94 rc = secvar_ops->set(kobj->name, strlen(kobj->name) + 1, buf, count);
95 if (rc) {
96 pr_err("Error setting the %s variable %d\n", kobj->name, rc);
97 return rc;
98 }
99
100 return count;
101}
102
103static struct kobj_attribute format_attr = __ATTR_RO(format);
104
105static struct kobj_attribute size_attr = __ATTR_RO(size);
106
107static struct bin_attribute data_attr = __BIN_ATTR_RO(data, 0);
108
109static struct bin_attribute update_attr = __BIN_ATTR_WO(update, 0);
110
111static struct bin_attribute *secvar_bin_attrs[] = {
112 &data_attr,
113 &update_attr,
114 NULL,
115};
116
117static struct attribute *secvar_attrs[] = {
118 &size_attr.attr,
119 NULL,
120};
121
122static const struct attribute_group secvar_attr_group = {
123 .attrs = secvar_attrs,
124 .bin_attrs = secvar_bin_attrs,
125};
126__ATTRIBUTE_GROUPS(secvar_attr);
127
128static const struct kobj_type secvar_ktype = {
129 .sysfs_ops = &kobj_sysfs_ops,
130 .default_groups = secvar_attr_groups,
131};
132
133static int update_kobj_size(void)
134{
135
136 u64 varsize;
137 int rc = secvar_ops->max_size(&varsize);
138
139 if (rc)
140 return rc;
141
142 data_attr.size = varsize;
143 update_attr.size = varsize;
144
145 return 0;
146}
147
148static int secvar_sysfs_config(struct kobject *kobj)
149{
150 struct attribute_group config_group = {
151 .name = "config",
152 .attrs = (struct attribute **)secvar_ops->config_attrs,
153 };
154
155 if (secvar_ops->config_attrs)
156 return sysfs_create_group(kobj, &config_group);
157
158 return 0;
159}
160
161static int add_var(const char *name)
162{
163 struct kobject *kobj;
164 int rc;
165
166 kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
167 if (!kobj)
168 return -ENOMEM;
169
170 kobject_init(kobj, &secvar_ktype);
171
172 rc = kobject_add(kobj, &secvar_kset->kobj, "%s", name);
173 if (rc) {
174 pr_warn("kobject_add error %d for attribute: %s\n", rc,
175 name);
176 kobject_put(kobj);
177 return rc;
178 }
179
180 kobject_uevent(kobj, KOBJ_ADD);
181 return 0;
182}
183
184static int secvar_sysfs_load(void)
185{
186 u64 namesize = 0;
187 char *name;
188 int rc;
189
190 name = kzalloc(NAME_MAX_SIZE, GFP_KERNEL);
191 if (!name)
192 return -ENOMEM;
193
194 do {
195 rc = secvar_ops->get_next(name, &namesize, NAME_MAX_SIZE);
196 if (rc) {
197 if (rc != -ENOENT)
198 pr_err("error getting secvar from firmware %d\n", rc);
199 else
200 rc = 0;
201
202 break;
203 }
204
205 rc = add_var(name);
206 } while (!rc);
207
208 kfree(name);
209 return rc;
210}
211
212static int secvar_sysfs_load_static(void)
213{
214 const char * const *name_ptr = secvar_ops->var_names;
215 int rc;
216
217 while (*name_ptr) {
218 rc = add_var(*name_ptr);
219 if (rc)
220 return rc;
221 name_ptr++;
222 }
223
224 return 0;
225}
226
227static int secvar_sysfs_init(void)
228{
229 u64 max_size;
230 int rc;
231
232 if (!secvar_ops) {
233 pr_warn("Failed to retrieve secvar operations\n");
234 return -ENODEV;
235 }
236
237 secvar_kobj = kobject_create_and_add("secvar", firmware_kobj);
238 if (!secvar_kobj) {
239 pr_err("Failed to create firmware kobj\n");
240 return -ENOMEM;
241 }
242
243 rc = sysfs_create_file(secvar_kobj, &format_attr.attr);
244 if (rc) {
245 pr_err("Failed to create format object\n");
246 rc = -ENOMEM;
247 goto err;
248 }
249
250 secvar_kset = kset_create_and_add("vars", NULL, secvar_kobj);
251 if (!secvar_kset) {
252 pr_err("sysfs kobject registration failed\n");
253 rc = -ENOMEM;
254 goto err;
255 }
256
257 rc = update_kobj_size();
258 if (rc) {
259 pr_err("Cannot read the size of the attribute\n");
260 goto err;
261 }
262
263 rc = secvar_sysfs_config(secvar_kobj);
264 if (rc) {
265 pr_err("Failed to create config directory\n");
266 goto err;
267 }
268
269 if (secvar_ops->get_next)
270 rc = secvar_sysfs_load();
271 else
272 rc = secvar_sysfs_load_static();
273
274 if (rc) {
275 pr_err("Failed to create variable attributes\n");
276 goto err;
277 }
278
279 // Due to sysfs limitations, we will only ever get a write buffer of
280 // up to 1 page in size. Print a warning if this is potentially going
281 // to cause problems, so that the user is aware.
282 secvar_ops->max_size(&max_size);
283 if (max_size > PAGE_SIZE)
284 pr_warn_ratelimited("PAGE_SIZE (%lu) is smaller than maximum object size (%llu), writes are limited to PAGE_SIZE\n",
285 PAGE_SIZE, max_size);
286
287 return 0;
288err:
289 kobject_put(secvar_kobj);
290 return rc;
291}
292
293late_initcall(secvar_sysfs_init);