1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Architecture specific sysfs attributes in /sys/kernel 4 * 5 * Copyright (C) 2007, Intel Corp. 6 * Huang Ying <ying.huang@intel.com> 7 * Copyright (C) 2013, 2013 Red Hat, Inc. 8 * Dave Young <dyoung@redhat.com> 9 */ 10 11 #include <linux/kobject.h> 12 #include <linux/string.h> 13 #include <linux/sysfs.h> 14 #include <linux/init.h> 15 #include <linux/stat.h> 16 #include <linux/slab.h> 17 #include <linux/mm.h> 18 #include <linux/io.h> 19 20 #include <asm/setup.h> 21 22 static ssize_t version_show(struct kobject *kobj, 23 struct kobj_attribute *attr, char *buf) 24 { 25 return sprintf(buf, "0x%04x\n", boot_params.hdr.version); 26 } 27 28 static struct kobj_attribute boot_params_version_attr = __ATTR_RO(version); 29 30 static ssize_t boot_params_data_read(struct file *fp, struct kobject *kobj, 31 struct bin_attribute *bin_attr, 32 char *buf, loff_t off, size_t count) 33 { 34 memcpy(buf, (void *)&boot_params + off, count); 35 return count; 36 } 37 38 static struct bin_attribute boot_params_data_attr = { 39 .attr = { 40 .name = "data", 41 .mode = S_IRUGO, 42 }, 43 .read = boot_params_data_read, 44 .size = sizeof(boot_params), 45 }; 46 47 static struct attribute *boot_params_version_attrs[] = { 48 &boot_params_version_attr.attr, 49 NULL, 50 }; 51 52 static struct bin_attribute *boot_params_data_attrs[] = { 53 &boot_params_data_attr, 54 NULL, 55 }; 56 57 static const struct attribute_group boot_params_attr_group = { 58 .attrs = boot_params_version_attrs, 59 .bin_attrs = boot_params_data_attrs, 60 }; 61 62 static int kobj_to_setup_data_nr(struct kobject *kobj, int *nr) 63 { 64 const char *name; 65 66 name = kobject_name(kobj); 67 return kstrtoint(name, 10, nr); 68 } 69 70 static int get_setup_data_paddr(int nr, u64 *paddr) 71 { 72 int i = 0; 73 struct setup_data *data; 74 u64 pa_data = boot_params.hdr.setup_data; 75 76 while (pa_data) { 77 if (nr == i) { 78 *paddr = pa_data; 79 return 0; 80 } 81 data = memremap(pa_data, sizeof(*data), MEMREMAP_WB); 82 if (!data) 83 return -ENOMEM; 84 85 pa_data = data->next; 86 memunmap(data); 87 i++; 88 } 89 return -EINVAL; 90 } 91 92 static int __init get_setup_data_size(int nr, size_t *size) 93 { 94 u64 pa_data = boot_params.hdr.setup_data, pa_next; 95 struct setup_indirect *indirect; 96 struct setup_data *data; 97 int i = 0; 98 u32 len; 99 100 while (pa_data) { 101 data = memremap(pa_data, sizeof(*data), MEMREMAP_WB); 102 if (!data) 103 return -ENOMEM; 104 pa_next = data->next; 105 106 if (nr == i) { 107 if (data->type == SETUP_INDIRECT) { 108 len = sizeof(*data) + data->len; 109 memunmap(data); 110 data = memremap(pa_data, len, MEMREMAP_WB); 111 if (!data) 112 return -ENOMEM; 113 114 indirect = (struct setup_indirect *)data->data; 115 116 if (indirect->type != SETUP_INDIRECT) 117 *size = indirect->len; 118 else 119 *size = data->len; 120 } else { 121 *size = data->len; 122 } 123 124 memunmap(data); 125 return 0; 126 } 127 128 pa_data = pa_next; 129 memunmap(data); 130 i++; 131 } 132 return -EINVAL; 133 } 134 135 static ssize_t type_show(struct kobject *kobj, 136 struct kobj_attribute *attr, char *buf) 137 { 138 struct setup_indirect *indirect; 139 struct setup_data *data; 140 int nr, ret; 141 u64 paddr; 142 u32 len; 143 144 ret = kobj_to_setup_data_nr(kobj, &nr); 145 if (ret) 146 return ret; 147 148 ret = get_setup_data_paddr(nr, &paddr); 149 if (ret) 150 return ret; 151 data = memremap(paddr, sizeof(*data), MEMREMAP_WB); 152 if (!data) 153 return -ENOMEM; 154 155 if (data->type == SETUP_INDIRECT) { 156 len = sizeof(*data) + data->len; 157 memunmap(data); 158 data = memremap(paddr, len, MEMREMAP_WB); 159 if (!data) 160 return -ENOMEM; 161 162 indirect = (struct setup_indirect *)data->data; 163 164 ret = sprintf(buf, "0x%x\n", indirect->type); 165 } else { 166 ret = sprintf(buf, "0x%x\n", data->type); 167 } 168 169 memunmap(data); 170 return ret; 171 } 172 173 static ssize_t setup_data_data_read(struct file *fp, 174 struct kobject *kobj, 175 struct bin_attribute *bin_attr, 176 char *buf, 177 loff_t off, size_t count) 178 { 179 struct setup_indirect *indirect; 180 struct setup_data *data; 181 int nr, ret = 0; 182 u64 paddr, len; 183 void *p; 184 185 ret = kobj_to_setup_data_nr(kobj, &nr); 186 if (ret) 187 return ret; 188 189 ret = get_setup_data_paddr(nr, &paddr); 190 if (ret) 191 return ret; 192 data = memremap(paddr, sizeof(*data), MEMREMAP_WB); 193 if (!data) 194 return -ENOMEM; 195 196 if (data->type == SETUP_INDIRECT) { 197 len = sizeof(*data) + data->len; 198 memunmap(data); 199 data = memremap(paddr, len, MEMREMAP_WB); 200 if (!data) 201 return -ENOMEM; 202 203 indirect = (struct setup_indirect *)data->data; 204 205 if (indirect->type != SETUP_INDIRECT) { 206 paddr = indirect->addr; 207 len = indirect->len; 208 } else { 209 /* 210 * Even though this is technically undefined, return 211 * the data as though it is a normal setup_data struct. 212 * This will at least allow it to be inspected. 213 */ 214 paddr += sizeof(*data); 215 len = data->len; 216 } 217 } else { 218 paddr += sizeof(*data); 219 len = data->len; 220 } 221 222 if (off > len) { 223 ret = -EINVAL; 224 goto out; 225 } 226 227 if (count > len - off) 228 count = len - off; 229 230 if (!count) 231 goto out; 232 233 ret = count; 234 p = memremap(paddr, len, MEMREMAP_WB); 235 if (!p) { 236 ret = -ENOMEM; 237 goto out; 238 } 239 memcpy(buf, p + off, count); 240 memunmap(p); 241 out: 242 memunmap(data); 243 return ret; 244 } 245 246 static struct kobj_attribute type_attr = __ATTR_RO(type); 247 248 static struct bin_attribute data_attr __ro_after_init = { 249 .attr = { 250 .name = "data", 251 .mode = S_IRUGO, 252 }, 253 .read = setup_data_data_read, 254 }; 255 256 static struct attribute *setup_data_type_attrs[] = { 257 &type_attr.attr, 258 NULL, 259 }; 260 261 static struct bin_attribute *setup_data_data_attrs[] = { 262 &data_attr, 263 NULL, 264 }; 265 266 static const struct attribute_group setup_data_attr_group = { 267 .attrs = setup_data_type_attrs, 268 .bin_attrs = setup_data_data_attrs, 269 }; 270 271 static int __init create_setup_data_node(struct kobject *parent, 272 struct kobject **kobjp, int nr) 273 { 274 int ret = 0; 275 size_t size; 276 struct kobject *kobj; 277 char name[16]; /* should be enough for setup_data nodes numbers */ 278 snprintf(name, 16, "%d", nr); 279 280 kobj = kobject_create_and_add(name, parent); 281 if (!kobj) 282 return -ENOMEM; 283 284 ret = get_setup_data_size(nr, &size); 285 if (ret) 286 goto out_kobj; 287 288 data_attr.size = size; 289 ret = sysfs_create_group(kobj, &setup_data_attr_group); 290 if (ret) 291 goto out_kobj; 292 *kobjp = kobj; 293 294 return 0; 295 out_kobj: 296 kobject_put(kobj); 297 return ret; 298 } 299 300 static void __init cleanup_setup_data_node(struct kobject *kobj) 301 { 302 sysfs_remove_group(kobj, &setup_data_attr_group); 303 kobject_put(kobj); 304 } 305 306 static int __init get_setup_data_total_num(u64 pa_data, int *nr) 307 { 308 int ret = 0; 309 struct setup_data *data; 310 311 *nr = 0; 312 while (pa_data) { 313 *nr += 1; 314 data = memremap(pa_data, sizeof(*data), MEMREMAP_WB); 315 if (!data) { 316 ret = -ENOMEM; 317 goto out; 318 } 319 pa_data = data->next; 320 memunmap(data); 321 } 322 323 out: 324 return ret; 325 } 326 327 static int __init create_setup_data_nodes(struct kobject *parent) 328 { 329 struct kobject *setup_data_kobj, **kobjp; 330 u64 pa_data; 331 int i, j, nr, ret = 0; 332 333 pa_data = boot_params.hdr.setup_data; 334 if (!pa_data) 335 return 0; 336 337 setup_data_kobj = kobject_create_and_add("setup_data", parent); 338 if (!setup_data_kobj) { 339 ret = -ENOMEM; 340 goto out; 341 } 342 343 ret = get_setup_data_total_num(pa_data, &nr); 344 if (ret) 345 goto out_setup_data_kobj; 346 347 kobjp = kmalloc_array(nr, sizeof(*kobjp), GFP_KERNEL); 348 if (!kobjp) { 349 ret = -ENOMEM; 350 goto out_setup_data_kobj; 351 } 352 353 for (i = 0; i < nr; i++) { 354 ret = create_setup_data_node(setup_data_kobj, kobjp + i, i); 355 if (ret) 356 goto out_clean_nodes; 357 } 358 359 kfree(kobjp); 360 return 0; 361 362 out_clean_nodes: 363 for (j = i - 1; j >= 0; j--) 364 cleanup_setup_data_node(*(kobjp + j)); 365 kfree(kobjp); 366 out_setup_data_kobj: 367 kobject_put(setup_data_kobj); 368 out: 369 return ret; 370 } 371 372 static int __init boot_params_ksysfs_init(void) 373 { 374 int ret; 375 struct kobject *boot_params_kobj; 376 377 boot_params_kobj = kobject_create_and_add("boot_params", 378 kernel_kobj); 379 if (!boot_params_kobj) { 380 ret = -ENOMEM; 381 goto out; 382 } 383 384 ret = sysfs_create_group(boot_params_kobj, &boot_params_attr_group); 385 if (ret) 386 goto out_boot_params_kobj; 387 388 ret = create_setup_data_nodes(boot_params_kobj); 389 if (ret) 390 goto out_create_group; 391 392 return 0; 393 out_create_group: 394 sysfs_remove_group(boot_params_kobj, &boot_params_attr_group); 395 out_boot_params_kobj: 396 kobject_put(boot_params_kobj); 397 out: 398 return ret; 399 } 400 401 arch_initcall(boot_params_ksysfs_init); 402