14febfb8dSArd Biesheuvel // SPDX-License-Identifier: GPL-2.0
2f4f75ad5SArd Biesheuvel /*
3f4f75ad5SArd Biesheuvel  * Helper functions used by the EFI stub on multiple
4f4f75ad5SArd Biesheuvel  * architectures. This should be #included by the EFI stub
5f4f75ad5SArd Biesheuvel  * implementation files.
6f4f75ad5SArd Biesheuvel  *
7f4f75ad5SArd Biesheuvel  * Copyright 2011 Intel Corporation; author Matt Fleming
8f4f75ad5SArd Biesheuvel  */
9f4f75ad5SArd Biesheuvel 
102c7d1e30SArvind Sankar #include <stdarg.h>
112c7d1e30SArvind Sankar 
12f4f75ad5SArd Biesheuvel #include <linux/efi.h>
13fd0528a2SArvind Sankar #include <linux/kernel.h>
14f4f75ad5SArd Biesheuvel #include <asm/efi.h>
15f4f75ad5SArd Biesheuvel 
16f4f75ad5SArd Biesheuvel #include "efistub.h"
17f4f75ad5SArd Biesheuvel 
18980771f6SArd Biesheuvel bool efi_nochunk;
19980771f6SArd Biesheuvel bool efi_nokaslr;
20980771f6SArd Biesheuvel bool efi_noinitrd;
21980771f6SArd Biesheuvel bool efi_quiet;
22980771f6SArd Biesheuvel bool efi_novamap;
23980771f6SArd Biesheuvel 
2454439370SArvind Sankar static bool efi_nosoftreserve;
2554439370SArvind Sankar static bool efi_disable_pci_dma = IS_ENABLED(CONFIG_EFI_DISABLE_PCI_DMA);
2660f38de7SArd Biesheuvel 
27b617c526SDan Williams bool __pure __efi_soft_reserve_enabled(void)
28b617c526SDan Williams {
29b617c526SDan Williams 	return !efi_nosoftreserve;
30b617c526SDan Williams }
3160f38de7SArd Biesheuvel 
32cb8c90a0SArvind Sankar void efi_char16_puts(efi_char16_t *str)
33cb8c90a0SArvind Sankar {
34cb8c90a0SArvind Sankar 	efi_call_proto(efi_table_attr(efi_system_table, con_out),
35cb8c90a0SArvind Sankar 		       output_string, str);
36cb8c90a0SArvind Sankar }
37cb8c90a0SArvind Sankar 
38cb8c90a0SArvind Sankar void efi_puts(const char *str)
39f4f75ad5SArd Biesheuvel {
40fd0528a2SArvind Sankar 	efi_char16_t buf[128];
41fd0528a2SArvind Sankar 	size_t pos = 0, lim = ARRAY_SIZE(buf);
42f4f75ad5SArd Biesheuvel 
43fd0528a2SArvind Sankar 	while (*str) {
44fd0528a2SArvind Sankar 		if (*str == '\n')
45fd0528a2SArvind Sankar 			buf[pos++] = L'\r';
46fd0528a2SArvind Sankar 		/* Cast to unsigned char to avoid sign-extension */
47fd0528a2SArvind Sankar 		buf[pos++] = (unsigned char)(*str++);
48fd0528a2SArvind Sankar 		if (*str == '\0' || pos >= lim - 2) {
49fd0528a2SArvind Sankar 			buf[pos] = L'\0';
50fd0528a2SArvind Sankar 			efi_char16_puts(buf);
51fd0528a2SArvind Sankar 			pos = 0;
52fd0528a2SArvind Sankar 		}
53f4f75ad5SArd Biesheuvel 	}
54f4f75ad5SArd Biesheuvel }
55f4f75ad5SArd Biesheuvel 
562c7d1e30SArvind Sankar int efi_printk(const char *fmt, ...)
572c7d1e30SArvind Sankar {
582c7d1e30SArvind Sankar 	char printf_buf[256];
592c7d1e30SArvind Sankar 	va_list args;
602c7d1e30SArvind Sankar 	int printed;
612c7d1e30SArvind Sankar 
622c7d1e30SArvind Sankar 	va_start(args, fmt);
638fb331e1SArvind Sankar 	printed = vsnprintf(printf_buf, sizeof(printf_buf), fmt, args);
642c7d1e30SArvind Sankar 	va_end(args);
652c7d1e30SArvind Sankar 
662c7d1e30SArvind Sankar 	efi_puts(printf_buf);
678fb331e1SArvind Sankar 	if (printed >= sizeof(printf_buf)) {
688fb331e1SArvind Sankar 		efi_puts("[Message truncated]\n");
698fb331e1SArvind Sankar 		return -1;
708fb331e1SArvind Sankar 	}
712c7d1e30SArvind Sankar 
722c7d1e30SArvind Sankar 	return printed;
732c7d1e30SArvind Sankar }
742c7d1e30SArvind Sankar 
755a17dae4SMatt Fleming /*
765a17dae4SMatt Fleming  * Parse the ASCII string 'cmdline' for EFI options, denoted by the efi=
775a17dae4SMatt Fleming  * option, e.g. efi=nochunk.
785a17dae4SMatt Fleming  *
795a17dae4SMatt Fleming  * It should be noted that efi= is parsed in two very different
805a17dae4SMatt Fleming  * environments, first in the early boot environment of the EFI boot
815a17dae4SMatt Fleming  * stub, and subsequently during the kernel boot.
825a17dae4SMatt Fleming  */
8360f38de7SArd Biesheuvel efi_status_t efi_parse_options(char const *cmdline)
845a17dae4SMatt Fleming {
8591d150c0SArd Biesheuvel 	size_t len = strlen(cmdline) + 1;
8691d150c0SArd Biesheuvel 	efi_status_t status;
8791d150c0SArd Biesheuvel 	char *str, *buf;
885a17dae4SMatt Fleming 
8991d150c0SArd Biesheuvel 	status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, len, (void **)&buf);
9091d150c0SArd Biesheuvel 	if (status != EFI_SUCCESS)
9191d150c0SArd Biesheuvel 		return status;
9291d150c0SArd Biesheuvel 
9391d150c0SArd Biesheuvel 	str = skip_spaces(memcpy(buf, cmdline, len));
9491d150c0SArd Biesheuvel 
9591d150c0SArd Biesheuvel 	while (*str) {
9691d150c0SArd Biesheuvel 		char *param, *val;
9791d150c0SArd Biesheuvel 
9891d150c0SArd Biesheuvel 		str = next_arg(str, &param, &val);
9991d150c0SArd Biesheuvel 
10091d150c0SArd Biesheuvel 		if (!strcmp(param, "nokaslr")) {
1017d4e323dSArd Biesheuvel 			efi_nokaslr = true;
10291d150c0SArd Biesheuvel 		} else if (!strcmp(param, "quiet")) {
1037d4e323dSArd Biesheuvel 			efi_quiet = true;
10479d3219dSArd Biesheuvel 		} else if (!strcmp(param, "noinitrd")) {
10579d3219dSArd Biesheuvel 			efi_noinitrd = true;
10691d150c0SArd Biesheuvel 		} else if (!strcmp(param, "efi") && val) {
10791d150c0SArd Biesheuvel 			efi_nochunk = parse_option_str(val, "nochunk");
10891d150c0SArd Biesheuvel 			efi_novamap = parse_option_str(val, "novamap");
109eeff7d63SArd Biesheuvel 
11091d150c0SArd Biesheuvel 			efi_nosoftreserve = IS_ENABLED(CONFIG_EFI_SOFT_RESERVE) &&
11191d150c0SArd Biesheuvel 					    parse_option_str(val, "nosoftreserve");
1125a17dae4SMatt Fleming 
11391d150c0SArd Biesheuvel 			if (parse_option_str(val, "disable_early_pci_dma"))
1144444f854SMatthew Garrett 				efi_disable_pci_dma = true;
11591d150c0SArd Biesheuvel 			if (parse_option_str(val, "no_disable_early_pci_dma"))
1164444f854SMatthew Garrett 				efi_disable_pci_dma = false;
117fffb6804SArvind Sankar 		} else if (!strcmp(param, "video") &&
118fffb6804SArvind Sankar 			   val && strstarts(val, "efifb:")) {
119fffb6804SArvind Sankar 			efi_parse_option_graphics(val + strlen("efifb:"));
1204444f854SMatthew Garrett 		}
1215a17dae4SMatt Fleming 	}
12291d150c0SArd Biesheuvel 	efi_bs_call(free_pool, buf);
1235a17dae4SMatt Fleming 	return EFI_SUCCESS;
1245a17dae4SMatt Fleming }
125f4f75ad5SArd Biesheuvel 
126f4f75ad5SArd Biesheuvel /*
127f4f75ad5SArd Biesheuvel  * Get the number of UTF-8 bytes corresponding to an UTF-16 character.
128f4f75ad5SArd Biesheuvel  * This overestimates for surrogates, but that is okay.
129f4f75ad5SArd Biesheuvel  */
130f4f75ad5SArd Biesheuvel static int efi_utf8_bytes(u16 c)
131f4f75ad5SArd Biesheuvel {
132f4f75ad5SArd Biesheuvel 	return 1 + (c >= 0x80) + (c >= 0x800);
133f4f75ad5SArd Biesheuvel }
134f4f75ad5SArd Biesheuvel 
135f4f75ad5SArd Biesheuvel /*
136f4f75ad5SArd Biesheuvel  * Convert an UTF-16 string, not necessarily null terminated, to UTF-8.
137f4f75ad5SArd Biesheuvel  */
138f4f75ad5SArd Biesheuvel static u8 *efi_utf16_to_utf8(u8 *dst, const u16 *src, int n)
139f4f75ad5SArd Biesheuvel {
140f4f75ad5SArd Biesheuvel 	unsigned int c;
141f4f75ad5SArd Biesheuvel 
142f4f75ad5SArd Biesheuvel 	while (n--) {
143f4f75ad5SArd Biesheuvel 		c = *src++;
144f4f75ad5SArd Biesheuvel 		if (n && c >= 0xd800 && c <= 0xdbff &&
145f4f75ad5SArd Biesheuvel 		    *src >= 0xdc00 && *src <= 0xdfff) {
146f4f75ad5SArd Biesheuvel 			c = 0x10000 + ((c & 0x3ff) << 10) + (*src & 0x3ff);
147f4f75ad5SArd Biesheuvel 			src++;
148f4f75ad5SArd Biesheuvel 			n--;
149f4f75ad5SArd Biesheuvel 		}
150f4f75ad5SArd Biesheuvel 		if (c >= 0xd800 && c <= 0xdfff)
151f4f75ad5SArd Biesheuvel 			c = 0xfffd; /* Unmatched surrogate */
152f4f75ad5SArd Biesheuvel 		if (c < 0x80) {
153f4f75ad5SArd Biesheuvel 			*dst++ = c;
154f4f75ad5SArd Biesheuvel 			continue;
155f4f75ad5SArd Biesheuvel 		}
156f4f75ad5SArd Biesheuvel 		if (c < 0x800) {
157f4f75ad5SArd Biesheuvel 			*dst++ = 0xc0 + (c >> 6);
158f4f75ad5SArd Biesheuvel 			goto t1;
159f4f75ad5SArd Biesheuvel 		}
160f4f75ad5SArd Biesheuvel 		if (c < 0x10000) {
161f4f75ad5SArd Biesheuvel 			*dst++ = 0xe0 + (c >> 12);
162f4f75ad5SArd Biesheuvel 			goto t2;
163f4f75ad5SArd Biesheuvel 		}
164f4f75ad5SArd Biesheuvel 		*dst++ = 0xf0 + (c >> 18);
165f4f75ad5SArd Biesheuvel 		*dst++ = 0x80 + ((c >> 12) & 0x3f);
166f4f75ad5SArd Biesheuvel 	t2:
167f4f75ad5SArd Biesheuvel 		*dst++ = 0x80 + ((c >> 6) & 0x3f);
168f4f75ad5SArd Biesheuvel 	t1:
169f4f75ad5SArd Biesheuvel 		*dst++ = 0x80 + (c & 0x3f);
170f4f75ad5SArd Biesheuvel 	}
171f4f75ad5SArd Biesheuvel 
172f4f75ad5SArd Biesheuvel 	return dst;
173f4f75ad5SArd Biesheuvel }
174f4f75ad5SArd Biesheuvel 
175f4f75ad5SArd Biesheuvel /*
176f4f75ad5SArd Biesheuvel  * Convert the unicode UEFI command line to ASCII to pass to kernel.
177f4f75ad5SArd Biesheuvel  * Size of memory allocated return in *cmd_line_len.
178f4f75ad5SArd Biesheuvel  * Returns NULL on error.
179f4f75ad5SArd Biesheuvel  */
180cd33a5c1SArd Biesheuvel char *efi_convert_cmdline(efi_loaded_image_t *image,
1811e45bf73SArd Biesheuvel 			  int *cmd_line_len, unsigned long max_addr)
182f4f75ad5SArd Biesheuvel {
183f4f75ad5SArd Biesheuvel 	const u16 *s2;
184f4f75ad5SArd Biesheuvel 	u8 *s1 = NULL;
185f4f75ad5SArd Biesheuvel 	unsigned long cmdline_addr = 0;
186f7b85b33SArd Biesheuvel 	int load_options_chars = efi_table_attr(image, load_options_size) / 2;
187f7b85b33SArd Biesheuvel 	const u16 *options = efi_table_attr(image, load_options);
188f4f75ad5SArd Biesheuvel 	int options_bytes = 0;  /* UTF-8 bytes */
189f4f75ad5SArd Biesheuvel 	int options_chars = 0;  /* UTF-16 chars */
190f4f75ad5SArd Biesheuvel 	efi_status_t status;
191f4f75ad5SArd Biesheuvel 	u16 zero = 0;
192f4f75ad5SArd Biesheuvel 
193f4f75ad5SArd Biesheuvel 	if (options) {
194f4f75ad5SArd Biesheuvel 		s2 = options;
195f4f75ad5SArd Biesheuvel 		while (*s2 && *s2 != '\n'
196f4f75ad5SArd Biesheuvel 		       && options_chars < load_options_chars) {
197f4f75ad5SArd Biesheuvel 			options_bytes += efi_utf8_bytes(*s2++);
198f4f75ad5SArd Biesheuvel 			options_chars++;
199f4f75ad5SArd Biesheuvel 		}
200f4f75ad5SArd Biesheuvel 	}
201f4f75ad5SArd Biesheuvel 
202f4f75ad5SArd Biesheuvel 	if (!options_chars) {
203f4f75ad5SArd Biesheuvel 		/* No command line options, so return empty string*/
204f4f75ad5SArd Biesheuvel 		options = &zero;
205f4f75ad5SArd Biesheuvel 	}
206f4f75ad5SArd Biesheuvel 
207f4f75ad5SArd Biesheuvel 	options_bytes++;	/* NUL termination */
208f4f75ad5SArd Biesheuvel 
2091e45bf73SArd Biesheuvel 	status = efi_allocate_pages(options_bytes, &cmdline_addr, max_addr);
210f4f75ad5SArd Biesheuvel 	if (status != EFI_SUCCESS)
211f4f75ad5SArd Biesheuvel 		return NULL;
212f4f75ad5SArd Biesheuvel 
213f4f75ad5SArd Biesheuvel 	s1 = (u8 *)cmdline_addr;
214f4f75ad5SArd Biesheuvel 	s2 = (const u16 *)options;
215f4f75ad5SArd Biesheuvel 
216f4f75ad5SArd Biesheuvel 	s1 = efi_utf16_to_utf8(s1, s2, options_chars);
217f4f75ad5SArd Biesheuvel 	*s1 = '\0';
218f4f75ad5SArd Biesheuvel 
219f4f75ad5SArd Biesheuvel 	*cmd_line_len = options_bytes;
220f4f75ad5SArd Biesheuvel 	return (char *)cmdline_addr;
221f4f75ad5SArd Biesheuvel }
222fc07716bSJeffrey Hugo 
223fc07716bSJeffrey Hugo /*
224fc07716bSJeffrey Hugo  * Handle calling ExitBootServices according to the requirements set out by the
225fc07716bSJeffrey Hugo  * spec.  Obtains the current memory map, and returns that info after calling
226fc07716bSJeffrey Hugo  * ExitBootServices.  The client must specify a function to perform any
227fc07716bSJeffrey Hugo  * processing of the memory map data prior to ExitBootServices.  A client
228fc07716bSJeffrey Hugo  * specific structure may be passed to the function via priv.  The client
229fc07716bSJeffrey Hugo  * function may be called multiple times.
230fc07716bSJeffrey Hugo  */
231cd33a5c1SArd Biesheuvel efi_status_t efi_exit_boot_services(void *handle,
232fc07716bSJeffrey Hugo 				    struct efi_boot_memmap *map,
233fc07716bSJeffrey Hugo 				    void *priv,
234fc07716bSJeffrey Hugo 				    efi_exit_boot_map_processing priv_func)
235fc07716bSJeffrey Hugo {
236fc07716bSJeffrey Hugo 	efi_status_t status;
237fc07716bSJeffrey Hugo 
238cd33a5c1SArd Biesheuvel 	status = efi_get_memory_map(map);
239fc07716bSJeffrey Hugo 
240fc07716bSJeffrey Hugo 	if (status != EFI_SUCCESS)
241fc07716bSJeffrey Hugo 		goto fail;
242fc07716bSJeffrey Hugo 
243cd33a5c1SArd Biesheuvel 	status = priv_func(map, priv);
244fc07716bSJeffrey Hugo 	if (status != EFI_SUCCESS)
245fc07716bSJeffrey Hugo 		goto free_map;
246fc07716bSJeffrey Hugo 
2474444f854SMatthew Garrett 	if (efi_disable_pci_dma)
2484444f854SMatthew Garrett 		efi_pci_disable_bridge_busmaster();
2494444f854SMatthew Garrett 
250966291f6SArd Biesheuvel 	status = efi_bs_call(exit_boot_services, handle, *map->key_ptr);
251fc07716bSJeffrey Hugo 
252fc07716bSJeffrey Hugo 	if (status == EFI_INVALID_PARAMETER) {
253fc07716bSJeffrey Hugo 		/*
254fc07716bSJeffrey Hugo 		 * The memory map changed between efi_get_memory_map() and
255fc07716bSJeffrey Hugo 		 * exit_boot_services().  Per the UEFI Spec v2.6, Section 6.4:
256fc07716bSJeffrey Hugo 		 * EFI_BOOT_SERVICES.ExitBootServices we need to get the
257fc07716bSJeffrey Hugo 		 * updated map, and try again.  The spec implies one retry
258fc07716bSJeffrey Hugo 		 * should be sufficent, which is confirmed against the EDK2
259fc07716bSJeffrey Hugo 		 * implementation.  Per the spec, we can only invoke
260fc07716bSJeffrey Hugo 		 * get_memory_map() and exit_boot_services() - we cannot alloc
261fc07716bSJeffrey Hugo 		 * so efi_get_memory_map() cannot be used, and we must reuse
262fc07716bSJeffrey Hugo 		 * the buffer.  For all practical purposes, the headroom in the
263fc07716bSJeffrey Hugo 		 * buffer should account for any changes in the map so the call
264fc07716bSJeffrey Hugo 		 * to get_memory_map() is expected to succeed here.
265fc07716bSJeffrey Hugo 		 */
266fc07716bSJeffrey Hugo 		*map->map_size = *map->buff_size;
267966291f6SArd Biesheuvel 		status = efi_bs_call(get_memory_map,
268fc07716bSJeffrey Hugo 				     map->map_size,
269fc07716bSJeffrey Hugo 				     *map->map,
270fc07716bSJeffrey Hugo 				     map->key_ptr,
271fc07716bSJeffrey Hugo 				     map->desc_size,
272fc07716bSJeffrey Hugo 				     map->desc_ver);
273fc07716bSJeffrey Hugo 
274fc07716bSJeffrey Hugo 		/* exit_boot_services() was called, thus cannot free */
275fc07716bSJeffrey Hugo 		if (status != EFI_SUCCESS)
276fc07716bSJeffrey Hugo 			goto fail;
277fc07716bSJeffrey Hugo 
278cd33a5c1SArd Biesheuvel 		status = priv_func(map, priv);
279fc07716bSJeffrey Hugo 		/* exit_boot_services() was called, thus cannot free */
280fc07716bSJeffrey Hugo 		if (status != EFI_SUCCESS)
281fc07716bSJeffrey Hugo 			goto fail;
282fc07716bSJeffrey Hugo 
283966291f6SArd Biesheuvel 		status = efi_bs_call(exit_boot_services, handle, *map->key_ptr);
284fc07716bSJeffrey Hugo 	}
285fc07716bSJeffrey Hugo 
286fc07716bSJeffrey Hugo 	/* exit_boot_services() was called, thus cannot free */
287fc07716bSJeffrey Hugo 	if (status != EFI_SUCCESS)
288fc07716bSJeffrey Hugo 		goto fail;
289fc07716bSJeffrey Hugo 
290fc07716bSJeffrey Hugo 	return EFI_SUCCESS;
291fc07716bSJeffrey Hugo 
292fc07716bSJeffrey Hugo free_map:
293966291f6SArd Biesheuvel 	efi_bs_call(free_pool, *map->map);
294fc07716bSJeffrey Hugo fail:
295fc07716bSJeffrey Hugo 	return status;
296fc07716bSJeffrey Hugo }
29782d736acSMatthew Garrett 
298cd33a5c1SArd Biesheuvel void *get_efi_config_table(efi_guid_t guid)
29982d736acSMatthew Garrett {
300ccc27ae7SArd Biesheuvel 	unsigned long tables = efi_table_attr(efi_system_table, tables);
301ccc27ae7SArd Biesheuvel 	int nr_tables = efi_table_attr(efi_system_table, nr_tables);
302f958efe9SArd Biesheuvel 	int i;
303f958efe9SArd Biesheuvel 
304f958efe9SArd Biesheuvel 	for (i = 0; i < nr_tables; i++) {
305f958efe9SArd Biesheuvel 		efi_config_table_t *t = (void *)tables;
306f958efe9SArd Biesheuvel 
307f958efe9SArd Biesheuvel 		if (efi_guidcmp(t->guid, guid) == 0)
30899ea8b1dSArd Biesheuvel 			return efi_table_attr(t, table);
309f958efe9SArd Biesheuvel 
310f958efe9SArd Biesheuvel 		tables += efi_is_native() ? sizeof(efi_config_table_t)
311f958efe9SArd Biesheuvel 					  : sizeof(efi_config_table_32_t);
312f958efe9SArd Biesheuvel 	}
313f958efe9SArd Biesheuvel 	return NULL;
31482d736acSMatthew Garrett }
315dc29da14SArd Biesheuvel 
316ec93fc37SArd Biesheuvel /*
317ec93fc37SArd Biesheuvel  * The LINUX_EFI_INITRD_MEDIA_GUID vendor media device path below provides a way
318ec93fc37SArd Biesheuvel  * for the firmware or bootloader to expose the initrd data directly to the stub
319ec93fc37SArd Biesheuvel  * via the trivial LoadFile2 protocol, which is defined in the UEFI spec, and is
320ec93fc37SArd Biesheuvel  * very easy to implement. It is a simple Linux initrd specific conduit between
321ec93fc37SArd Biesheuvel  * kernel and firmware, allowing us to put the EFI stub (being part of the
322ec93fc37SArd Biesheuvel  * kernel) in charge of where and when to load the initrd, while leaving it up
323ec93fc37SArd Biesheuvel  * to the firmware to decide whether it needs to expose its filesystem hierarchy
324ec93fc37SArd Biesheuvel  * via EFI protocols.
325ec93fc37SArd Biesheuvel  */
326ec93fc37SArd Biesheuvel static const struct {
327ec93fc37SArd Biesheuvel 	struct efi_vendor_dev_path	vendor;
328ec93fc37SArd Biesheuvel 	struct efi_generic_dev_path	end;
329ec93fc37SArd Biesheuvel } __packed initrd_dev_path = {
330ec93fc37SArd Biesheuvel 	{
331ec93fc37SArd Biesheuvel 		{
332ec93fc37SArd Biesheuvel 			EFI_DEV_MEDIA,
333ec93fc37SArd Biesheuvel 			EFI_DEV_MEDIA_VENDOR,
334ec93fc37SArd Biesheuvel 			sizeof(struct efi_vendor_dev_path),
335ec93fc37SArd Biesheuvel 		},
336ec93fc37SArd Biesheuvel 		LINUX_EFI_INITRD_MEDIA_GUID
337ec93fc37SArd Biesheuvel 	}, {
338ec93fc37SArd Biesheuvel 		EFI_DEV_END_PATH,
339ec93fc37SArd Biesheuvel 		EFI_DEV_END_ENTIRE,
340ec93fc37SArd Biesheuvel 		sizeof(struct efi_generic_dev_path)
341ec93fc37SArd Biesheuvel 	}
342ec93fc37SArd Biesheuvel };
343ec93fc37SArd Biesheuvel 
344ec93fc37SArd Biesheuvel /**
345ec93fc37SArd Biesheuvel  * efi_load_initrd_dev_path - load the initrd from the Linux initrd device path
346ec93fc37SArd Biesheuvel  * @load_addr:	pointer to store the address where the initrd was loaded
347ec93fc37SArd Biesheuvel  * @load_size:	pointer to store the size of the loaded initrd
348ec93fc37SArd Biesheuvel  * @max:	upper limit for the initrd memory allocation
349ec93fc37SArd Biesheuvel  * @return:	%EFI_SUCCESS if the initrd was loaded successfully, in which
350ec93fc37SArd Biesheuvel  *		case @load_addr and @load_size are assigned accordingly
351ec93fc37SArd Biesheuvel  *		%EFI_NOT_FOUND if no LoadFile2 protocol exists on the initrd
352ec93fc37SArd Biesheuvel  *		device path
353ec93fc37SArd Biesheuvel  *		%EFI_INVALID_PARAMETER if load_addr == NULL or load_size == NULL
354ec93fc37SArd Biesheuvel  *		%EFI_OUT_OF_RESOURCES if memory allocation failed
355ec93fc37SArd Biesheuvel  *		%EFI_LOAD_ERROR in all other cases
356ec93fc37SArd Biesheuvel  */
357f61900fdSArvind Sankar static
358ec93fc37SArd Biesheuvel efi_status_t efi_load_initrd_dev_path(unsigned long *load_addr,
359ec93fc37SArd Biesheuvel 				      unsigned long *load_size,
360ec93fc37SArd Biesheuvel 				      unsigned long max)
361ec93fc37SArd Biesheuvel {
362ec93fc37SArd Biesheuvel 	efi_guid_t lf2_proto_guid = EFI_LOAD_FILE2_PROTOCOL_GUID;
363ec93fc37SArd Biesheuvel 	efi_device_path_protocol_t *dp;
364ec93fc37SArd Biesheuvel 	efi_load_file2_protocol_t *lf2;
365ec93fc37SArd Biesheuvel 	unsigned long initrd_addr;
366ec93fc37SArd Biesheuvel 	unsigned long initrd_size;
367ec93fc37SArd Biesheuvel 	efi_handle_t handle;
368ec93fc37SArd Biesheuvel 	efi_status_t status;
369ec93fc37SArd Biesheuvel 
370ec93fc37SArd Biesheuvel 	dp = (efi_device_path_protocol_t *)&initrd_dev_path;
371ec93fc37SArd Biesheuvel 	status = efi_bs_call(locate_device_path, &lf2_proto_guid, &dp, &handle);
372ec93fc37SArd Biesheuvel 	if (status != EFI_SUCCESS)
373ec93fc37SArd Biesheuvel 		return status;
374ec93fc37SArd Biesheuvel 
375ec93fc37SArd Biesheuvel 	status = efi_bs_call(handle_protocol, handle, &lf2_proto_guid,
376ec93fc37SArd Biesheuvel 			     (void **)&lf2);
377ec93fc37SArd Biesheuvel 	if (status != EFI_SUCCESS)
378ec93fc37SArd Biesheuvel 		return status;
379ec93fc37SArd Biesheuvel 
380ec93fc37SArd Biesheuvel 	status = efi_call_proto(lf2, load_file, dp, false, &initrd_size, NULL);
381ec93fc37SArd Biesheuvel 	if (status != EFI_BUFFER_TOO_SMALL)
382ec93fc37SArd Biesheuvel 		return EFI_LOAD_ERROR;
383ec93fc37SArd Biesheuvel 
384ec93fc37SArd Biesheuvel 	status = efi_allocate_pages(initrd_size, &initrd_addr, max);
385ec93fc37SArd Biesheuvel 	if (status != EFI_SUCCESS)
386ec93fc37SArd Biesheuvel 		return status;
387ec93fc37SArd Biesheuvel 
388ec93fc37SArd Biesheuvel 	status = efi_call_proto(lf2, load_file, dp, false, &initrd_size,
389ec93fc37SArd Biesheuvel 				(void *)initrd_addr);
390ec93fc37SArd Biesheuvel 	if (status != EFI_SUCCESS) {
391ec93fc37SArd Biesheuvel 		efi_free(initrd_size, initrd_addr);
392ec93fc37SArd Biesheuvel 		return EFI_LOAD_ERROR;
393ec93fc37SArd Biesheuvel 	}
394ec93fc37SArd Biesheuvel 
395ec93fc37SArd Biesheuvel 	*load_addr = initrd_addr;
396ec93fc37SArd Biesheuvel 	*load_size = initrd_size;
397ec93fc37SArd Biesheuvel 	return EFI_SUCCESS;
398ec93fc37SArd Biesheuvel }
399f61900fdSArvind Sankar 
400f61900fdSArvind Sankar static
401f61900fdSArvind Sankar efi_status_t efi_load_initrd_cmdline(efi_loaded_image_t *image,
402f61900fdSArvind Sankar 				     unsigned long *load_addr,
403f61900fdSArvind Sankar 				     unsigned long *load_size,
404f61900fdSArvind Sankar 				     unsigned long soft_limit,
405f61900fdSArvind Sankar 				     unsigned long hard_limit)
406f61900fdSArvind Sankar {
407f61900fdSArvind Sankar 	if (!IS_ENABLED(CONFIG_EFI_GENERIC_STUB_INITRD_CMDLINE_LOADER) ||
408f61900fdSArvind Sankar 	    (IS_ENABLED(CONFIG_X86) && (!efi_is_native() || image == NULL))) {
409f61900fdSArvind Sankar 		*load_addr = *load_size = 0;
410f61900fdSArvind Sankar 		return EFI_SUCCESS;
411f61900fdSArvind Sankar 	}
412f61900fdSArvind Sankar 
413f61900fdSArvind Sankar 	return handle_cmdline_files(image, L"initrd=", sizeof(L"initrd=") - 2,
414f61900fdSArvind Sankar 				    soft_limit, hard_limit,
415f61900fdSArvind Sankar 				    load_addr, load_size);
416f61900fdSArvind Sankar }
417f61900fdSArvind Sankar 
418f61900fdSArvind Sankar efi_status_t efi_load_initrd(efi_loaded_image_t *image,
419f61900fdSArvind Sankar 			     unsigned long *load_addr,
420f61900fdSArvind Sankar 			     unsigned long *load_size,
421f61900fdSArvind Sankar 			     unsigned long soft_limit,
422f61900fdSArvind Sankar 			     unsigned long hard_limit)
423f61900fdSArvind Sankar {
424f61900fdSArvind Sankar 	efi_status_t status;
425f61900fdSArvind Sankar 
426f61900fdSArvind Sankar 	if (!load_addr || !load_size)
427f61900fdSArvind Sankar 		return EFI_INVALID_PARAMETER;
428f61900fdSArvind Sankar 
429f61900fdSArvind Sankar 	status = efi_load_initrd_dev_path(load_addr, load_size, hard_limit);
430f61900fdSArvind Sankar 	if (status == EFI_SUCCESS) {
431f61900fdSArvind Sankar 		efi_info("Loaded initrd from LINUX_EFI_INITRD_MEDIA_GUID device path\n");
432f61900fdSArvind Sankar 	} else if (status == EFI_NOT_FOUND) {
433f61900fdSArvind Sankar 		status = efi_load_initrd_cmdline(image, load_addr, load_size,
434f61900fdSArvind Sankar 						 soft_limit, hard_limit);
435f61900fdSArvind Sankar 		if (status == EFI_SUCCESS && *load_size > 0)
436f61900fdSArvind Sankar 			efi_info("Loaded initrd from command line option\n");
437f61900fdSArvind Sankar 	}
438f61900fdSArvind Sankar 
439f61900fdSArvind Sankar 	return status;
440f61900fdSArvind Sankar }
441