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 18 static struct kobject *secvar_kobj; 19 static struct kset *secvar_kset; 20 21 static 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 38 static 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 54 static 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 82 data_fail: 83 kfree(data); 84 return rc; 85 } 86 87 static 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 103 static struct kobj_attribute format_attr = __ATTR_RO(format); 104 105 static struct kobj_attribute size_attr = __ATTR_RO(size); 106 107 static struct bin_attribute data_attr = __BIN_ATTR_RO(data, 0); 108 109 static struct bin_attribute update_attr = __BIN_ATTR_WO(update, 0); 110 111 static struct bin_attribute *secvar_bin_attrs[] = { 112 &data_attr, 113 &update_attr, 114 NULL, 115 }; 116 117 static struct attribute *secvar_attrs[] = { 118 &size_attr.attr, 119 NULL, 120 }; 121 122 static const struct attribute_group secvar_attr_group = { 123 .attrs = secvar_attrs, 124 .bin_attrs = secvar_bin_attrs, 125 }; 126 __ATTRIBUTE_GROUPS(secvar_attr); 127 128 static const struct kobj_type secvar_ktype = { 129 .sysfs_ops = &kobj_sysfs_ops, 130 .default_groups = secvar_attr_groups, 131 }; 132 133 static 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 148 static 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 161 static 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 184 static 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 212 static 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 227 static 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; 288 err: 289 kobject_put(secvar_kobj); 290 return rc; 291 } 292 293 late_initcall(secvar_sysfs_init); 294