D5108.id12876.diff
No OneTemporary
Actions

Size

19 KB

Referenced Files

None

Subscribers

None

D5108.id12876.diff
View Options

	Index: sys/boot/efi/boot1/boot1.c
	===================================================================
	--- sys/boot/efi/boot1/boot1.c
	+++ sys/boot/efi/boot1/boot1.c
	@@ -50,8 +50,9 @@
	void putchar(int c);
	EFI_STATUS efi_main(EFI_HANDLE Ximage, EFI_SYSTEM_TABLE* Xsystab);

	-static void try_load(const boot_module_t* mod);
	-static EFI_STATUS probe_handle(EFI_HANDLE h);
	+static void probe_handle_status(EFI_HANDLE h, EFI_DEVICE_PATH *imgpath);
	+static EFI_STATUS probe_handle(EFI_HANDLE h, EFI_DEVICE_PATH *imgpath,
	+ BOOLEAN *preferred);

	EFI_SYSTEM_TABLE *systab;
	EFI_BOOT_SERVICES *bs;
	@@ -84,21 +85,258 @@
	(void)bs->FreePool(buf);
	}

	+static BOOLEAN
	+nodes_match(EFI_DEVICE_PATH imgpath, EFI_DEVICE_PATH devpath)
	+{
	+ int len;
	+
	+ if (imgpath == NULL \|\| imgpath->Type != devpath->Type \|\|
	+ imgpath->SubType != devpath->SubType)
	+ return (FALSE);
	+
	+ len = DevicePathNodeLength(imgpath);
	+
	+ if (len != DevicePathNodeLength(devpath))
	+ return (FALSE);
	+
	+ return (memcmp(imgpath, devpath, (size_t)len) == 0);
	+}
	+
	+static BOOLEAN
	+msg_paths_match(EFI_DEVICE_PATH imgpath, EFI_DEVICE_PATH devpath)
	+{
	+
	+ while (!IsDevicePathEnd(imgpath) && !IsDevicePathEnd(devpath)) {
	+ if (!nodes_match(imgpath, devpath))
	+ return (FALSE);
	+
	+ if (IsDevicePathType(imgpath, MESSAGING_DEVICE_PATH))
	+ return (TRUE);
	+
	+ imgpath = NextDevicePathNode(imgpath);
	+ devpath = NextDevicePathNode(devpath);
	+ }
	+
	+ return (FALSE);
	+}
	+
	+static EFI_DEVICE_PATH *
	+devpath_last(EFI_DEVICE_PATH *devpath)
	+{
	+
	+ while (!IsDevicePathEnd(NextDevicePathNode(devpath)))
	+ devpath = NextDevicePathNode(devpath);
	+
	+ return (devpath);
	+}
	+
	/*
	- * This function only returns if it fails to load the kernel. If it
	- * succeeds, it simply boots the kernel.
	+ * devpath_print_node is a basic output method for a devpath.
	+ * If we switch to UEFI 2.x then we should update it to use:
	+ * EFI_DEVICE_PATH_TO_TEXT_PROTOCOL.
	*/
	-void
	-try_load(const boot_module_t *mod)
	+static int
	+devpath_str_node(char buf, size_t size, EFI_DEVICE_PATH devpath)
	{
	- size_t bufsize, cmdsize;
	- void *buf;
	+
	+ switch (devpath->Type) {
	+ case MESSAGING_DEVICE_PATH:
	+ switch (devpath->SubType) {
	+ case MSG_ATAPI_DP: {
	+ ATAPI_DEVICE_PATH *atapi;
	+
	+ atapi = (ATAPI_DEVICE_PATH )(void )devpath;
	+ return snprintf(buf, size, "ata(%s,%s,0x%x)",
	+ (atapi->PrimarySecondary == 1) ? "Sec" : "Pri",
	+ (atapi->SlaveMaster == 1) ? "Slave" : "Master",
	+ atapi->Lun);
	+ }
	+ case MSG_USB_DP: {
	+ USB_DEVICE_PATH *usb;
	+
	+ usb = (USB_DEVICE_PATH *)devpath;
	+ return snprintf(buf, size, "usb(0x%02x,0x%02x)",
	+ usb->ParentPortNumber, usb->InterfaceNumber);
	+ }
	+ case MSG_SCSI_DP: {
	+ SCSI_DEVICE_PATH *scsi;
	+
	+ scsi = (SCSI_DEVICE_PATH )(void )devpath;
	+ return snprintf(buf, size, "scsi(0x%02x,0x%02x)",
	+ scsi->Pun, scsi->Lun);
	+ }
	+ default:
	+ return snprintf(buf, size, "msg(0x%02x)",
	+ devpath->SubType);
	+ }
	+ break;
	+ case HARDWARE_DEVICE_PATH:
	+ switch (devpath->SubType) {
	+ case HW_PCI_DP: {
	+ PCI_DEVICE_PATH *pci;
	+
	+ pci = (PCI_DEVICE_PATH *)devpath;
	+ return snprintf(buf, size, "pci(0x%02x,0x%02x)",
	+ pci->Device, pci->Function);
	+ }
	+ default:
	+ return snprintf(buf, size, "hw(0x%02x)",
	+ devpath->SubType);
	+ }
	+ break;
	+ case ACPI_DEVICE_PATH: {
	+ ACPI_HID_DEVICE_PATH *acpi;
	+
	+ acpi = (ACPI_HID_DEVICE_PATH )(void )devpath;
	+ if ((acpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
	+ switch (EISA_ID_TO_NUM(acpi->HID)) {
	+ case 0x0a03:
	+ return snprintf(buf, size, "pciroot(0x%x)",
	+ acpi->UID);
	+ case 0x0a08:
	+ return snprintf(buf, size, "pcieroot(0x%x)",
	+ acpi->UID);
	+ case 0x0604:
	+ return snprintf(buf, size, "floppy(0x%x)",
	+ acpi->UID);
	+ case 0x0301:
	+ return snprintf(buf, size, "keyboard(0x%x)",
	+ acpi->UID);
	+ case 0x0501:
	+ return snprintf(buf, size, "serial(0x%x)",
	+ acpi->UID);
	+ case 0x0401:
	+ return snprintf(buf, size, "parallelport(0x%x)",
	+ acpi->UID);
	+ default:
	+ return snprintf(buf, size, "acpi(pnp%04x,0x%x)",
	+ EISA_ID_TO_NUM(acpi->HID), acpi->UID);
	+ }
	+ }
	+
	+ return snprintf(buf, size, "acpi(0x%08x,0x%x)", acpi->HID,
	+ acpi->UID);
	+ }
	+ case MEDIA_DEVICE_PATH:
	+ switch (devpath->SubType) {
	+ case MEDIA_CDROM_DP: {
	+ CDROM_DEVICE_PATH *cdrom;
	+
	+ cdrom = (CDROM_DEVICE_PATH )(void )devpath;
	+ return snprintf(buf, size, "cdrom(%x)",
	+ cdrom->BootEntry);
	+ }
	+ case MEDIA_HARDDRIVE_DP: {
	+ HARDDRIVE_DEVICE_PATH *hd;
	+
	+ hd = (HARDDRIVE_DEVICE_PATH )(void )devpath;
	+ return snprintf(buf, size, "hd(%x)",
	+ hd->PartitionNumber);
	+ }
	+ default:
	+ return snprintf(buf, size, "media(0x%02x)",
	+ devpath->SubType);
	+ }
	+ case BBS_DEVICE_PATH:
	+ return snprintf(buf, size, "bbs(0x%02x)", devpath->SubType);
	+ case END_DEVICE_PATH_TYPE:
	+ return (0);
	+ }
	+
	+ return snprintf(buf, size, "type(0x%02x, 0x%02x)", devpath->Type,
	+ devpath->SubType);
	+}
	+
	+int
	+devpath_strncat(char buf, size_t size, EFI_DEVICE_PATH devpath)
	+{
	+ size_t len, used;
	+ const char *sep;
	+
	+ sep = "";
	+ used = 0;
	+ while (!IsDevicePathEnd(devpath)) {
	+ len = snprintf(buf, size - used, "%s", sep);
	+ used += len;
	+ if (used > size)
	+ return (used);
	+ buf += len;
	+
	+ len = devpath_str_node(buf, size - used, devpath);
	+ used += len;
	+ if (used > size)
	+ return (used);
	+ buf += len;
	+ devpath = NextDevicePathNode(devpath);
	+ sep = ":";
	+ }
	+
	+ return (used);
	+}
	+
	+char *
	+devpath_str(EFI_DEVICE_PATH *devpath)
	+{
	+ static char buf[128];
	+
	+ devpath_strncat(buf, sizeof(buf), devpath);
	+
	+ return buf;
	+}
	+
	+static EFI_STATUS
	+load_loader(const boot_module_t modp, dev_info_t devinfop, void **bufp,
	+ size_t *bufsize, BOOLEAN preferred)
	+{
	+ UINTN i;
	+ dev_info_t *dev;
	+ const boot_module_t *mod;
	+
	+ for (i = 0; i < NUM_BOOT_MODULES; i++) {
	+ if (boot_modules[i] == NULL)
	+ continue;
	+ mod = boot_modules[i];
	+ for (dev = mod->devices(); dev != NULL; dev = dev->next) {
	+ if (dev->preferred != preferred)
	+ continue;
	+
	+ if (mod->load(PATH_LOADER_EFI, dev, bufp, bufsize) ==
	+ EFI_SUCCESS) {
	+ *devinfop = dev;
	+ *modp = mod;
	+ return (EFI_SUCCESS);
	+ }
	+ }
	+ }
	+ printf("Failed to load %s\n", PATH_LOADER_EFI);
	+
	+ return (EFI_NOT_FOUND);
	+}
	+
	+/*
	+ * This function only returns if it fails to load the loader. If it succeeds
	+ * it simply boots.
	+ */
	+static EFI_STATUS
	+try_boot()
	+{
	+ size_t bufsize, loadersize, cmdsize;
	+ void buf, loaderbuf;
	char *cmd;
	dev_info_t *dev;
	+ const boot_module_t *mod;
	EFI_HANDLE loaderhandle;
	EFI_LOADED_IMAGE *loaded_image;
	EFI_STATUS status;

	+ status = load_loader(&mod, &dev, &loaderbuf, &loadersize, TRUE);
	+ if (status != EFI_SUCCESS)
	+ status = load_loader(&mod, &dev, &loaderbuf, &loadersize,
	+ FALSE);
	+
	+ if (status != EFI_SUCCESS)
	+ return (status);
	+
	/*
	* Read in and parse the command line from /boot.config or /boot/config,
	* if present. We'll pass it the next stage via a simple ASCII
	@@ -111,48 +349,37 @@
	*/
	cmd = NULL;
	cmdsize = 0;
	- status = mod->load(PATH_DOTCONFIG, &dev, &buf, &bufsize);
	+ status = mod->load(PATH_DOTCONFIG, dev, &buf, &bufsize);
	if (status == EFI_NOT_FOUND)
	- status = mod->load(PATH_CONFIG, &dev, &buf, &bufsize);
	+ status = mod->load(PATH_CONFIG, dev, &buf, &bufsize);
	if (status == EFI_SUCCESS) {
	cmdsize = bufsize + 1;
	cmd = malloc(cmdsize);
	- if (cmd == NULL) {
	- free(buf);
	- return;
	- }
	+ if (cmd == NULL)
	+ goto errout;
	memcpy(cmd, buf, bufsize);
	cmd[bufsize] = '\0';
	free(buf);
	+ buf = NULL;
	}

	- status = mod->load(PATH_LOADER_EFI, &dev, &buf, &bufsize);
	- if (status == EFI_NOT_FOUND)
	- return;
	-
	- if (status != EFI_SUCCESS) {
	- printf("%s failed to load %s (%lu)\n", mod->name,
	- PATH_LOADER_EFI, EFI_ERROR_CODE(status));
	- return;
	- }
	-
	- if ((status = bs->LoadImage(TRUE, image, dev->devpath, buf, bufsize,
	- &loaderhandle)) != EFI_SUCCESS) {
	+ if ((status = bs->LoadImage(TRUE, image, devpath_last(dev->devpath),
	+ loaderbuf, loadersize, &loaderhandle)) != EFI_SUCCESS) {
	printf("Failed to load image provided by %s, size: %zu, (%lu)\n",
	mod->name, bufsize, EFI_ERROR_CODE(status));
	- return;
	+ goto errout;
	}

	- if (cmd != NULL)
	- printf(" command args: %s\n", cmd);
	-
	if ((status = bs->HandleProtocol(loaderhandle, &LoadedImageGUID,
	(VOID**)&loaded_image)) != EFI_SUCCESS) {
	printf("Failed to query LoadedImage provided by %s (%lu)\n",
	mod->name, EFI_ERROR_CODE(status));
	- return;
	+ goto errout;
	}

	+ if (cmd != NULL)
	+ printf(" command args: %s\n", cmd);
	+
	loaded_image->DeviceHandle = dev->devhandle;
	loaded_image->LoadOptionsSize = cmdsize;
	loaded_image->LoadOptions = cmd;
	@@ -161,17 +388,26 @@
	EFI_SUCCESS) {
	printf("Failed to start image provided by %s (%lu)\n",
	mod->name, EFI_ERROR_CODE(status));
	- free(cmd);
	loaded_image->LoadOptionsSize = 0;
	loaded_image->LoadOptions = NULL;
	- return;
	}
	+errout:
	+ if (cmd != NULL)
	+ free(cmd);
	+ if (buf != NULL)
	+ free(buf);
	+ if (loaderbuf != NULL)
	+ free(loaderbuf);
	+
	+ return (status);
	}

	EFI_STATUS
	efi_main(EFI_HANDLE Ximage, EFI_SYSTEM_TABLE *Xsystab)
	{
	EFI_HANDLE *handles;
	+ EFI_LOADED_IMAGE *img;
	+ EFI_DEVICE_PATH *imgpath;
	EFI_STATUS status;
	EFI_CONSOLE_CONTROL_PROTOCOL *ConsoleControl = NULL;
	SIMPLE_TEXT_OUTPUT_INTERFACE *conout = NULL;
	@@ -254,20 +490,21 @@
	/* Scan all partitions, probing with all modules. */
	nhandles = hsize / sizeof(*handles);
	printf(" Probing %zu block devices...", nhandles);
	- for (i = 0; i < nhandles; i++) {
	- status = probe_handle(handles[i]);
	- switch (status) {
	- case EFI_UNSUPPORTED:
	- printf(".");
	- break;
	- case EFI_SUCCESS:
	- printf("+");
	- break;
	- default:
	- printf("x");
	- break;
	- }
	+ DPRINTF("\n");
	+
	+ /* Determine the devpath of our image so we can prefer it. */
	+ status = bs->HandleProtocol(image, &LoadedImageGUID, (VOID**)&img);
	+ imgpath = NULL;
	+ if (status == EFI_SUCCESS) {
	+ status = bs->HandleProtocol(img->DeviceHandle, &DevicePathGUID,
	+ (void **)&imgpath);
	+ if (status != EFI_SUCCESS)
	+ DPRINTF("Failed to get image DevicePath (%lu)\n",
	+ EFI_ERROR_CODE(status));
	}
	+
	+ for (i = 0; i < nhandles; i++)
	+ probe_handle_status(handles[i], imgpath);
	printf(" done\n");

	/* Status summary. */
	@@ -278,17 +515,44 @@
	}
	}

	- /* Select a partition to boot by trying each module in order. */
	- for (i = 0; i < NUM_BOOT_MODULES; i++)
	- if (boot_modules[i] != NULL)
	- try_load(boot_modules[i]);
	+ try_boot();

	/* If we get here, we're out of luck... */
	panic("No bootable partitions found!");
	}

	+static void
	+probe_handle_status(EFI_HANDLE h, EFI_DEVICE_PATH *imgpath)
	+{
	+ EFI_STATUS status;
	+ BOOLEAN preferred;
	+
	+ status = probe_handle(h, imgpath, &preferred);
	+
	+ DPRINTF("probe: ");
	+ switch (status) {
	+ case EFI_UNSUPPORTED:
	+ printf(".");
	+ DPRINTF(" not supported\n");
	+ break;
	+ case EFI_SUCCESS:
	+ if (preferred) {
	+ printf("%c", '*');
	+ DPRINTF(" supported (preferred)\n");
	+ } else {
	+ printf("%c", '+');
	+ DPRINTF(" supported\n");
	+ }
	+ break;
	+ default:
	+ printf("x");
	+ DPRINTF(" error (%lu)\n", EFI_ERROR_CODE(status));
	+ break;
	+ }
	+}
	+
	static EFI_STATUS
	-probe_handle(EFI_HANDLE h)
	+probe_handle(EFI_HANDLE h, EFI_DEVICE_PATH imgpath, BOOLEAN preferred)
	{
	dev_info_t *devinfo;
	EFI_BLOCK_IO *blkio;
	@@ -307,8 +571,9 @@
	return (status);
	}

	- while (!IsDevicePathEnd(NextDevicePathNode(devpath)))
	- devpath = NextDevicePathNode(devpath);
	+ DPRINTF("probing: %s\n", devpath_str(devpath));
	+
	+ *preferred = msg_paths_match(imgpath, devpath);

	status = bs->HandleProtocol(h, &BlockIoProtocolGUID, (void **)&blkio);
	if (status == EFI_UNSUPPORTED)
	@@ -339,6 +604,7 @@
	devinfo->devpath = devpath;
	devinfo->devhandle = h;
	devinfo->devdata = NULL;
	+ devinfo->preferred = *preferred;
	devinfo->next = NULL;

	status = boot_modules[i]->probe(devinfo);
	Index: sys/boot/efi/boot1/boot_module.h
	===================================================================
	--- sys/boot/efi/boot1/boot_module.h
	+++ sys/boot/efi/boot1/boot_module.h
	@@ -36,7 +36,7 @@
	#include <eficonsctl.h>

	#ifdef EFI_DEBUG
	-#define DPRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
	+#define DPRINTF(fmt, args...) printf(fmt, ##args)
	#else
	#define DPRINTF(fmt, ...) {}
	#endif
	@@ -48,6 +48,7 @@
	EFI_DEVICE_PATH *devpath;
	EFI_HANDLE *devhandle;
	void *devdata;
	+ BOOLEAN preferred;
	struct dev_info *next;
	} dev_info_t;

	@@ -75,19 +76,21 @@

	/*
	* load should select the best out of a set of devices that probe
	- * indicated were loadable and load it.
	+ * indicated were loadable and load the specified file.
	*
	* Return codes:
	* EFI_SUCCESS = The module can handle the device.
	* EFI_NOT_FOUND = The module can not handle the device.
	* Other = The module encountered an error.
	*/
	- EFI_STATUS (load)(const char loader_path, dev_info_t **devinfo,
	+ EFI_STATUS (load)(const char filepath, dev_info_t *devinfo,
	void *buf, size_t bufsize);

	/* status outputs information about the probed devices. */
	void (*status)();

	+ /* valid devices as found by probe. */
	+ dev_info_t (devices)();
	} boot_module_t;

	/* Standard boot modules. */
	@@ -107,4 +110,6 @@
	extern EFI_SYSTEM_TABLE *systab;
	extern EFI_BOOT_SERVICES *bs;

	+extern int devpath_strncat(char buf, size_t size, EFI_DEVICE_PATH devpath);
	+extern char devpath_str(EFI_DEVICE_PATH devpath);
	#endif
	Index: sys/boot/efi/boot1/ufs_module.c
	===================================================================
	--- sys/boot/efi/boot1/ufs_module.c
	+++ sys/boot/efi/boot1/ufs_module.c
	@@ -93,7 +93,7 @@
	}

	static EFI_STATUS
	-try_load(dev_info_t dev, const char loader_path, void *bufp, size_t bufsize)
	+load(const char filepath, dev_info_t dev, void *bufp, size_t bufsize)
	{
	ufs_ino_t ino;
	EFI_STATUS status;
	@@ -101,28 +101,35 @@
	ssize_t read;
	void *buf;

	- if (init_dev(dev) < 0)
	+ DPRINTF("load: '%s' devpath: %s\n", filepath,
	+ devpath_str(dev->devpath));
	+
	+ if (init_dev(dev) < 0) {
	+ DPRINTF("Failed to device %p\n", dev);
	return (EFI_UNSUPPORTED);
	+ }

	- if ((ino = lookup(loader_path)) == 0)
	+ if ((ino = lookup(filepath)) == 0) {
	+ DPRINTF("Failed to lookup '%s' on %p\n", filepath, dev);
	return (EFI_NOT_FOUND);
	+ }

	if (fsread_size(ino, NULL, 0, &size) < 0 \|\| size <= 0) {
	- printf("Failed to read size of '%s' ino: %d\n", loader_path,
	+ printf("Failed to read size of '%s' ino: %d\n", filepath,
	ino);
	return (EFI_INVALID_PARAMETER);
	}

	if ((status = bs->AllocatePool(EfiLoaderData, size, &buf)) !=
	EFI_SUCCESS) {
	- printf("Failed to allocate read buffer (%lu)\n",
	- EFI_ERROR_CODE(status));
	+ printf("Failed to allocate read buffer %zu for '%s' (%lu)\n",
	+ size, filepath, EFI_ERROR_CODE(status));
	return (status);
	}

	read = fsread(ino, buf, size);
	if ((size_t)read != size) {
	- printf("Failed to read '%s' (%zd != %zu)\n", loader_path, read,
	+ printf("Failed to read '%s' (%zd != %zu)\n", filepath, read,
	size);
	(void)bs->FreePool(buf);
	return (EFI_INVALID_PARAMETER);
	@@ -134,26 +141,6 @@
	return (EFI_SUCCESS);
	}

	-static EFI_STATUS
	-load(const char loader_path, dev_info_t devinfop, void *buf,
	- size_t *bufsize)
	-{
	- dev_info_t *dev;
	- EFI_STATUS status;
	-
	- for (dev = devices; dev != NULL; dev = dev->next) {
	- status = try_load(dev, loader_path, buf, bufsize);
	- if (status == EFI_SUCCESS) {
	- *devinfop = dev;
	- return (EFI_SUCCESS);
	- } else if (status != EFI_NOT_FOUND) {
	- return (status);
	- }
	- }
	-
	- return (EFI_NOT_FOUND);
	-}
	-
	static void
	status()
	{
	@@ -176,10 +163,18 @@
	}
	}

	+static dev_info_t *
	+get_devices()
	+{
	+
	+ return (devices);
	+}
	+
	const boot_module_t ufs_module =
	{
	.name = "UFS",
	.probe = probe,
	.load = load,
	- .status = status
	+ .status = status,
	+ .devices = get_devices
	};
	Index: sys/boot/efi/boot1/zfs_module.c
	===================================================================
	--- sys/boot/efi/boot1/zfs_module.c
	+++ sys/boot/efi/boot1/zfs_module.c
	@@ -91,7 +91,7 @@
	}

	static EFI_STATUS
	-try_load(dev_info_t devinfo, const char loader_path, void *bufp, size_t bufsize)
	+load(const char filepath, dev_info_t devinfo, void *bufp, size_t bufsize)
	{
	spa_t *spa;
	struct zfsmount zfsmount;
	@@ -102,32 +102,41 @@
	EFI_STATUS status;

	spa = devinfo->devdata;
	- if (zfs_spa_init(spa) != 0) {
	- /* Init failed, don't report this loudly. */
	+
	+ DPRINTF("load: '%s' spa: '%s', devpath: %s\n", filepath, spa->spa_name,
	+ devpath_str(devinfo->devpath));
	+
	+ if ((err = zfs_spa_init(spa)) != 0) {
	+ DPRINTF("Failed to load pool '%s' (%d)\n", spa->spa_name, err);
	return (EFI_NOT_FOUND);
	}

	- if (zfs_mount(spa, 0, &zfsmount) != 0) {
	- /* Mount failed, don't report this loudly. */
	+ if ((err = zfs_mount(spa, 0, &zfsmount)) != 0) {
	+ DPRINTF("Failed to mount pool '%s' (%d)\n", spa->spa_name, err);
	return (EFI_NOT_FOUND);
	}

	- if ((err = zfs_lookup(&zfsmount, loader_path, &dn)) != 0) {
	- printf("Failed to lookup %s on pool %s (%d)\n", loader_path,
	+ if ((err = zfs_lookup(&zfsmount, filepath, &dn)) != 0) {
	+ if (err == ENOENT) {
	+ DPRINTF("Failed to find '%s' on pool '%s' (%d)\n",
	+ filepath, spa->spa_name, err);
	+ return (EFI_NOT_FOUND);
	+ }
	+ printf("Failed to lookup '%s' on pool '%s' (%d)\n", filepath,
	spa->spa_name, err);
	return (EFI_INVALID_PARAMETER);
	}

	if ((err = zfs_dnode_stat(spa, &dn, &st)) != 0) {
	- printf("Failed to lookup %s on pool %s (%d)\n", loader_path,
	+ printf("Failed to stat '%s' on pool '%s' (%d)\n", filepath,
	spa->spa_name, err);
	return (EFI_INVALID_PARAMETER);
	}

	if ((status = bs->AllocatePool(EfiLoaderData, (UINTN)st.st_size, &buf))
	!= EFI_SUCCESS) {
	- printf("Failed to allocate load buffer for pool %s (%lu)\n",
	- spa->spa_name, EFI_ERROR_CODE(status));
	+ printf("Failed to allocate load buffer %zu for pool '%s' for '%s' "
	+ "(%lu)\n", st.st_size, spa->spa_name, filepath, EFI_ERROR_CODE(status));
	return (EFI_INVALID_PARAMETER);
	}

	@@ -144,26 +153,6 @@
	return (EFI_SUCCESS);
	}

	-static EFI_STATUS
	-load(const char loader_path, dev_info_t devinfop, void *bufp,
	- size_t *bufsize)
	-{
	- dev_info_t *devinfo;
	- EFI_STATUS status;
	-
	- for (devinfo = devices; devinfo != NULL; devinfo = devinfo->next) {
	- status = try_load(devinfo, loader_path, bufp, bufsize);
	- if (status == EFI_SUCCESS) {
	- *devinfop = devinfo;
	- return (EFI_SUCCESS);
	- } else if (status != EFI_NOT_FOUND) {
	- return (status);
	- }
	- }
	-
	- return (EFI_NOT_FOUND);
	-}
	-
	static void
	status()
	{
	@@ -189,11 +178,19 @@
	zfs_init();
	}

	+static dev_info_t *
	+get_devices()
	+{
	+
	+ return (devices);
	+}
	+
	const boot_module_t zfs_module =
	{
	.name = "ZFS",
	.init = init,
	.probe = probe,
	.load = load,
	- .status = status
	+ .status = status,
	+ .devices = get_devices
	};
	Index: sys/boot/efi/include/efidevp.h
	===================================================================
	--- sys/boot/efi/include/efidevp.h
	+++ sys/boot/efi/include/efidevp.h
	@@ -40,9 +40,7 @@
	#define EFI_DP_TYPE_MASK 0x7F
	#define EFI_DP_TYPE_UNPACKED 0x80

	-//#define END_DEVICE_PATH_TYPE 0xff
	#define END_DEVICE_PATH_TYPE 0x7f
	-//#define END_DEVICE_PATH_TYPE_UNPACKED 0x7f

	#define END_ENTIRE_DEVICE_PATH_SUBTYPE 0xff
	#define END_INSTANCE_DEVICE_PATH_SUBTYPE 0x01
	@@ -56,8 +54,8 @@
	#define DevicePathSubType(a) ( (a)->SubType )
	#define DevicePathNodeLength(a) ( ((a)->Length[0]) \| ((a)->Length[1] << 8) )
	#define NextDevicePathNode(a) ( (EFI_DEVICE_PATH ) ( ((UINT8 ) (a)) + DevicePathNodeLength(a)))
	-//#define IsDevicePathEndType(a) ( DevicePathType(a) == END_DEVICE_PATH_TYPE_UNPACKED )
	-#define IsDevicePathEndType(a) ( DevicePathType(a) == END_DEVICE_PATH_TYPE )
	+#define IsDevicePathType(a, t) ( DevicePathType(a) == t )
	+#define IsDevicePathEndType(a) IsDevicePathType(a, END_DEVICE_PATH_TYPE)
	#define IsDevicePathEndSubType(a) ( (a)->SubType == END_ENTIRE_DEVICE_PATH_SUBTYPE )
	#define IsDevicePathEnd(a) ( IsDevicePathEndType(a) && IsDevicePathEndSubType(a) )
	#define IsDevicePathUnpacked(a) ( (a)->Type & EFI_DP_TYPE_UNPACKED )

File Metadata

Mime Type: text/plain
Expires: Mon, Feb 9, 12:35 PM (7 h, 29 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 28579758
Default Alt Text: D5108.id12876.diff (19 KB)

D5108.id12876.diffNo OneTemporaryActions

D5108.id12876.diffView Options

File Metadata

Event Timeline

D5108.id12876.diff
No OneTemporary
Actions

D5108.id12876.diff
View Options