1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2020 Arm Limited 4 * 5 * Based on arch/arm64/kernel/machine_kexec_file.c: 6 * Copyright (C) 2018 Linaro Limited 7 * 8 * And arch/powerpc/kexec/file_load.c: 9 * Copyright (C) 2016 IBM Corporation 10 */ 11 12 #include <linux/ima.h> 13 #include <linux/kernel.h> 14 #include <linux/kexec.h> 15 #include <linux/memblock.h> 16 #include <linux/libfdt.h> 17 #include <linux/of.h> 18 #include <linux/of_fdt.h> 19 #include <linux/random.h> 20 #include <linux/slab.h> 21 #include <linux/types.h> 22 23 #define RNG_SEED_SIZE 128 24 25 /* 26 * Additional space needed for the FDT buffer so that we can add initrd, 27 * bootargs, kaslr-seed, rng-seed, useable-memory-range and elfcorehdr. 28 */ 29 #define FDT_EXTRA_SPACE 0x1000 30 31 /** 32 * fdt_find_and_del_mem_rsv - delete memory reservation with given address and size 33 * 34 * @fdt: Flattened device tree for the current kernel. 35 * @start: Starting address of the reserved memory. 36 * @size: Size of the reserved memory. 37 * 38 * Return: 0 on success, or negative errno on error. 39 */ 40 static int fdt_find_and_del_mem_rsv(void *fdt, unsigned long start, unsigned long size) 41 { 42 int i, ret, num_rsvs = fdt_num_mem_rsv(fdt); 43 44 for (i = 0; i < num_rsvs; i++) { 45 u64 rsv_start, rsv_size; 46 47 ret = fdt_get_mem_rsv(fdt, i, &rsv_start, &rsv_size); 48 if (ret) { 49 pr_err("Malformed device tree.\n"); 50 return -EINVAL; 51 } 52 53 if (rsv_start == start && rsv_size == size) { 54 ret = fdt_del_mem_rsv(fdt, i); 55 if (ret) { 56 pr_err("Error deleting device tree reservation.\n"); 57 return -EINVAL; 58 } 59 60 return 0; 61 } 62 } 63 64 return -ENOENT; 65 } 66 67 /** 68 * get_addr_size_cells - Get address and size of root node 69 * 70 * @addr_cells: Return address of the root node 71 * @size_cells: Return size of the root node 72 * 73 * Return: 0 on success, or negative errno on error. 74 */ 75 static int get_addr_size_cells(int *addr_cells, int *size_cells) 76 { 77 struct device_node *root; 78 79 root = of_find_node_by_path("/"); 80 if (!root) 81 return -EINVAL; 82 83 *addr_cells = of_n_addr_cells(root); 84 *size_cells = of_n_size_cells(root); 85 86 of_node_put(root); 87 88 return 0; 89 } 90 91 /** 92 * do_get_kexec_buffer - Get address and size of device tree property 93 * 94 * @prop: Device tree property 95 * @len: Size of @prop 96 * @addr: Return address of the node 97 * @size: Return size of the node 98 * 99 * Return: 0 on success, or negative errno on error. 100 */ 101 static int do_get_kexec_buffer(const void *prop, int len, unsigned long *addr, 102 size_t *size) 103 { 104 int ret, addr_cells, size_cells; 105 106 ret = get_addr_size_cells(&addr_cells, &size_cells); 107 if (ret) 108 return ret; 109 110 if (len < 4 * (addr_cells + size_cells)) 111 return -ENOENT; 112 113 *addr = of_read_number(prop, addr_cells); 114 *size = of_read_number(prop + 4 * addr_cells, size_cells); 115 116 return 0; 117 } 118 119 #ifdef CONFIG_HAVE_IMA_KEXEC 120 /** 121 * ima_get_kexec_buffer - get IMA buffer from the previous kernel 122 * @addr: On successful return, set to point to the buffer contents. 123 * @size: On successful return, set to the buffer size. 124 * 125 * Return: 0 on success, negative errno on error. 126 */ 127 int __init ima_get_kexec_buffer(void **addr, size_t *size) 128 { 129 int ret, len; 130 unsigned long tmp_addr; 131 size_t tmp_size; 132 const void *prop; 133 134 prop = of_get_property(of_chosen, "linux,ima-kexec-buffer", &len); 135 if (!prop) 136 return -ENOENT; 137 138 ret = do_get_kexec_buffer(prop, len, &tmp_addr, &tmp_size); 139 if (ret) 140 return ret; 141 142 *addr = __va(tmp_addr); 143 *size = tmp_size; 144 145 return 0; 146 } 147 148 /** 149 * ima_free_kexec_buffer - free memory used by the IMA buffer 150 */ 151 int __init ima_free_kexec_buffer(void) 152 { 153 int ret; 154 unsigned long addr; 155 size_t size; 156 struct property *prop; 157 158 prop = of_find_property(of_chosen, "linux,ima-kexec-buffer", NULL); 159 if (!prop) 160 return -ENOENT; 161 162 ret = do_get_kexec_buffer(prop->value, prop->length, &addr, &size); 163 if (ret) 164 return ret; 165 166 ret = of_remove_property(of_chosen, prop); 167 if (ret) 168 return ret; 169 170 return memblock_phys_free(addr, size); 171 } 172 #endif 173 174 /** 175 * remove_ima_buffer - remove the IMA buffer property and reservation from @fdt 176 * 177 * @fdt: Flattened Device Tree to update 178 * @chosen_node: Offset to the chosen node in the device tree 179 * 180 * The IMA measurement buffer is of no use to a subsequent kernel, so we always 181 * remove it from the device tree. 182 */ 183 static void remove_ima_buffer(void *fdt, int chosen_node) 184 { 185 int ret, len; 186 unsigned long addr; 187 size_t size; 188 const void *prop; 189 190 if (!IS_ENABLED(CONFIG_HAVE_IMA_KEXEC)) 191 return; 192 193 prop = fdt_getprop(fdt, chosen_node, "linux,ima-kexec-buffer", &len); 194 if (!prop) 195 return; 196 197 ret = do_get_kexec_buffer(prop, len, &addr, &size); 198 fdt_delprop(fdt, chosen_node, "linux,ima-kexec-buffer"); 199 if (ret) 200 return; 201 202 ret = fdt_find_and_del_mem_rsv(fdt, addr, size); 203 if (!ret) 204 pr_debug("Removed old IMA buffer reservation.\n"); 205 } 206 207 #ifdef CONFIG_IMA_KEXEC 208 /** 209 * setup_ima_buffer - add IMA buffer information to the fdt 210 * @image: kexec image being loaded. 211 * @fdt: Flattened device tree for the next kernel. 212 * @chosen_node: Offset to the chosen node. 213 * 214 * Return: 0 on success, or negative errno on error. 215 */ 216 static int setup_ima_buffer(const struct kimage *image, void *fdt, 217 int chosen_node) 218 { 219 int ret; 220 221 if (!image->ima_buffer_size) 222 return 0; 223 224 ret = fdt_appendprop_addrrange(fdt, 0, chosen_node, 225 "linux,ima-kexec-buffer", 226 image->ima_buffer_addr, 227 image->ima_buffer_size); 228 if (ret < 0) 229 return -EINVAL; 230 231 ret = fdt_add_mem_rsv(fdt, image->ima_buffer_addr, 232 image->ima_buffer_size); 233 if (ret) 234 return -EINVAL; 235 236 pr_debug("IMA buffer at 0x%llx, size = 0x%zx\n", 237 image->ima_buffer_addr, image->ima_buffer_size); 238 239 return 0; 240 } 241 #else /* CONFIG_IMA_KEXEC */ 242 static inline int setup_ima_buffer(const struct kimage *image, void *fdt, 243 int chosen_node) 244 { 245 return 0; 246 } 247 #endif /* CONFIG_IMA_KEXEC */ 248 249 /* 250 * of_kexec_alloc_and_setup_fdt - Alloc and setup a new Flattened Device Tree 251 * 252 * @image: kexec image being loaded. 253 * @initrd_load_addr: Address where the next initrd will be loaded. 254 * @initrd_len: Size of the next initrd, or 0 if there will be none. 255 * @cmdline: Command line for the next kernel, or NULL if there will 256 * be none. 257 * @extra_fdt_size: Additional size for the new FDT buffer. 258 * 259 * Return: fdt on success, or NULL errno on error. 260 */ 261 void *of_kexec_alloc_and_setup_fdt(const struct kimage *image, 262 unsigned long initrd_load_addr, 263 unsigned long initrd_len, 264 const char *cmdline, size_t extra_fdt_size) 265 { 266 void *fdt; 267 int ret, chosen_node; 268 const void *prop; 269 size_t fdt_size; 270 271 fdt_size = fdt_totalsize(initial_boot_params) + 272 (cmdline ? strlen(cmdline) : 0) + 273 FDT_EXTRA_SPACE + 274 extra_fdt_size; 275 fdt = kvmalloc(fdt_size, GFP_KERNEL); 276 if (!fdt) 277 return NULL; 278 279 ret = fdt_open_into(initial_boot_params, fdt, fdt_size); 280 if (ret < 0) { 281 pr_err("Error %d setting up the new device tree.\n", ret); 282 goto out; 283 } 284 285 /* Remove memory reservation for the current device tree. */ 286 ret = fdt_find_and_del_mem_rsv(fdt, __pa(initial_boot_params), 287 fdt_totalsize(initial_boot_params)); 288 if (ret == -EINVAL) { 289 pr_err("Error removing memory reservation.\n"); 290 goto out; 291 } 292 293 chosen_node = fdt_path_offset(fdt, "/chosen"); 294 if (chosen_node == -FDT_ERR_NOTFOUND) 295 chosen_node = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), 296 "chosen"); 297 if (chosen_node < 0) { 298 ret = chosen_node; 299 goto out; 300 } 301 302 ret = fdt_delprop(fdt, chosen_node, "linux,elfcorehdr"); 303 if (ret && ret != -FDT_ERR_NOTFOUND) 304 goto out; 305 ret = fdt_delprop(fdt, chosen_node, "linux,usable-memory-range"); 306 if (ret && ret != -FDT_ERR_NOTFOUND) 307 goto out; 308 309 /* Did we boot using an initrd? */ 310 prop = fdt_getprop(fdt, chosen_node, "linux,initrd-start", NULL); 311 if (prop) { 312 u64 tmp_start, tmp_end, tmp_size; 313 314 tmp_start = fdt64_to_cpu(*((const fdt64_t *) prop)); 315 316 prop = fdt_getprop(fdt, chosen_node, "linux,initrd-end", NULL); 317 if (!prop) { 318 ret = -EINVAL; 319 goto out; 320 } 321 322 tmp_end = fdt64_to_cpu(*((const fdt64_t *) prop)); 323 324 /* 325 * kexec reserves exact initrd size, while firmware may 326 * reserve a multiple of PAGE_SIZE, so check for both. 327 */ 328 tmp_size = tmp_end - tmp_start; 329 ret = fdt_find_and_del_mem_rsv(fdt, tmp_start, tmp_size); 330 if (ret == -ENOENT) 331 ret = fdt_find_and_del_mem_rsv(fdt, tmp_start, 332 round_up(tmp_size, PAGE_SIZE)); 333 if (ret == -EINVAL) 334 goto out; 335 } 336 337 /* add initrd-* */ 338 if (initrd_load_addr) { 339 ret = fdt_setprop_u64(fdt, chosen_node, "linux,initrd-start", 340 initrd_load_addr); 341 if (ret) 342 goto out; 343 344 ret = fdt_setprop_u64(fdt, chosen_node, "linux,initrd-end", 345 initrd_load_addr + initrd_len); 346 if (ret) 347 goto out; 348 349 ret = fdt_add_mem_rsv(fdt, initrd_load_addr, initrd_len); 350 if (ret) 351 goto out; 352 353 } else { 354 ret = fdt_delprop(fdt, chosen_node, "linux,initrd-start"); 355 if (ret && (ret != -FDT_ERR_NOTFOUND)) 356 goto out; 357 358 ret = fdt_delprop(fdt, chosen_node, "linux,initrd-end"); 359 if (ret && (ret != -FDT_ERR_NOTFOUND)) 360 goto out; 361 } 362 363 if (image->type == KEXEC_TYPE_CRASH) { 364 /* add linux,elfcorehdr */ 365 ret = fdt_appendprop_addrrange(fdt, 0, chosen_node, 366 "linux,elfcorehdr", image->elf_load_addr, 367 image->elf_headers_sz); 368 if (ret) 369 goto out; 370 371 /* 372 * Avoid elfcorehdr from being stomped on in kdump kernel by 373 * setting up memory reserve map. 374 */ 375 ret = fdt_add_mem_rsv(fdt, image->elf_load_addr, 376 image->elf_headers_sz); 377 if (ret) 378 goto out; 379 380 /* add linux,usable-memory-range */ 381 ret = fdt_appendprop_addrrange(fdt, 0, chosen_node, 382 "linux,usable-memory-range", crashk_res.start, 383 crashk_res.end - crashk_res.start + 1); 384 if (ret) 385 goto out; 386 387 if (crashk_low_res.end) { 388 ret = fdt_appendprop_addrrange(fdt, 0, chosen_node, 389 "linux,usable-memory-range", 390 crashk_low_res.start, 391 crashk_low_res.end - crashk_low_res.start + 1); 392 if (ret) 393 goto out; 394 } 395 } 396 397 /* add bootargs */ 398 if (cmdline) { 399 ret = fdt_setprop_string(fdt, chosen_node, "bootargs", cmdline); 400 if (ret) 401 goto out; 402 } else { 403 ret = fdt_delprop(fdt, chosen_node, "bootargs"); 404 if (ret && (ret != -FDT_ERR_NOTFOUND)) 405 goto out; 406 } 407 408 /* add kaslr-seed */ 409 ret = fdt_delprop(fdt, chosen_node, "kaslr-seed"); 410 if (ret == -FDT_ERR_NOTFOUND) 411 ret = 0; 412 else if (ret) 413 goto out; 414 415 if (rng_is_initialized()) { 416 u64 seed = get_random_u64(); 417 418 ret = fdt_setprop_u64(fdt, chosen_node, "kaslr-seed", seed); 419 if (ret) 420 goto out; 421 } else { 422 pr_notice("RNG is not initialised: omitting \"%s\" property\n", 423 "kaslr-seed"); 424 } 425 426 /* add rng-seed */ 427 if (rng_is_initialized()) { 428 void *rng_seed; 429 430 ret = fdt_setprop_placeholder(fdt, chosen_node, "rng-seed", 431 RNG_SEED_SIZE, &rng_seed); 432 if (ret) 433 goto out; 434 get_random_bytes(rng_seed, RNG_SEED_SIZE); 435 } else { 436 pr_notice("RNG is not initialised: omitting \"%s\" property\n", 437 "rng-seed"); 438 } 439 440 ret = fdt_setprop(fdt, chosen_node, "linux,booted-from-kexec", NULL, 0); 441 if (ret) 442 goto out; 443 444 remove_ima_buffer(fdt, chosen_node); 445 ret = setup_ima_buffer(image, fdt, fdt_path_offset(fdt, "/chosen")); 446 447 out: 448 if (ret) { 449 kvfree(fdt); 450 fdt = NULL; 451 } 452 453 return fdt; 454 } 455