1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * powerpc code to implement the kexec_file_load syscall
4 *
5 * Copyright (C) 2004  Adam Litke (agl@us.ibm.com)
6 * Copyright (C) 2004  IBM Corp.
7 * Copyright (C) 2004,2005  Milton D Miller II, IBM Corporation
8 * Copyright (C) 2005  R Sharada (sharada@in.ibm.com)
9 * Copyright (C) 2006  Mohan Kumar M (mohan@in.ibm.com)
10 * Copyright (C) 2016  IBM Corporation
11 *
12 * Based on kexec-tools' kexec-elf-ppc64.c, fs2dt.c.
13 * Heavily modified for the kernel by
14 * Thiago Jung Bauermann <bauerman@linux.vnet.ibm.com>.
15 */
16
17#include <linux/slab.h>
18#include <linux/kexec.h>
19#include <linux/of_fdt.h>
20#include <linux/libfdt.h>
21#include <asm/setup.h>
22#include <asm/ima.h>
23
24#define SLAVE_CODE_SIZE		256	/* First 0x100 bytes */
25
26/**
27 * setup_kdump_cmdline - Prepend "elfcorehdr=<addr> " to command line
28 *                       of kdump kernel for exporting the core.
29 * @image:               Kexec image
30 * @cmdline:             Command line parameters to update.
31 * @cmdline_len:         Length of the cmdline parameters.
32 *
33 * kdump segment must be setup before calling this function.
34 *
35 * Returns new cmdline buffer for kdump kernel on success, NULL otherwise.
36 */
37char *setup_kdump_cmdline(struct kimage *image, char *cmdline,
38			  unsigned long cmdline_len)
39{
40	int elfcorehdr_strlen;
41	char *cmdline_ptr;
42
43	cmdline_ptr = kzalloc(COMMAND_LINE_SIZE, GFP_KERNEL);
44	if (!cmdline_ptr)
45		return NULL;
46
47	elfcorehdr_strlen = sprintf(cmdline_ptr, "elfcorehdr=0x%lx ",
48				    image->arch.elfcorehdr_addr);
49
50	if (elfcorehdr_strlen + cmdline_len > COMMAND_LINE_SIZE) {
51		pr_err("Appending elfcorehdr=<addr> exceeds cmdline size\n");
52		kfree(cmdline_ptr);
53		return NULL;
54	}
55
56	memcpy(cmdline_ptr + elfcorehdr_strlen, cmdline, cmdline_len);
57	// Ensure it's nul terminated
58	cmdline_ptr[COMMAND_LINE_SIZE - 1] = '\0';
59	return cmdline_ptr;
60}
61
62/**
63 * setup_purgatory - initialize the purgatory's global variables
64 * @image:		kexec image.
65 * @slave_code:		Slave code for the purgatory.
66 * @fdt:		Flattened device tree for the next kernel.
67 * @kernel_load_addr:	Address where the kernel is loaded.
68 * @fdt_load_addr:	Address where the flattened device tree is loaded.
69 *
70 * Return: 0 on success, or negative errno on error.
71 */
72int setup_purgatory(struct kimage *image, const void *slave_code,
73		    const void *fdt, unsigned long kernel_load_addr,
74		    unsigned long fdt_load_addr)
75{
76	unsigned int *slave_code_buf, master_entry;
77	int ret;
78
79	slave_code_buf = kmalloc(SLAVE_CODE_SIZE, GFP_KERNEL);
80	if (!slave_code_buf)
81		return -ENOMEM;
82
83	/* Get the slave code from the new kernel and put it in purgatory. */
84	ret = kexec_purgatory_get_set_symbol(image, "purgatory_start",
85					     slave_code_buf, SLAVE_CODE_SIZE,
86					     true);
87	if (ret) {
88		kfree(slave_code_buf);
89		return ret;
90	}
91
92	master_entry = slave_code_buf[0];
93	memcpy(slave_code_buf, slave_code, SLAVE_CODE_SIZE);
94	slave_code_buf[0] = master_entry;
95	ret = kexec_purgatory_get_set_symbol(image, "purgatory_start",
96					     slave_code_buf, SLAVE_CODE_SIZE,
97					     false);
98	kfree(slave_code_buf);
99
100	ret = kexec_purgatory_get_set_symbol(image, "kernel", &kernel_load_addr,
101					     sizeof(kernel_load_addr), false);
102	if (ret)
103		return ret;
104	ret = kexec_purgatory_get_set_symbol(image, "dt_offset", &fdt_load_addr,
105					     sizeof(fdt_load_addr), false);
106	if (ret)
107		return ret;
108
109	return 0;
110}
111
112/**
113 * delete_fdt_mem_rsv - delete memory reservation with given address and size
114 *
115 * Return: 0 on success, or negative errno on error.
116 */
117int delete_fdt_mem_rsv(void *fdt, unsigned long start, unsigned long size)
118{
119	int i, ret, num_rsvs = fdt_num_mem_rsv(fdt);
120
121	for (i = 0; i < num_rsvs; i++) {
122		uint64_t rsv_start, rsv_size;
123
124		ret = fdt_get_mem_rsv(fdt, i, &rsv_start, &rsv_size);
125		if (ret) {
126			pr_err("Malformed device tree.\n");
127			return -EINVAL;
128		}
129
130		if (rsv_start == start && rsv_size == size) {
131			ret = fdt_del_mem_rsv(fdt, i);
132			if (ret) {
133				pr_err("Error deleting device tree reservation.\n");
134				return -EINVAL;
135			}
136
137			return 0;
138		}
139	}
140
141	return -ENOENT;
142}
143
144/*
145 * setup_new_fdt - modify /chosen and memory reservation for the next kernel
146 * @image:		kexec image being loaded.
147 * @fdt:		Flattened device tree for the next kernel.
148 * @initrd_load_addr:	Address where the next initrd will be loaded.
149 * @initrd_len:		Size of the next initrd, or 0 if there will be none.
150 * @cmdline:		Command line for the next kernel, or NULL if there will
151 *			be none.
152 *
153 * Return: 0 on success, or negative errno on error.
154 */
155int setup_new_fdt(const struct kimage *image, void *fdt,
156		  unsigned long initrd_load_addr, unsigned long initrd_len,
157		  const char *cmdline)
158{
159	int ret, chosen_node;
160	const void *prop;
161
162	/* Remove memory reservation for the current device tree. */
163	ret = delete_fdt_mem_rsv(fdt, __pa(initial_boot_params),
164				 fdt_totalsize(initial_boot_params));
165	if (ret == 0)
166		pr_debug("Removed old device tree reservation.\n");
167	else if (ret != -ENOENT)
168		return ret;
169
170	chosen_node = fdt_path_offset(fdt, "/chosen");
171	if (chosen_node == -FDT_ERR_NOTFOUND) {
172		chosen_node = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"),
173					      "chosen");
174		if (chosen_node < 0) {
175			pr_err("Error creating /chosen.\n");
176			return -EINVAL;
177		}
178	} else if (chosen_node < 0) {
179		pr_err("Malformed device tree: error reading /chosen.\n");
180		return -EINVAL;
181	}
182
183	/* Did we boot using an initrd? */
184	prop = fdt_getprop(fdt, chosen_node, "linux,initrd-start", NULL);
185	if (prop) {
186		uint64_t tmp_start, tmp_end, tmp_size;
187
188		tmp_start = fdt64_to_cpu(*((const fdt64_t *) prop));
189
190		prop = fdt_getprop(fdt, chosen_node, "linux,initrd-end", NULL);
191		if (!prop) {
192			pr_err("Malformed device tree.\n");
193			return -EINVAL;
194		}
195		tmp_end = fdt64_to_cpu(*((const fdt64_t *) prop));
196
197		/*
198		 * kexec reserves exact initrd size, while firmware may
199		 * reserve a multiple of PAGE_SIZE, so check for both.
200		 */
201		tmp_size = tmp_end - tmp_start;
202		ret = delete_fdt_mem_rsv(fdt, tmp_start, tmp_size);
203		if (ret == -ENOENT)
204			ret = delete_fdt_mem_rsv(fdt, tmp_start,
205						 round_up(tmp_size, PAGE_SIZE));
206		if (ret == 0)
207			pr_debug("Removed old initrd reservation.\n");
208		else if (ret != -ENOENT)
209			return ret;
210
211		/* If there's no new initrd, delete the old initrd's info. */
212		if (initrd_len == 0) {
213			ret = fdt_delprop(fdt, chosen_node,
214					  "linux,initrd-start");
215			if (ret) {
216				pr_err("Error deleting linux,initrd-start.\n");
217				return -EINVAL;
218			}
219
220			ret = fdt_delprop(fdt, chosen_node, "linux,initrd-end");
221			if (ret) {
222				pr_err("Error deleting linux,initrd-end.\n");
223				return -EINVAL;
224			}
225		}
226	}
227
228	if (initrd_len) {
229		ret = fdt_setprop_u64(fdt, chosen_node,
230				      "linux,initrd-start",
231				      initrd_load_addr);
232		if (ret < 0)
233			goto err;
234
235		/* initrd-end is the first address after the initrd image. */
236		ret = fdt_setprop_u64(fdt, chosen_node, "linux,initrd-end",
237				      initrd_load_addr + initrd_len);
238		if (ret < 0)
239			goto err;
240
241		ret = fdt_add_mem_rsv(fdt, initrd_load_addr, initrd_len);
242		if (ret) {
243			pr_err("Error reserving initrd memory: %s\n",
244			       fdt_strerror(ret));
245			return -EINVAL;
246		}
247	}
248
249	if (cmdline != NULL) {
250		ret = fdt_setprop_string(fdt, chosen_node, "bootargs", cmdline);
251		if (ret < 0)
252			goto err;
253	} else {
254		ret = fdt_delprop(fdt, chosen_node, "bootargs");
255		if (ret && ret != -FDT_ERR_NOTFOUND) {
256			pr_err("Error deleting bootargs.\n");
257			return -EINVAL;
258		}
259	}
260
261	if (image->type == KEXEC_TYPE_CRASH) {
262		/*
263		 * Avoid elfcorehdr from being stomped on in kdump kernel by
264		 * setting up memory reserve map.
265		 */
266		ret = fdt_add_mem_rsv(fdt, image->arch.elfcorehdr_addr,
267				      image->arch.elf_headers_sz);
268		if (ret) {
269			pr_err("Error reserving elfcorehdr memory: %s\n",
270			       fdt_strerror(ret));
271			goto err;
272		}
273	}
274
275	ret = setup_ima_buffer(image, fdt, chosen_node);
276	if (ret) {
277		pr_err("Error setting up the new device tree.\n");
278		return ret;
279	}
280
281	ret = fdt_setprop(fdt, chosen_node, "linux,booted-from-kexec", NULL, 0);
282	if (ret)
283		goto err;
284
285	return 0;
286
287err:
288	pr_err("Error setting up the new device tree.\n");
289	return -EINVAL;
290}
291