main.c revision 329183 
1/*-
2 * Copyright (c) 2008-2010 Rui Paulo
3 * Copyright (c) 2006 Marcel Moolenaar
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#include <sys/cdefs.h>
29__FBSDID("$FreeBSD: stable/11/stand/efi/loader/main.c 329183 2018-02-12 20:51:28Z kevans $");
30
31#include <sys/disk.h>
32#include <sys/param.h>
33#include <sys/reboot.h>
34#include <sys/boot.h>
35#include <stdint.h>
36#include <stand.h>
37#include <string.h>
38#include <setjmp.h>
39#include <disk.h>
40
41#include <efi.h>
42#include <efilib.h>
43
44#include <uuid.h>
45
46#include <bootstrap.h>
47#include <smbios.h>
48
49#ifdef EFI_ZFS_BOOT
50#include <libzfs.h>
51
52#include "efizfs.h"
53#endif
54
55#include "loader_efi.h"
56
57extern char bootprog_info[];
58
59struct arch_switch archsw;	/* MI/MD interface boundary */
60
61EFI_GUID acpi = ACPI_TABLE_GUID;
62EFI_GUID acpi20 = ACPI_20_TABLE_GUID;
63EFI_GUID devid = DEVICE_PATH_PROTOCOL;
64EFI_GUID imgid = LOADED_IMAGE_PROTOCOL;
65EFI_GUID mps = MPS_TABLE_GUID;
66EFI_GUID netid = EFI_SIMPLE_NETWORK_PROTOCOL;
67EFI_GUID smbios = SMBIOS_TABLE_GUID;
68EFI_GUID smbios3 = SMBIOS3_TABLE_GUID;
69EFI_GUID dxe = DXE_SERVICES_TABLE_GUID;
70EFI_GUID hoblist = HOB_LIST_TABLE_GUID;
71EFI_GUID lzmadecomp = LZMA_DECOMPRESSION_GUID;
72EFI_GUID mpcore = ARM_MP_CORE_INFO_TABLE_GUID;
73EFI_GUID esrt = ESRT_TABLE_GUID;
74EFI_GUID memtype = MEMORY_TYPE_INFORMATION_TABLE_GUID;
75EFI_GUID debugimg = DEBUG_IMAGE_INFO_TABLE_GUID;
76EFI_GUID fdtdtb = FDT_TABLE_GUID;
77EFI_GUID inputid = SIMPLE_TEXT_INPUT_PROTOCOL;
78
79static EFI_LOADED_IMAGE *img;
80
81#ifdef	EFI_ZFS_BOOT
82bool
83efi_zfs_is_preferred(EFI_HANDLE *h)
84{
85        return (h == img->DeviceHandle);
86}
87#endif
88
89static int
90has_keyboard(void)
91{
92	EFI_STATUS status;
93	EFI_DEVICE_PATH *path;
94	EFI_HANDLE *hin, *hin_end, *walker;
95	UINTN sz;
96	int retval = 0;
97
98	/*
99	 * Find all the handles that support the SIMPLE_TEXT_INPUT_PROTOCOL and
100	 * do the typical dance to get the right sized buffer.
101	 */
102	sz = 0;
103	hin = NULL;
104	status = BS->LocateHandle(ByProtocol, &inputid, 0, &sz, 0);
105	if (status == EFI_BUFFER_TOO_SMALL) {
106		hin = (EFI_HANDLE *)malloc(sz);
107		status = BS->LocateHandle(ByProtocol, &inputid, 0, &sz,
108		    hin);
109		if (EFI_ERROR(status))
110			free(hin);
111	}
112	if (EFI_ERROR(status))
113		return retval;
114
115	/*
116	 * Look at each of the handles. If it supports the device path protocol,
117	 * use it to get the device path for this handle. Then see if that
118	 * device path matches either the USB device path for keyboards or the
119	 * legacy device path for keyboards.
120	 */
121	hin_end = &hin[sz / sizeof(*hin)];
122	for (walker = hin; walker < hin_end; walker++) {
123		status = BS->HandleProtocol(*walker, &devid, (VOID **)&path);
124		if (EFI_ERROR(status))
125			continue;
126
127		while (!IsDevicePathEnd(path)) {
128			/*
129			 * Check for the ACPI keyboard node. All PNP3xx nodes
130			 * are keyboards of different flavors. Note: It is
131			 * unclear of there's always a keyboard node when
132			 * there's a keyboard controller, or if there's only one
133			 * when a keyboard is detected at boot.
134			 */
135			if (DevicePathType(path) == ACPI_DEVICE_PATH &&
136			    (DevicePathSubType(path) == ACPI_DP ||
137				DevicePathSubType(path) == ACPI_EXTENDED_DP)) {
138				ACPI_HID_DEVICE_PATH  *acpi;
139
140				acpi = (ACPI_HID_DEVICE_PATH *)(void *)path;
141				if ((EISA_ID_TO_NUM(acpi->HID) & 0xff00) == 0x300 &&
142				    (acpi->HID & 0xffff) == PNP_EISA_ID_CONST) {
143					retval = 1;
144					goto out;
145				}
146			/*
147			 * Check for USB keyboard node, if present. Unlike a
148			 * PS/2 keyboard, these definitely only appear when
149			 * connected to the system.
150			 */
151			} else if (DevicePathType(path) == MESSAGING_DEVICE_PATH &&
152			    DevicePathSubType(path) == MSG_USB_CLASS_DP) {
153				USB_CLASS_DEVICE_PATH *usb;
154
155				usb = (USB_CLASS_DEVICE_PATH *)(void *)path;
156				if (usb->DeviceClass == 3 && /* HID */
157				    usb->DeviceSubClass == 1 && /* Boot devices */
158				    usb->DeviceProtocol == 1) { /* Boot keyboards */
159					retval = 1;
160					goto out;
161				}
162			}
163			path = NextDevicePathNode(path);
164		}
165	}
166out:
167	free(hin);
168	return retval;
169}
170
171static void
172set_devdesc_currdev(struct devsw *dev, int unit)
173{
174	struct devdesc currdev;
175	char *devname;
176
177	currdev.d_dev = dev;
178	currdev.d_type = currdev.d_dev->dv_type;
179	currdev.d_unit = unit;
180	currdev.d_opendata = NULL;
181	devname = efi_fmtdev(&currdev);
182
183	env_setenv("currdev", EV_VOLATILE, devname, efi_setcurrdev,
184	    env_nounset);
185	env_setenv("loaddev", EV_VOLATILE, devname, env_noset, env_nounset);
186}
187
188static int
189find_currdev(EFI_LOADED_IMAGE *img)
190{
191	pdinfo_list_t *pdi_list;
192	pdinfo_t *dp, *pp;
193	EFI_DEVICE_PATH *devpath, *copy;
194	EFI_HANDLE h;
195	char *devname;
196	struct devsw *dev;
197	int unit;
198	uint64_t extra;
199
200#ifdef EFI_ZFS_BOOT
201	/* Did efi_zfs_probe() detect the boot pool? */
202	if (pool_guid != 0) {
203		struct zfs_devdesc currdev;
204
205		currdev.d_dev = &zfs_dev;
206		currdev.d_unit = 0;
207		currdev.d_type = currdev.d_dev->dv_type;
208		currdev.d_opendata = NULL;
209		currdev.pool_guid = pool_guid;
210		currdev.root_guid = 0;
211		devname = efi_fmtdev(&currdev);
212
213		env_setenv("currdev", EV_VOLATILE, devname, efi_setcurrdev,
214		    env_nounset);
215		env_setenv("loaddev", EV_VOLATILE, devname, env_noset,
216		    env_nounset);
217		init_zfs_bootenv(devname);
218		return (0);
219	}
220#endif /* EFI_ZFS_BOOT */
221
222	/* We have device lists for hd, cd, fd, walk them all. */
223	pdi_list = efiblk_get_pdinfo_list(&efipart_hddev);
224	STAILQ_FOREACH(dp, pdi_list, pd_link) {
225		struct disk_devdesc currdev;
226
227		currdev.d_dev = &efipart_hddev;
228		currdev.d_type = currdev.d_dev->dv_type;
229		currdev.d_unit = dp->pd_unit;
230		currdev.d_opendata = NULL;
231		currdev.d_slice = -1;
232		currdev.d_partition = -1;
233
234		if (dp->pd_handle == img->DeviceHandle) {
235			devname = efi_fmtdev(&currdev);
236
237			env_setenv("currdev", EV_VOLATILE, devname,
238			    efi_setcurrdev, env_nounset);
239			env_setenv("loaddev", EV_VOLATILE, devname,
240			    env_noset, env_nounset);
241			return (0);
242		}
243		/* Assuming GPT partitioning. */
244		STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
245			if (pp->pd_handle == img->DeviceHandle) {
246				currdev.d_slice = pp->pd_unit;
247				currdev.d_partition = 255;
248				devname = efi_fmtdev(&currdev);
249
250				env_setenv("currdev", EV_VOLATILE, devname,
251				    efi_setcurrdev, env_nounset);
252				env_setenv("loaddev", EV_VOLATILE, devname,
253				    env_noset, env_nounset);
254				return (0);
255			}
256		}
257	}
258
259	pdi_list = efiblk_get_pdinfo_list(&efipart_cddev);
260	STAILQ_FOREACH(dp, pdi_list, pd_link) {
261		if (dp->pd_handle == img->DeviceHandle ||
262		    dp->pd_alias == img->DeviceHandle) {
263			set_devdesc_currdev(&efipart_cddev, dp->pd_unit);
264			return (0);
265		}
266	}
267
268	pdi_list = efiblk_get_pdinfo_list(&efipart_fddev);
269	STAILQ_FOREACH(dp, pdi_list, pd_link) {
270		if (dp->pd_handle == img->DeviceHandle) {
271			set_devdesc_currdev(&efipart_fddev, dp->pd_unit);
272			return (0);
273		}
274	}
275
276	/*
277	 * Try the device handle from our loaded image first.  If that
278	 * fails, use the device path from the loaded image and see if
279	 * any of the nodes in that path match one of the enumerated
280	 * handles.
281	 */
282	if (efi_handle_lookup(img->DeviceHandle, &dev, &unit, &extra) == 0) {
283		set_devdesc_currdev(dev, unit);
284		return (0);
285	}
286
287	copy = NULL;
288	devpath = efi_lookup_image_devpath(IH);
289	while (devpath != NULL) {
290		h = efi_devpath_handle(devpath);
291		if (h == NULL)
292			break;
293
294		free(copy);
295		copy = NULL;
296
297		if (efi_handle_lookup(h, &dev, &unit, &extra) == 0) {
298			set_devdesc_currdev(dev, unit);
299			return (0);
300		}
301
302		devpath = efi_lookup_devpath(h);
303		if (devpath != NULL) {
304			copy = efi_devpath_trim(devpath);
305			devpath = copy;
306		}
307	}
308	free(copy);
309
310	return (ENOENT);
311}
312
313EFI_STATUS
314main(int argc, CHAR16 *argv[])
315{
316	char var[128];
317	EFI_GUID *guid;
318	int i, j, vargood, howto;
319	UINTN k;
320	int has_kbd;
321#if !defined(__arm__)
322	char buf[40];
323#endif
324
325	archsw.arch_autoload = efi_autoload;
326	archsw.arch_getdev = efi_getdev;
327	archsw.arch_copyin = efi_copyin;
328	archsw.arch_copyout = efi_copyout;
329	archsw.arch_readin = efi_readin;
330#ifdef EFI_ZFS_BOOT
331	/* Note this needs to be set before ZFS init. */
332	archsw.arch_zfs_probe = efi_zfs_probe;
333#endif
334
335        /* Get our loaded image protocol interface structure. */
336	BS->HandleProtocol(IH, &imgid, (VOID**)&img);
337
338	/* Init the time source */
339	efi_time_init();
340
341	has_kbd = has_keyboard();
342
343	/*
344	 * XXX Chicken-and-egg problem; we want to have console output
345	 * early, but some console attributes may depend on reading from
346	 * eg. the boot device, which we can't do yet.  We can use
347	 * printf() etc. once this is done.
348	 */
349	cons_probe();
350
351	/*
352	 * Initialise the block cache. Set the upper limit.
353	 */
354	bcache_init(32768, 512);
355
356	/*
357	 * Parse the args to set the console settings, etc
358	 * boot1.efi passes these in, if it can read /boot.config or /boot/config
359	 * or iPXE may be setup to pass these in.
360	 *
361	 * Loop through the args, and for each one that contains an '=' that is
362	 * not the first character, add it to the environment.  This allows
363	 * loader and kernel env vars to be passed on the command line.  Convert
364	 * args from UCS-2 to ASCII (16 to 8 bit) as they are copied.
365	 */
366	howto = 0;
367	for (i = 1; i < argc; i++) {
368		if (argv[i][0] == '-') {
369			for (j = 1; argv[i][j] != 0; j++) {
370				int ch;
371
372				ch = argv[i][j];
373				switch (ch) {
374				case 'a':
375					howto |= RB_ASKNAME;
376					break;
377				case 'd':
378					howto |= RB_KDB;
379					break;
380				case 'D':
381					howto |= RB_MULTIPLE;
382					break;
383				case 'h':
384					howto |= RB_SERIAL;
385					break;
386				case 'm':
387					howto |= RB_MUTE;
388					break;
389				case 'p':
390					howto |= RB_PAUSE;
391					break;
392				case 'P':
393					if (!has_kbd)
394						howto |= RB_SERIAL | RB_MULTIPLE;
395					break;
396				case 'r':
397					howto |= RB_DFLTROOT;
398					break;
399				case 's':
400					howto |= RB_SINGLE;
401					break;
402				case 'S':
403					if (argv[i][j + 1] == 0) {
404						if (i + 1 == argc) {
405							setenv("comconsole_speed", "115200", 1);
406						} else {
407							cpy16to8(&argv[i + 1][0], var,
408							    sizeof(var));
409							setenv("comconsole_speed", var, 1);
410						}
411						i++;
412						break;
413					} else {
414						cpy16to8(&argv[i][j + 1], var,
415						    sizeof(var));
416						setenv("comconsole_speed", var, 1);
417						break;
418					}
419				case 'v':
420					howto |= RB_VERBOSE;
421					break;
422				}
423			}
424		} else {
425			vargood = 0;
426			for (j = 0; argv[i][j] != 0; j++) {
427				if (j == sizeof(var)) {
428					vargood = 0;
429					break;
430				}
431				if (j > 0 && argv[i][j] == '=')
432					vargood = 1;
433				var[j] = (char)argv[i][j];
434			}
435			if (vargood) {
436				var[j] = 0;
437				putenv(var);
438			}
439		}
440	}
441	for (i = 0; howto_names[i].ev != NULL; i++)
442		if (howto & howto_names[i].mask)
443			setenv(howto_names[i].ev, "YES", 1);
444	if (howto & RB_MULTIPLE) {
445		if (howto & RB_SERIAL)
446			setenv("console", "comconsole efi" , 1);
447		else
448			setenv("console", "efi comconsole" , 1);
449	} else if (howto & RB_SERIAL) {
450		setenv("console", "comconsole" , 1);
451	}
452
453	if (efi_copy_init()) {
454		printf("failed to allocate staging area\n");
455		return (EFI_BUFFER_TOO_SMALL);
456	}
457
458	/*
459	 * March through the device switch probing for things.
460	 */
461	for (i = 0; devsw[i] != NULL; i++)
462		if (devsw[i]->dv_init != NULL)
463			(devsw[i]->dv_init)();
464
465	printf("Command line arguments:");
466	for (i = 0; i < argc; i++)
467		printf(" %S", argv[i]);
468	printf("\n");
469
470	printf("Image base: 0x%lx\n", (u_long)img->ImageBase);
471	printf("EFI version: %d.%02d\n", ST->Hdr.Revision >> 16,
472	    ST->Hdr.Revision & 0xffff);
473	printf("EFI Firmware: %S (rev %d.%02d)\n", ST->FirmwareVendor,
474	    ST->FirmwareRevision >> 16, ST->FirmwareRevision & 0xffff);
475
476	printf("\n%s", bootprog_info);
477
478	/*
479	 * Disable the watchdog timer. By default the boot manager sets
480	 * the timer to 5 minutes before invoking a boot option. If we
481	 * want to return to the boot manager, we have to disable the
482	 * watchdog timer and since we're an interactive program, we don't
483	 * want to wait until the user types "quit". The timer may have
484	 * fired by then. We don't care if this fails. It does not prevent
485	 * normal functioning in any way...
486	 */
487	BS->SetWatchdogTimer(0, 0, 0, NULL);
488
489	if (find_currdev(img) != 0)
490		return (EFI_NOT_FOUND);
491
492	efi_init_environment();
493	setenv("LINES", "24", 1);	/* optional */
494
495	for (k = 0; k < ST->NumberOfTableEntries; k++) {
496		guid = &ST->ConfigurationTable[k].VendorGuid;
497#if !defined(__arm__)
498		if (!memcmp(guid, &smbios, sizeof(EFI_GUID))) {
499			snprintf(buf, sizeof(buf), "%p",
500			    ST->ConfigurationTable[k].VendorTable);
501			setenv("hint.smbios.0.mem", buf, 1);
502			smbios_detect(ST->ConfigurationTable[k].VendorTable);
503			break;
504		}
505#endif
506	}
507
508	interact();			/* doesn't return */
509
510	return (EFI_SUCCESS);		/* keep compiler happy */
511}
512
513COMMAND_SET(reboot, "reboot", "reboot the system", command_reboot);
514
515static int
516command_reboot(int argc, char *argv[])
517{
518	int i;
519
520	for (i = 0; devsw[i] != NULL; ++i)
521		if (devsw[i]->dv_cleanup != NULL)
522			(devsw[i]->dv_cleanup)();
523
524	RS->ResetSystem(EfiResetCold, EFI_SUCCESS, 0, NULL);
525
526	/* NOTREACHED */
527	return (CMD_ERROR);
528}
529
530COMMAND_SET(quit, "quit", "exit the loader", command_quit);
531
532static int
533command_quit(int argc, char *argv[])
534{
535	exit(0);
536	return (CMD_OK);
537}
538
539COMMAND_SET(memmap, "memmap", "print memory map", command_memmap);
540
541static int
542command_memmap(int argc, char *argv[])
543{
544	UINTN sz;
545	EFI_MEMORY_DESCRIPTOR *map, *p;
546	UINTN key, dsz;
547	UINT32 dver;
548	EFI_STATUS status;
549	int i, ndesc;
550	char line[80];
551	static char *types[] = {
552	    "Reserved",
553	    "LoaderCode",
554	    "LoaderData",
555	    "BootServicesCode",
556	    "BootServicesData",
557	    "RuntimeServicesCode",
558	    "RuntimeServicesData",
559	    "ConventionalMemory",
560	    "UnusableMemory",
561	    "ACPIReclaimMemory",
562	    "ACPIMemoryNVS",
563	    "MemoryMappedIO",
564	    "MemoryMappedIOPortSpace",
565	    "PalCode"
566	};
567
568	sz = 0;
569	status = BS->GetMemoryMap(&sz, 0, &key, &dsz, &dver);
570	if (status != EFI_BUFFER_TOO_SMALL) {
571		printf("Can't determine memory map size\n");
572		return (CMD_ERROR);
573	}
574	map = malloc(sz);
575	status = BS->GetMemoryMap(&sz, map, &key, &dsz, &dver);
576	if (EFI_ERROR(status)) {
577		printf("Can't read memory map\n");
578		return (CMD_ERROR);
579	}
580
581	ndesc = sz / dsz;
582	snprintf(line, sizeof(line), "%23s %12s %12s %8s %4s\n",
583	    "Type", "Physical", "Virtual", "#Pages", "Attr");
584	pager_open();
585	if (pager_output(line)) {
586		pager_close();
587		return (CMD_OK);
588	}
589
590	for (i = 0, p = map; i < ndesc;
591	     i++, p = NextMemoryDescriptor(p, dsz)) {
592		printf("%23s %012jx %012jx %08jx ", types[p->Type],
593		    (uintmax_t)p->PhysicalStart, (uintmax_t)p->VirtualStart,
594		    (uintmax_t)p->NumberOfPages);
595		if (p->Attribute & EFI_MEMORY_UC)
596			printf("UC ");
597		if (p->Attribute & EFI_MEMORY_WC)
598			printf("WC ");
599		if (p->Attribute & EFI_MEMORY_WT)
600			printf("WT ");
601		if (p->Attribute & EFI_MEMORY_WB)
602			printf("WB ");
603		if (p->Attribute & EFI_MEMORY_UCE)
604			printf("UCE ");
605		if (p->Attribute & EFI_MEMORY_WP)
606			printf("WP ");
607		if (p->Attribute & EFI_MEMORY_RP)
608			printf("RP ");
609		if (p->Attribute & EFI_MEMORY_XP)
610			printf("XP ");
611		if (pager_output("\n"))
612			break;
613	}
614
615	pager_close();
616	return (CMD_OK);
617}
618
619COMMAND_SET(configuration, "configuration", "print configuration tables",
620    command_configuration);
621
622static const char *
623guid_to_string(EFI_GUID *guid)
624{
625	static char buf[40];
626
627	sprintf(buf, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
628	    guid->Data1, guid->Data2, guid->Data3, guid->Data4[0],
629	    guid->Data4[1], guid->Data4[2], guid->Data4[3], guid->Data4[4],
630	    guid->Data4[5], guid->Data4[6], guid->Data4[7]);
631	return (buf);
632}
633
634static int
635command_configuration(int argc, char *argv[])
636{
637	char line[80];
638	UINTN i;
639
640	snprintf(line, sizeof(line), "NumberOfTableEntries=%lu\n",
641		(unsigned long)ST->NumberOfTableEntries);
642	pager_open();
643	if (pager_output(line)) {
644		pager_close();
645		return (CMD_OK);
646	}
647
648	for (i = 0; i < ST->NumberOfTableEntries; i++) {
649		EFI_GUID *guid;
650
651		printf("  ");
652		guid = &ST->ConfigurationTable[i].VendorGuid;
653		if (!memcmp(guid, &mps, sizeof(EFI_GUID)))
654			printf("MPS Table");
655		else if (!memcmp(guid, &acpi, sizeof(EFI_GUID)))
656			printf("ACPI Table");
657		else if (!memcmp(guid, &acpi20, sizeof(EFI_GUID)))
658			printf("ACPI 2.0 Table");
659		else if (!memcmp(guid, &smbios, sizeof(EFI_GUID)))
660			printf("SMBIOS Table %p",
661			    ST->ConfigurationTable[i].VendorTable);
662		else if (!memcmp(guid, &smbios3, sizeof(EFI_GUID)))
663			printf("SMBIOS3 Table");
664		else if (!memcmp(guid, &dxe, sizeof(EFI_GUID)))
665			printf("DXE Table");
666		else if (!memcmp(guid, &hoblist, sizeof(EFI_GUID)))
667			printf("HOB List Table");
668		else if (!memcmp(guid, &lzmadecomp, sizeof(EFI_GUID)))
669			printf("LZMA Compression");
670		else if (!memcmp(guid, &mpcore, sizeof(EFI_GUID)))
671			printf("ARM MpCore Information Table");
672		else if (!memcmp(guid, &esrt, sizeof(EFI_GUID)))
673			printf("ESRT Table");
674		else if (!memcmp(guid, &memtype, sizeof(EFI_GUID)))
675			printf("Memory Type Information Table");
676		else if (!memcmp(guid, &debugimg, sizeof(EFI_GUID)))
677			printf("Debug Image Info Table");
678		else if (!memcmp(guid, &fdtdtb, sizeof(EFI_GUID)))
679			printf("FDT Table");
680		else
681			printf("Unknown Table (%s)", guid_to_string(guid));
682		snprintf(line, sizeof(line), " at %p\n",
683		    ST->ConfigurationTable[i].VendorTable);
684		if (pager_output(line))
685			break;
686	}
687
688	pager_close();
689	return (CMD_OK);
690}
691
692
693COMMAND_SET(mode, "mode", "change or display EFI text modes", command_mode);
694
695static int
696command_mode(int argc, char *argv[])
697{
698	UINTN cols, rows;
699	unsigned int mode;
700	int i;
701	char *cp;
702	char rowenv[8];
703	EFI_STATUS status;
704	SIMPLE_TEXT_OUTPUT_INTERFACE *conout;
705	extern void HO(void);
706
707	conout = ST->ConOut;
708
709	if (argc > 1) {
710		mode = strtol(argv[1], &cp, 0);
711		if (cp[0] != '\0') {
712			printf("Invalid mode\n");
713			return (CMD_ERROR);
714		}
715		status = conout->QueryMode(conout, mode, &cols, &rows);
716		if (EFI_ERROR(status)) {
717			printf("invalid mode %d\n", mode);
718			return (CMD_ERROR);
719		}
720		status = conout->SetMode(conout, mode);
721		if (EFI_ERROR(status)) {
722			printf("couldn't set mode %d\n", mode);
723			return (CMD_ERROR);
724		}
725		sprintf(rowenv, "%u", (unsigned)rows);
726		setenv("LINES", rowenv, 1);
727		HO();		/* set cursor */
728		return (CMD_OK);
729	}
730
731	printf("Current mode: %d\n", conout->Mode->Mode);
732	for (i = 0; i <= conout->Mode->MaxMode; i++) {
733		status = conout->QueryMode(conout, i, &cols, &rows);
734		if (EFI_ERROR(status))
735			continue;
736		printf("Mode %d: %u columns, %u rows\n", i, (unsigned)cols,
737		    (unsigned)rows);
738	}
739
740	if (i != 0)
741		printf("Select a mode with the command \"mode <number>\"\n");
742
743	return (CMD_OK);
744}
745
746#ifdef EFI_ZFS_BOOT
747COMMAND_SET(lszfs, "lszfs", "list child datasets of a zfs dataset",
748    command_lszfs);
749
750static int
751command_lszfs(int argc, char *argv[])
752{
753	int err;
754
755	if (argc != 2) {
756		command_errmsg = "wrong number of arguments";
757		return (CMD_ERROR);
758	}
759
760	err = zfs_list(argv[1]);
761	if (err != 0) {
762		command_errmsg = strerror(err);
763		return (CMD_ERROR);
764	}
765	return (CMD_OK);
766}
767
768COMMAND_SET(reloadbe, "reloadbe", "refresh the list of ZFS Boot Environments",
769	    command_reloadbe);
770
771static int
772command_reloadbe(int argc, char *argv[])
773{
774	int err;
775	char *root;
776
777	if (argc > 2) {
778		command_errmsg = "wrong number of arguments";
779		return (CMD_ERROR);
780	}
781
782	if (argc == 2) {
783		err = zfs_bootenv(argv[1]);
784	} else {
785		root = getenv("zfs_be_root");
786		if (root == NULL) {
787			return (CMD_OK);
788		}
789		err = zfs_bootenv(root);
790	}
791
792	if (err != 0) {
793		command_errmsg = strerror(err);
794		return (CMD_ERROR);
795	}
796
797	return (CMD_OK);
798}
799#endif
800
801#ifdef LOADER_FDT_SUPPORT
802extern int command_fdt_internal(int argc, char *argv[]);
803
804/*
805 * Since proper fdt command handling function is defined in fdt_loader_cmd.c,
806 * and declaring it as extern is in contradiction with COMMAND_SET() macro
807 * (which uses static pointer), we're defining wrapper function, which
808 * calls the proper fdt handling routine.
809 */
810static int
811command_fdt(int argc, char *argv[])
812{
813
814	return (command_fdt_internal(argc, argv));
815}
816
817COMMAND_SET(fdt, "fdt", "flattened device tree handling", command_fdt);
818#endif
819
820/*
821 * Chain load another efi loader.
822 */
823static int
824command_chain(int argc, char *argv[])
825{
826	EFI_GUID LoadedImageGUID = LOADED_IMAGE_PROTOCOL;
827	EFI_HANDLE loaderhandle;
828	EFI_LOADED_IMAGE *loaded_image;
829	EFI_STATUS status;
830	struct stat st;
831	struct devdesc *dev;
832	char *name, *path;
833	void *buf;
834	int fd;
835
836	if (argc < 2) {
837		command_errmsg = "wrong number of arguments";
838		return (CMD_ERROR);
839	}
840
841	name = argv[1];
842
843	if ((fd = open(name, O_RDONLY)) < 0) {
844		command_errmsg = "no such file";
845		return (CMD_ERROR);
846	}
847
848	if (fstat(fd, &st) < -1) {
849		command_errmsg = "stat failed";
850		close(fd);
851		return (CMD_ERROR);
852	}
853
854	status = BS->AllocatePool(EfiLoaderCode, (UINTN)st.st_size, &buf);
855	if (status != EFI_SUCCESS) {
856		command_errmsg = "failed to allocate buffer";
857		close(fd);
858		return (CMD_ERROR);
859	}
860	if (read(fd, buf, st.st_size) != st.st_size) {
861		command_errmsg = "error while reading the file";
862		(void)BS->FreePool(buf);
863		close(fd);
864		return (CMD_ERROR);
865	}
866	close(fd);
867	status = BS->LoadImage(FALSE, IH, NULL, buf, st.st_size, &loaderhandle);
868	(void)BS->FreePool(buf);
869	if (status != EFI_SUCCESS) {
870		command_errmsg = "LoadImage failed";
871		return (CMD_ERROR);
872	}
873	status = BS->HandleProtocol(loaderhandle, &LoadedImageGUID,
874	    (void **)&loaded_image);
875
876	if (argc > 2) {
877		int i, len = 0;
878		CHAR16 *argp;
879
880		for (i = 2; i < argc; i++)
881			len += strlen(argv[i]) + 1;
882
883		len *= sizeof (*argp);
884		loaded_image->LoadOptions = argp = malloc (len);
885		loaded_image->LoadOptionsSize = len;
886		for (i = 2; i < argc; i++) {
887			char *ptr = argv[i];
888			while (*ptr)
889				*(argp++) = *(ptr++);
890			*(argp++) = ' ';
891		}
892		*(--argv) = 0;
893	}
894
895	if (efi_getdev((void **)&dev, name, (const char **)&path) == 0) {
896#ifdef EFI_ZFS_BOOT
897		struct zfs_devdesc *z_dev;
898#endif
899		struct disk_devdesc *d_dev;
900		pdinfo_t *hd, *pd;
901
902		switch (dev->d_type) {
903#ifdef EFI_ZFS_BOOT
904		case DEVT_ZFS:
905			z_dev = (struct zfs_devdesc *)dev;
906			loaded_image->DeviceHandle =
907			    efizfs_get_handle_by_guid(z_dev->pool_guid);
908			break;
909#endif
910		case DEVT_NET:
911			loaded_image->DeviceHandle =
912			    efi_find_handle(dev->d_dev, dev->d_unit);
913			break;
914		default:
915			hd = efiblk_get_pdinfo(dev);
916			if (STAILQ_EMPTY(&hd->pd_part)) {
917				loaded_image->DeviceHandle = hd->pd_handle;
918				break;
919			}
920			d_dev = (struct disk_devdesc *)dev;
921			STAILQ_FOREACH(pd, &hd->pd_part, pd_link) {
922				/*
923				 * d_partition should be 255
924				 */
925				if (pd->pd_unit == (uint32_t)d_dev->d_slice) {
926					loaded_image->DeviceHandle =
927					    pd->pd_handle;
928					break;
929				}
930			}
931			break;
932		}
933	}
934
935	dev_cleanup();
936	status = BS->StartImage(loaderhandle, NULL, NULL);
937	if (status != EFI_SUCCESS) {
938		command_errmsg = "StartImage failed";
939		free(loaded_image->LoadOptions);
940		loaded_image->LoadOptions = NULL;
941		status = BS->UnloadImage(loaded_image);
942		return (CMD_ERROR);
943	}
944
945	return (CMD_ERROR);	/* not reached */
946}
947
948COMMAND_SET(chain, "chain", "chain load file", command_chain);
949