475 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Copyright (C) 2020 Arm Limited4 *5 * Based on arch/arm64/kernel/machine_kexec_file.c:6 * Copyright (C) 2018 Linaro Limited7 *8 * And arch/powerpc/kexec/file_load.c:9 * Copyright (C) 2016 IBM Corporation10 */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 12824 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 0x100030 31/**32 * fdt_find_and_del_mem_rsv - delete memory reservation with given address and size33 *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 */40static 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 node69 *70 * @addr_cells: Return address of the root node71 * @size_cells: Return size of the root node72 *73 * Return: 0 on success, or negative errno on error.74 */75static 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 property93 *94 * @prop: Device tree property95 * @len: Size of @prop96 * @addr: Return address of the node97 * @size: Return size of the node98 *99 * Return: 0 on success, or negative errno on error.100 */101static 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_KEXEC120/**121 * ima_get_kexec_buffer - get IMA buffer from the previous kernel122 * @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 */127int __init ima_get_kexec_buffer(void **addr, size_t *size)128{129 int ret, len;130 unsigned long tmp_addr;131 unsigned long start_pfn, end_pfn;132 size_t tmp_size;133 const void *prop;134 135 prop = of_get_property(of_chosen, "linux,ima-kexec-buffer", &len);136 if (!prop)137 return -ENOENT;138 139 ret = do_get_kexec_buffer(prop, len, &tmp_addr, &tmp_size);140 if (ret)141 return ret;142 143 /* Do some sanity on the returned size for the ima-kexec buffer */144 if (!tmp_size)145 return -ENOENT;146 147 /*148 * Calculate the PFNs for the buffer and ensure149 * they are with in addressable memory.150 */151 start_pfn = PHYS_PFN(tmp_addr);152 end_pfn = PHYS_PFN(tmp_addr + tmp_size - 1);153 if (!page_is_ram(start_pfn) || !page_is_ram(end_pfn)) {154 pr_warn("IMA buffer at 0x%lx, size = 0x%zx beyond memory\n",155 tmp_addr, tmp_size);156 return -EINVAL;157 }158 159 *addr = __va(tmp_addr);160 *size = tmp_size;161 162 return 0;163}164 165/**166 * ima_free_kexec_buffer - free memory used by the IMA buffer167 */168int __init ima_free_kexec_buffer(void)169{170 int ret;171 unsigned long addr;172 size_t size;173 struct property *prop;174 175 prop = of_find_property(of_chosen, "linux,ima-kexec-buffer", NULL);176 if (!prop)177 return -ENOENT;178 179 ret = do_get_kexec_buffer(prop->value, prop->length, &addr, &size);180 if (ret)181 return ret;182 183 ret = of_remove_property(of_chosen, prop);184 if (ret)185 return ret;186 187 memblock_free_late(addr, size);188 return 0;189}190#endif191 192/**193 * remove_ima_buffer - remove the IMA buffer property and reservation from @fdt194 *195 * @fdt: Flattened Device Tree to update196 * @chosen_node: Offset to the chosen node in the device tree197 *198 * The IMA measurement buffer is of no use to a subsequent kernel, so we always199 * remove it from the device tree.200 */201static void remove_ima_buffer(void *fdt, int chosen_node)202{203 int ret, len;204 unsigned long addr;205 size_t size;206 const void *prop;207 208 if (!IS_ENABLED(CONFIG_HAVE_IMA_KEXEC))209 return;210 211 prop = fdt_getprop(fdt, chosen_node, "linux,ima-kexec-buffer", &len);212 if (!prop)213 return;214 215 ret = do_get_kexec_buffer(prop, len, &addr, &size);216 fdt_delprop(fdt, chosen_node, "linux,ima-kexec-buffer");217 if (ret)218 return;219 220 ret = fdt_find_and_del_mem_rsv(fdt, addr, size);221 if (!ret)222 pr_debug("Removed old IMA buffer reservation.\n");223}224 225#ifdef CONFIG_IMA_KEXEC226/**227 * setup_ima_buffer - add IMA buffer information to the fdt228 * @image: kexec image being loaded.229 * @fdt: Flattened device tree for the next kernel.230 * @chosen_node: Offset to the chosen node.231 *232 * Return: 0 on success, or negative errno on error.233 */234static int setup_ima_buffer(const struct kimage *image, void *fdt,235 int chosen_node)236{237 int ret;238 239 if (!image->ima_buffer_size)240 return 0;241 242 ret = fdt_appendprop_addrrange(fdt, 0, chosen_node,243 "linux,ima-kexec-buffer",244 image->ima_buffer_addr,245 image->ima_buffer_size);246 if (ret < 0)247 return -EINVAL;248 249 ret = fdt_add_mem_rsv(fdt, image->ima_buffer_addr,250 image->ima_buffer_size);251 if (ret)252 return -EINVAL;253 254 pr_debug("IMA buffer at 0x%llx, size = 0x%zx\n",255 image->ima_buffer_addr, image->ima_buffer_size);256 257 return 0;258}259#else /* CONFIG_IMA_KEXEC */260static inline int setup_ima_buffer(const struct kimage *image, void *fdt,261 int chosen_node)262{263 return 0;264}265#endif /* CONFIG_IMA_KEXEC */266 267/*268 * of_kexec_alloc_and_setup_fdt - Alloc and setup a new Flattened Device Tree269 *270 * @image: kexec image being loaded.271 * @initrd_load_addr: Address where the next initrd will be loaded.272 * @initrd_len: Size of the next initrd, or 0 if there will be none.273 * @cmdline: Command line for the next kernel, or NULL if there will274 * be none.275 * @extra_fdt_size: Additional size for the new FDT buffer.276 *277 * Return: fdt on success, or NULL errno on error.278 */279void *of_kexec_alloc_and_setup_fdt(const struct kimage *image,280 unsigned long initrd_load_addr,281 unsigned long initrd_len,282 const char *cmdline, size_t extra_fdt_size)283{284 void *fdt;285 int ret, chosen_node, len;286 const void *prop;287 size_t fdt_size;288 289 fdt_size = fdt_totalsize(initial_boot_params) +290 (cmdline ? strlen(cmdline) : 0) +291 FDT_EXTRA_SPACE +292 extra_fdt_size;293 fdt = kvmalloc(fdt_size, GFP_KERNEL);294 if (!fdt)295 return NULL;296 297 ret = fdt_open_into(initial_boot_params, fdt, fdt_size);298 if (ret < 0) {299 pr_err("Error %d setting up the new device tree.\n", ret);300 goto out;301 }302 303 /* Remove memory reservation for the current device tree. */304 ret = fdt_find_and_del_mem_rsv(fdt, __pa(initial_boot_params),305 fdt_totalsize(initial_boot_params));306 if (ret == -EINVAL) {307 pr_err("Error removing memory reservation.\n");308 goto out;309 }310 311 chosen_node = fdt_path_offset(fdt, "/chosen");312 if (chosen_node == -FDT_ERR_NOTFOUND)313 chosen_node = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"),314 "chosen");315 if (chosen_node < 0) {316 ret = chosen_node;317 goto out;318 }319 320 ret = fdt_delprop(fdt, chosen_node, "linux,elfcorehdr");321 if (ret && ret != -FDT_ERR_NOTFOUND)322 goto out;323 ret = fdt_delprop(fdt, chosen_node, "linux,usable-memory-range");324 if (ret && ret != -FDT_ERR_NOTFOUND)325 goto out;326 327 /* Did we boot using an initrd? */328 prop = fdt_getprop(fdt, chosen_node, "linux,initrd-start", &len);329 if (prop) {330 u64 tmp_start, tmp_end, tmp_size;331 332 tmp_start = of_read_number(prop, len / 4);333 334 prop = fdt_getprop(fdt, chosen_node, "linux,initrd-end", &len);335 if (!prop) {336 ret = -EINVAL;337 goto out;338 }339 340 tmp_end = of_read_number(prop, len / 4);341 342 /*343 * kexec reserves exact initrd size, while firmware may344 * reserve a multiple of PAGE_SIZE, so check for both.345 */346 tmp_size = tmp_end - tmp_start;347 ret = fdt_find_and_del_mem_rsv(fdt, tmp_start, tmp_size);348 if (ret == -ENOENT)349 ret = fdt_find_and_del_mem_rsv(fdt, tmp_start,350 round_up(tmp_size, PAGE_SIZE));351 if (ret == -EINVAL)352 goto out;353 }354 355 /* add initrd-* */356 if (initrd_load_addr) {357 ret = fdt_setprop_u64(fdt, chosen_node, "linux,initrd-start",358 initrd_load_addr);359 if (ret)360 goto out;361 362 ret = fdt_setprop_u64(fdt, chosen_node, "linux,initrd-end",363 initrd_load_addr + initrd_len);364 if (ret)365 goto out;366 367 ret = fdt_add_mem_rsv(fdt, initrd_load_addr, initrd_len);368 if (ret)369 goto out;370 371 } else {372 ret = fdt_delprop(fdt, chosen_node, "linux,initrd-start");373 if (ret && (ret != -FDT_ERR_NOTFOUND))374 goto out;375 376 ret = fdt_delprop(fdt, chosen_node, "linux,initrd-end");377 if (ret && (ret != -FDT_ERR_NOTFOUND))378 goto out;379 }380 381 if (image->type == KEXEC_TYPE_CRASH) {382 /* add linux,elfcorehdr */383 ret = fdt_appendprop_addrrange(fdt, 0, chosen_node,384 "linux,elfcorehdr", image->elf_load_addr,385 image->elf_headers_sz);386 if (ret)387 goto out;388 389 /*390 * Avoid elfcorehdr from being stomped on in kdump kernel by391 * setting up memory reserve map.392 */393 ret = fdt_add_mem_rsv(fdt, image->elf_load_addr,394 image->elf_headers_sz);395 if (ret)396 goto out;397 398#ifdef CONFIG_CRASH_DUMP399 /* add linux,usable-memory-range */400 ret = fdt_appendprop_addrrange(fdt, 0, chosen_node,401 "linux,usable-memory-range", crashk_res.start,402 crashk_res.end - crashk_res.start + 1);403 if (ret)404 goto out;405 406 if (crashk_low_res.end) {407 ret = fdt_appendprop_addrrange(fdt, 0, chosen_node,408 "linux,usable-memory-range",409 crashk_low_res.start,410 crashk_low_res.end - crashk_low_res.start + 1);411 if (ret)412 goto out;413 }414#endif415 }416 417 /* add bootargs */418 if (cmdline) {419 ret = fdt_setprop_string(fdt, chosen_node, "bootargs", cmdline);420 if (ret)421 goto out;422 } else {423 ret = fdt_delprop(fdt, chosen_node, "bootargs");424 if (ret && (ret != -FDT_ERR_NOTFOUND))425 goto out;426 }427 428 /* add kaslr-seed */429 ret = fdt_delprop(fdt, chosen_node, "kaslr-seed");430 if (ret == -FDT_ERR_NOTFOUND)431 ret = 0;432 else if (ret)433 goto out;434 435 if (rng_is_initialized()) {436 u64 seed = get_random_u64();437 438 ret = fdt_setprop_u64(fdt, chosen_node, "kaslr-seed", seed);439 if (ret)440 goto out;441 } else {442 pr_notice("RNG is not initialised: omitting \"%s\" property\n",443 "kaslr-seed");444 }445 446 /* add rng-seed */447 if (rng_is_initialized()) {448 void *rng_seed;449 450 ret = fdt_setprop_placeholder(fdt, chosen_node, "rng-seed",451 RNG_SEED_SIZE, &rng_seed);452 if (ret)453 goto out;454 get_random_bytes(rng_seed, RNG_SEED_SIZE);455 } else {456 pr_notice("RNG is not initialised: omitting \"%s\" property\n",457 "rng-seed");458 }459 460 ret = fdt_setprop(fdt, chosen_node, "linux,booted-from-kexec", NULL, 0);461 if (ret)462 goto out;463 464 remove_ima_buffer(fdt, chosen_node);465 ret = setup_ima_buffer(image, fdt, fdt_path_offset(fdt, "/chosen"));466 467out:468 if (ret) {469 kvfree(fdt);470 fdt = NULL;471 }472 473 return fdt;474}475