2965c7cc2d
A new machine-specific function "grub_machine_set_prefix" is
defined. This is called after loading modules, so that a prefix
initialization can use modules. Also, this change adds an
intensive debugging feature for the memory manager via the
configure option "--enable-mm-debug".
* partmap/gpt.c (gpt_partition_map_iterate): Add one more into
PART.LEN.
* kern/sparc64/ieee1275/init.c (abort): Removed.
(grub_stop): Likewise.
(grub_exit): New function.
(grub_set_prefix): Renamed to ...
(grub_machine_set_prefix): ... this.
(grub_machine_init): Do not call grub_set_prefix.
* kern/powerpc/ieee1275/init.c (grub_set_prefix): Renamed to ...
(grub_machine_set_prefix): ... this.
(grub_machine_init): Do not call grub_set_prefix.
* kern/i386/pc/init.c (grub_machine_set_prefix): New function.
(grub_machine_init): Do not set the prefix here.
* kern/i386/efi/init.c (grub_machine_set_prefix): New function.
* kern/efi/init.c: Include grub/mm.h.
(grub_efi_set_prefix): New function.
* kern/efi/efi.c (grub_exit): Call grub_efi_fini.
(grub_efi_get_filename): New function.
(grub_print_device_path): Renamed to ...
(grub_efi_print_device_path): ... this.
* kern/mm.c [MM_DEBUG] (grub_malloc): Undefined.
[MM_DEBUG] (grub_realloc): Likewise.
[MM_DEBUG] (grub_free): Likewise.
[MM_DEBUG] (grub_memalign): Likewise.
[MM_DEBUG] (grub_mm_debug): New variable.
[MM_DEBUG] (grub_debug_malloc): New function.
[MM_DEBUG] (grub_debug_free): New function.
[MM_DEBUG] (grub_debug_realloc): New function.
[MM_DEBUG] (grub_debug_memalign): New function.
* kern/misc.c (grub_abort): Print a newline to distinguish
the message.
* kern/main.c (grub_main): Call grub_machine_set_prefix and
grub_set_root_dev after loading modules. This is necessary when
setting a prefix depends on modules.
* include/grub/efi/efi.h (grub_print_device_path): Renamed to ...
(grub_efi_print_device_path): ... this.
(grub_efi_get_filename): New prototype.
(grub_efi_set_prefix): Likewise.
* include/grub/efi/disk.h: Include grub/efi/api.h, grub/symbol.h
and grub/disk.h.
(grub_efidisk_get_device_handle): New prototype.
(grub_efidisk_get_device_name): Likewise.
* include/grub/mm.h: Include config.h.
(MM_DEBUG): Removed.
[MM_DEBUG && !GRUB_UTIL] (grub_mm_debug): New prototype.
[MM_DEBUG && !GRUB_UTIL] (grub_malloc): New macro.
[MM_DEBUG && !GRUB_UTIL] (grub_realloc): Likewise.
[MM_DEBUG && !GRUB_UTIL] (grub_memalign): Likewise.
[MM_DEBUG && !GRUB_UTIL] (grub_free): Likewise.
[MM_DEBUG && !GRUB_UTIL] (grub_debug_malloc): New prototype.
[MM_DEBUG && !GRUB_UTIL] (grub_debug_realloc): New prototype.
[MM_DEBUG && !GRUB_UTIL] (grub_debug_memalign): New prototype.
[MM_DEBUG && !GRUB_UTIL] (grub_debug_free): New prototype.
* include/grub/kernel.h (grub_machine_set_prefix): New prototype.
* disk/efi/efidisk.c: Include grub/partition.h.
(iterate_child_devices): New function.
(add_device): First, compare only last device path nodes, so that
devices are sorted by the types.
(grub_efidisk_get_device_handle): New function.
(grub_efidisk_get_device_name): Likewise.
* configure.ac (--enable-mm-debug): New option to enable the
memory manager debugging feature. This makes the binary much
bigger, so is disabled by default.
698 lines
20 KiB
C
698 lines
20 KiB
C
/* efi.c - generic EFI support */
|
|
/*
|
|
* GRUB -- GRand Unified Bootloader
|
|
* Copyright (C) 2006 Free Software Foundation, Inc.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
#include <grub/misc.h>
|
|
#include <grub/efi/api.h>
|
|
#include <grub/efi/efi.h>
|
|
#include <grub/efi/console_control.h>
|
|
#include <grub/efi/pe32.h>
|
|
#include <grub/machine/time.h>
|
|
#include <grub/term.h>
|
|
#include <grub/kernel.h>
|
|
#include <grub/mm.h>
|
|
|
|
/* The handle of GRUB itself. Filled in by the startup code. */
|
|
grub_efi_handle_t grub_efi_image_handle;
|
|
|
|
/* The pointer to a system table. Filled in by the startup code. */
|
|
grub_efi_system_table_t *grub_efi_system_table;
|
|
|
|
static grub_efi_guid_t console_control_guid = GRUB_EFI_CONSOLE_CONTROL_GUID;
|
|
static grub_efi_guid_t loaded_image_guid = GRUB_EFI_LOADED_IMAGE_GUID;
|
|
|
|
void *
|
|
grub_efi_locate_protocol (grub_efi_guid_t *protocol, void *registration)
|
|
{
|
|
void *interface;
|
|
grub_efi_status_t status;
|
|
|
|
status = grub_efi_system_table->boot_services->locate_protocol (protocol,
|
|
registration,
|
|
&interface);
|
|
if (status != GRUB_EFI_SUCCESS)
|
|
return 0;
|
|
|
|
return interface;
|
|
}
|
|
|
|
/* Return the array of handles which meet the requirement. If successful,
|
|
the number of handles is stored in NUM_HANDLES. The array is allocated
|
|
from the heap. */
|
|
grub_efi_handle_t *
|
|
grub_efi_locate_handle (grub_efi_locate_search_type_t search_type,
|
|
grub_efi_guid_t *protocol,
|
|
void *search_key,
|
|
grub_efi_uintn_t *num_handles)
|
|
{
|
|
grub_efi_boot_services_t *b;
|
|
grub_efi_status_t status;
|
|
grub_efi_handle_t *buffer;
|
|
grub_efi_uintn_t buffer_size = 8 * sizeof (grub_efi_handle_t);
|
|
|
|
buffer = grub_malloc (buffer_size);
|
|
if (! buffer)
|
|
return 0;
|
|
|
|
b = grub_efi_system_table->boot_services;
|
|
status = b->locate_handle (search_type, protocol, search_key,
|
|
&buffer_size, buffer);
|
|
if (status == GRUB_EFI_BUFFER_TOO_SMALL)
|
|
{
|
|
grub_free (buffer);
|
|
buffer = grub_malloc (buffer_size);
|
|
if (! buffer)
|
|
return 0;
|
|
|
|
status = b->locate_handle (search_type, protocol, search_key,
|
|
&buffer_size, buffer);
|
|
}
|
|
|
|
if (status != GRUB_EFI_SUCCESS)
|
|
{
|
|
grub_free (buffer);
|
|
return 0;
|
|
}
|
|
|
|
*num_handles = buffer_size / sizeof (grub_efi_handle_t);
|
|
return buffer;
|
|
}
|
|
|
|
void *
|
|
grub_efi_open_protocol (grub_efi_handle_t handle,
|
|
grub_efi_guid_t *protocol,
|
|
grub_efi_uint32_t attributes)
|
|
{
|
|
grub_efi_boot_services_t *b;
|
|
grub_efi_status_t status;
|
|
void *interface;
|
|
|
|
b = grub_efi_system_table->boot_services;
|
|
status = b->open_protocol (handle,
|
|
protocol,
|
|
&interface,
|
|
grub_efi_image_handle,
|
|
0,
|
|
attributes);
|
|
if (status != GRUB_EFI_SUCCESS)
|
|
return 0;
|
|
|
|
return interface;
|
|
}
|
|
|
|
int
|
|
grub_efi_set_text_mode (int on)
|
|
{
|
|
grub_efi_console_control_protocol_t *c;
|
|
grub_efi_screen_mode_t mode, new_mode;
|
|
|
|
c = grub_efi_locate_protocol (&console_control_guid, 0);
|
|
if (! c)
|
|
return 0;
|
|
|
|
if (c->get_mode (c, &mode, 0, 0) != GRUB_EFI_SUCCESS)
|
|
return 0;
|
|
|
|
new_mode = on ? GRUB_EFI_SCREEN_TEXT : GRUB_EFI_SCREEN_GRAPHICS;
|
|
if (mode != new_mode)
|
|
if (c->set_mode (c, new_mode) != GRUB_EFI_SUCCESS)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
void
|
|
grub_efi_stall (grub_efi_uintn_t microseconds)
|
|
{
|
|
grub_efi_system_table->boot_services->stall (microseconds);
|
|
}
|
|
|
|
grub_efi_loaded_image_t *
|
|
grub_efi_get_loaded_image (void)
|
|
{
|
|
return grub_efi_open_protocol (grub_efi_image_handle,
|
|
&loaded_image_guid,
|
|
GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL);
|
|
}
|
|
|
|
void
|
|
grub_exit (void)
|
|
{
|
|
grub_efi_fini ();
|
|
grub_efi_system_table->boot_services->exit (grub_efi_image_handle,
|
|
GRUB_EFI_SUCCESS,
|
|
0, 0);
|
|
}
|
|
|
|
grub_uint32_t
|
|
grub_get_rtc (void)
|
|
{
|
|
grub_efi_time_t time;
|
|
grub_efi_runtime_services_t *r;
|
|
|
|
r = grub_efi_system_table->runtime_services;
|
|
if (r->get_time (&time, 0) != GRUB_EFI_SUCCESS)
|
|
/* What is possible in this case? */
|
|
return 0;
|
|
|
|
return (((time.minute * 60 + time.second) * 1000
|
|
+ time.nanosecond / 1000000)
|
|
* GRUB_TICKS_PER_SECOND / 1000);
|
|
}
|
|
|
|
/* Search the mods section from the PE32/PE32+ image. This code uses
|
|
a PE32 header, but should work with PE32+ as well. */
|
|
grub_addr_t
|
|
grub_arch_modules_addr (void)
|
|
{
|
|
grub_efi_loaded_image_t *image;
|
|
struct grub_pe32_header *header;
|
|
struct grub_pe32_coff_header *coff_header;
|
|
struct grub_pe32_section_table *sections;
|
|
struct grub_pe32_section_table *section;
|
|
struct grub_module_info *info;
|
|
grub_uint16_t i;
|
|
|
|
image = grub_efi_get_loaded_image ();
|
|
if (! image)
|
|
return 0;
|
|
|
|
header = image->image_base;
|
|
coff_header = &(header->coff_header);
|
|
sections
|
|
= (struct grub_pe32_section_table *) ((char *) coff_header
|
|
+ sizeof (*coff_header)
|
|
+ coff_header->optional_header_size);
|
|
|
|
for (i = 0, section = sections;
|
|
i < coff_header->num_sections;
|
|
i++, section++)
|
|
{
|
|
if (grub_strcmp (section->name, "mods") == 0)
|
|
break;
|
|
}
|
|
|
|
if (i == coff_header->num_sections)
|
|
return 0;
|
|
|
|
info = (struct grub_module_info *) ((char *) image->image_base
|
|
+ section->virtual_address);
|
|
if (info->magic != GRUB_MODULE_MAGIC)
|
|
return 0;
|
|
|
|
return (grub_addr_t) info;
|
|
}
|
|
|
|
char *
|
|
grub_efi_get_filename (grub_efi_device_path_t *dp)
|
|
{
|
|
char *name = 0;
|
|
|
|
while (1)
|
|
{
|
|
grub_efi_uint8_t type = GRUB_EFI_DEVICE_PATH_TYPE (dp);
|
|
grub_efi_uint8_t subtype = GRUB_EFI_DEVICE_PATH_SUBTYPE (dp);
|
|
|
|
if (type == GRUB_EFI_END_DEVICE_PATH_TYPE)
|
|
break;
|
|
else if (type == GRUB_EFI_MEDIA_DEVICE_PATH_TYPE
|
|
&& subtype == GRUB_EFI_FILE_PATH_DEVICE_PATH_SUBTYPE)
|
|
{
|
|
grub_efi_file_path_device_path_t *fp;
|
|
grub_efi_uint16_t len;
|
|
char *p;
|
|
grub_size_t size;
|
|
|
|
if (name)
|
|
{
|
|
size = grub_strlen (name);
|
|
name[size] = '/';
|
|
size++;
|
|
}
|
|
else
|
|
size = 0;
|
|
|
|
len = GRUB_EFI_DEVICE_PATH_LENGTH (dp) - 4;
|
|
p = grub_realloc (name, size + len * 4 + 1);
|
|
if (! p)
|
|
{
|
|
grub_free (name);
|
|
return 0;
|
|
}
|
|
|
|
name = p;
|
|
fp = (grub_efi_file_path_device_path_t *) dp;
|
|
*grub_utf16_to_utf8 ((grub_uint8_t *) name + size,
|
|
fp->path_name, len) = '\0';
|
|
}
|
|
|
|
dp = GRUB_EFI_NEXT_DEVICE_PATH (dp);
|
|
}
|
|
|
|
if (name)
|
|
{
|
|
/* EFI breaks paths with backslashes. */
|
|
char *p;
|
|
|
|
for (p = name; *p; p++)
|
|
if (*p == '\\')
|
|
*p = '/';
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
/* Print the chain of Device Path nodes. This is mainly for debugging. */
|
|
void
|
|
grub_efi_print_device_path (grub_efi_device_path_t *dp)
|
|
{
|
|
while (1)
|
|
{
|
|
grub_efi_uint8_t type = GRUB_EFI_DEVICE_PATH_TYPE (dp);
|
|
grub_efi_uint8_t subtype = GRUB_EFI_DEVICE_PATH_SUBTYPE (dp);
|
|
grub_efi_uint16_t len = GRUB_EFI_DEVICE_PATH_LENGTH (dp);
|
|
|
|
switch (type)
|
|
{
|
|
case GRUB_EFI_END_DEVICE_PATH_TYPE:
|
|
switch (subtype)
|
|
{
|
|
case GRUB_EFI_END_ENTIRE_DEVICE_PATH_SUBTYPE:
|
|
/* grub_printf ("/EndEntire\n"); */
|
|
grub_putchar ('\n');
|
|
break;
|
|
case GRUB_EFI_END_THIS_DEVICE_PATH_SUBTYPE:
|
|
/* grub_printf ("/EndThis\n"); */
|
|
grub_putchar ('\n');
|
|
break;
|
|
default:
|
|
grub_printf ("/EndUnknown(%x)\n", (unsigned) subtype);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case GRUB_EFI_HARDWARE_DEVICE_PATH_TYPE:
|
|
switch (subtype)
|
|
{
|
|
case GRUB_EFI_PCI_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_pci_device_path_t pci;
|
|
grub_memcpy (&pci, dp, len);
|
|
grub_printf ("/PCI(%x,%x)",
|
|
(unsigned) pci.function, (unsigned) pci.device);
|
|
}
|
|
break;
|
|
case GRUB_EFI_PCCARD_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_pccard_device_path_t pccard;
|
|
grub_memcpy (&pccard, dp, len);
|
|
grub_printf ("/PCCARD(%x)",
|
|
(unsigned) pccard.function);
|
|
}
|
|
break;
|
|
case GRUB_EFI_MEMORY_MAPPED_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_memory_mapped_device_path_t mmapped;
|
|
grub_memcpy (&mmapped, dp, len);
|
|
grub_printf ("/MMap(%x,%llx,%llx)",
|
|
(unsigned) mmapped.memory_type,
|
|
mmapped.start_address,
|
|
mmapped.end_address);
|
|
}
|
|
break;
|
|
case GRUB_EFI_VENDOR_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_vendor_device_path_t vendor;
|
|
grub_memcpy (&vendor, dp, sizeof (vendor));
|
|
grub_printf ("/Vendor(%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x)",
|
|
(unsigned) vendor.vendor_guid.data1,
|
|
(unsigned) vendor.vendor_guid.data2,
|
|
(unsigned) vendor.vendor_guid.data3,
|
|
(unsigned) vendor.vendor_guid.data4[0],
|
|
(unsigned) vendor.vendor_guid.data4[1],
|
|
(unsigned) vendor.vendor_guid.data4[2],
|
|
(unsigned) vendor.vendor_guid.data4[3],
|
|
(unsigned) vendor.vendor_guid.data4[4],
|
|
(unsigned) vendor.vendor_guid.data4[5],
|
|
(unsigned) vendor.vendor_guid.data4[6],
|
|
(unsigned) vendor.vendor_guid.data4[7]);
|
|
}
|
|
break;
|
|
case GRUB_EFI_CONTROLLER_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_controller_device_path_t controller;
|
|
grub_memcpy (&controller, dp, len);
|
|
grub_printf ("/Ctrl(%x)",
|
|
(unsigned) controller.controller_number);
|
|
}
|
|
break;
|
|
default:
|
|
grub_printf ("/UnknownHW(%x)", (unsigned) subtype);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case GRUB_EFI_ACPI_DEVICE_PATH_TYPE:
|
|
switch (subtype)
|
|
{
|
|
case GRUB_EFI_ACPI_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_acpi_device_path_t acpi;
|
|
grub_memcpy (&acpi, dp, len);
|
|
grub_printf ("/ACPI(%x,%x)",
|
|
(unsigned) acpi.hid,
|
|
(unsigned) acpi.uid);
|
|
}
|
|
break;
|
|
case GRUB_EFI_EXPANDED_ACPI_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_expanded_acpi_device_path_t eacpi;
|
|
grub_memcpy (&eacpi, dp, sizeof (eacpi));
|
|
grub_printf ("/ACPI(");
|
|
|
|
if (GRUB_EFI_EXPANDED_ACPI_HIDSTR (dp)[0] == '\0')
|
|
grub_printf ("%x,", (unsigned) eacpi.hid);
|
|
else
|
|
grub_printf ("%s,", GRUB_EFI_EXPANDED_ACPI_HIDSTR (dp));
|
|
|
|
if (GRUB_EFI_EXPANDED_ACPI_UIDSTR (dp)[0] == '\0')
|
|
grub_printf ("%x,", (unsigned) eacpi.uid);
|
|
else
|
|
grub_printf ("%s,", GRUB_EFI_EXPANDED_ACPI_UIDSTR (dp));
|
|
|
|
if (GRUB_EFI_EXPANDED_ACPI_CIDSTR (dp)[0] == '\0')
|
|
grub_printf ("%x)", (unsigned) eacpi.cid);
|
|
else
|
|
grub_printf ("%s)", GRUB_EFI_EXPANDED_ACPI_CIDSTR (dp));
|
|
}
|
|
break;
|
|
default:
|
|
grub_printf ("/UnknownACPI(%x)", (unsigned) subtype);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case GRUB_EFI_MESSAGING_DEVICE_PATH_TYPE:
|
|
switch (subtype)
|
|
{
|
|
case GRUB_EFI_ATAPI_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_atapi_device_path_t atapi;
|
|
grub_memcpy (&atapi, dp, len);
|
|
grub_printf ("/ATAPI(%x,%x,%x)",
|
|
(unsigned) atapi.primary_secondary,
|
|
(unsigned) atapi.slave_master,
|
|
(unsigned) atapi.lun);
|
|
}
|
|
break;
|
|
case GRUB_EFI_SCSI_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_scsi_device_path_t scsi;
|
|
grub_memcpy (&scsi, dp, len);
|
|
grub_printf ("/SCSI(%x,%x)",
|
|
(unsigned) scsi.pun,
|
|
(unsigned) scsi.lun);
|
|
}
|
|
break;
|
|
case GRUB_EFI_FIBRE_CHANNEL_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_fibre_channel_device_path_t fc;
|
|
grub_memcpy (&fc, dp, len);
|
|
grub_printf ("/FibreChannel(%llx,%llx)",
|
|
fc.wwn, fc.lun);
|
|
}
|
|
break;
|
|
case GRUB_EFI_1394_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_1394_device_path_t firewire;
|
|
grub_memcpy (&firewire, dp, len);
|
|
grub_printf ("/1394(%llx)", firewire.guid);
|
|
}
|
|
break;
|
|
case GRUB_EFI_USB_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_usb_device_path_t usb;
|
|
grub_memcpy (&usb, dp, len);
|
|
grub_printf ("/USB(%x,%x)",
|
|
(unsigned) usb.parent_port_number,
|
|
(unsigned) usb.interface);
|
|
}
|
|
break;
|
|
case GRUB_EFI_USB_CLASS_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_usb_class_device_path_t usb_class;
|
|
grub_memcpy (&usb_class, dp, len);
|
|
grub_printf ("/USBClass(%x,%x,%x,%x,%x)",
|
|
(unsigned) usb_class.vendor_id,
|
|
(unsigned) usb_class.product_id,
|
|
(unsigned) usb_class.device_class,
|
|
(unsigned) usb_class.device_subclass,
|
|
(unsigned) usb_class.device_protocol);
|
|
}
|
|
break;
|
|
case GRUB_EFI_I2O_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_i2o_device_path_t i2o;
|
|
grub_memcpy (&i2o, dp, len);
|
|
grub_printf ("/I2O(%x)", (unsigned) i2o.tid);
|
|
}
|
|
break;
|
|
case GRUB_EFI_MAC_ADDRESS_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_mac_address_device_path_t mac;
|
|
grub_memcpy (&mac, dp, len);
|
|
grub_printf ("/MacAddr(%02x:%02x:%02x:%02x:%02x:%02x,%x)",
|
|
(unsigned) mac.mac_address[0],
|
|
(unsigned) mac.mac_address[1],
|
|
(unsigned) mac.mac_address[2],
|
|
(unsigned) mac.mac_address[3],
|
|
(unsigned) mac.mac_address[4],
|
|
(unsigned) mac.mac_address[5],
|
|
(unsigned) mac.if_type);
|
|
}
|
|
break;
|
|
case GRUB_EFI_IPV4_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_ipv4_device_path_t ipv4;
|
|
grub_memcpy (&ipv4, dp, len);
|
|
grub_printf ("/IPv4(%u.%u.%u.%u,%u.%u.%u.%u,%u,%u,%x,%x)",
|
|
(unsigned) ipv4.local_ip_address[0],
|
|
(unsigned) ipv4.local_ip_address[1],
|
|
(unsigned) ipv4.local_ip_address[2],
|
|
(unsigned) ipv4.local_ip_address[3],
|
|
(unsigned) ipv4.remote_ip_address[0],
|
|
(unsigned) ipv4.remote_ip_address[1],
|
|
(unsigned) ipv4.remote_ip_address[2],
|
|
(unsigned) ipv4.remote_ip_address[3],
|
|
(unsigned) ipv4.local_port,
|
|
(unsigned) ipv4.remote_port,
|
|
(unsigned) ipv4.protocol,
|
|
(unsigned) ipv4.static_ip_address);
|
|
}
|
|
break;
|
|
case GRUB_EFI_IPV6_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_ipv6_device_path_t ipv6;
|
|
grub_memcpy (&ipv6, dp, len);
|
|
grub_printf ("/IPv6(%x:%x:%x:%x:%x:%x:%x:%x,%x:%x:%x:%x:%x:%x:%x:%x,%u,%u,%x,%x)",
|
|
(unsigned) ipv6.local_ip_address[0],
|
|
(unsigned) ipv6.local_ip_address[1],
|
|
(unsigned) ipv6.local_ip_address[2],
|
|
(unsigned) ipv6.local_ip_address[3],
|
|
(unsigned) ipv6.local_ip_address[4],
|
|
(unsigned) ipv6.local_ip_address[5],
|
|
(unsigned) ipv6.local_ip_address[6],
|
|
(unsigned) ipv6.local_ip_address[7],
|
|
(unsigned) ipv6.remote_ip_address[0],
|
|
(unsigned) ipv6.remote_ip_address[1],
|
|
(unsigned) ipv6.remote_ip_address[2],
|
|
(unsigned) ipv6.remote_ip_address[3],
|
|
(unsigned) ipv6.remote_ip_address[4],
|
|
(unsigned) ipv6.remote_ip_address[5],
|
|
(unsigned) ipv6.remote_ip_address[6],
|
|
(unsigned) ipv6.remote_ip_address[7],
|
|
(unsigned) ipv6.local_port,
|
|
(unsigned) ipv6.remote_port,
|
|
(unsigned) ipv6.protocol,
|
|
(unsigned) ipv6.static_ip_address);
|
|
}
|
|
break;
|
|
case GRUB_EFI_INFINIBAND_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_infiniband_device_path_t ib;
|
|
grub_memcpy (&ib, dp, len);
|
|
grub_printf ("/InfiniBand(%x,%llx,%llx,%llx)",
|
|
(unsigned) ib.port_gid[0], /* XXX */
|
|
ib.remote_id,
|
|
ib.target_port_id,
|
|
ib.device_id);
|
|
}
|
|
break;
|
|
case GRUB_EFI_UART_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_uart_device_path_t uart;
|
|
grub_memcpy (&uart, dp, len);
|
|
grub_printf ("/UART(%llu,%u,%x,%x)",
|
|
uart.baud_rate,
|
|
uart.data_bits,
|
|
uart.parity,
|
|
uart.stop_bits);
|
|
}
|
|
break;
|
|
case GRUB_EFI_VENDOR_MESSAGING_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_vendor_messaging_device_path_t vendor;
|
|
grub_memcpy (&vendor, dp, sizeof (vendor));
|
|
grub_printf ("/Vendor(%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x)",
|
|
(unsigned) vendor.vendor_guid.data1,
|
|
(unsigned) vendor.vendor_guid.data2,
|
|
(unsigned) vendor.vendor_guid.data3,
|
|
(unsigned) vendor.vendor_guid.data4[0],
|
|
(unsigned) vendor.vendor_guid.data4[1],
|
|
(unsigned) vendor.vendor_guid.data4[2],
|
|
(unsigned) vendor.vendor_guid.data4[3],
|
|
(unsigned) vendor.vendor_guid.data4[4],
|
|
(unsigned) vendor.vendor_guid.data4[5],
|
|
(unsigned) vendor.vendor_guid.data4[6],
|
|
(unsigned) vendor.vendor_guid.data4[7]);
|
|
}
|
|
break;
|
|
default:
|
|
grub_printf ("/UnknownMessaging(%x)", (unsigned) subtype);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case GRUB_EFI_MEDIA_DEVICE_PATH_TYPE:
|
|
switch (subtype)
|
|
{
|
|
case GRUB_EFI_HARD_DRIVE_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_hard_drive_device_path_t hd;
|
|
grub_memcpy (&hd, dp, len);
|
|
grub_printf ("/HD(%u,%llx,%llx,%02x%02x%02x%02x%02x%02x%02x%02x,%x,%x)",
|
|
hd.partition_number,
|
|
hd.partition_start,
|
|
hd.partition_size,
|
|
(unsigned) hd.partition_signature[0],
|
|
(unsigned) hd.partition_signature[1],
|
|
(unsigned) hd.partition_signature[2],
|
|
(unsigned) hd.partition_signature[3],
|
|
(unsigned) hd.partition_signature[4],
|
|
(unsigned) hd.partition_signature[5],
|
|
(unsigned) hd.partition_signature[6],
|
|
(unsigned) hd.partition_signature[7],
|
|
(unsigned) hd.mbr_type,
|
|
(unsigned) hd.signature_type);
|
|
}
|
|
break;
|
|
case GRUB_EFI_CDROM_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_cdrom_device_path_t cd;
|
|
grub_memcpy (&cd, dp, len);
|
|
grub_printf ("/CD(%u,%llx,%llx)",
|
|
cd.boot_entry,
|
|
cd.partition_start,
|
|
cd.partition_size);
|
|
}
|
|
break;
|
|
case GRUB_EFI_VENDOR_MEDIA_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_vendor_media_device_path_t vendor;
|
|
grub_memcpy (&vendor, dp, sizeof (vendor));
|
|
grub_printf ("/Vendor(%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x)",
|
|
(unsigned) vendor.vendor_guid.data1,
|
|
(unsigned) vendor.vendor_guid.data2,
|
|
(unsigned) vendor.vendor_guid.data3,
|
|
(unsigned) vendor.vendor_guid.data4[0],
|
|
(unsigned) vendor.vendor_guid.data4[1],
|
|
(unsigned) vendor.vendor_guid.data4[2],
|
|
(unsigned) vendor.vendor_guid.data4[3],
|
|
(unsigned) vendor.vendor_guid.data4[4],
|
|
(unsigned) vendor.vendor_guid.data4[5],
|
|
(unsigned) vendor.vendor_guid.data4[6],
|
|
(unsigned) vendor.vendor_guid.data4[7]);
|
|
}
|
|
break;
|
|
case GRUB_EFI_FILE_PATH_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_file_path_device_path_t *fp;
|
|
grub_uint8_t buf[(len - 4) * 4 + 1];
|
|
fp = (grub_efi_file_path_device_path_t *) dp;
|
|
*grub_utf16_to_utf8 (buf, fp->path_name, len - 4) = '\0';
|
|
grub_printf ("/File(%s)", buf);
|
|
}
|
|
break;
|
|
case GRUB_EFI_PROTOCOL_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_protocol_device_path_t proto;
|
|
grub_memcpy (&proto, dp, sizeof (proto));
|
|
grub_printf ("/Protocol(%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x)",
|
|
(unsigned) proto.guid.data1,
|
|
(unsigned) proto.guid.data2,
|
|
(unsigned) proto.guid.data3,
|
|
(unsigned) proto.guid.data4[0],
|
|
(unsigned) proto.guid.data4[1],
|
|
(unsigned) proto.guid.data4[2],
|
|
(unsigned) proto.guid.data4[3],
|
|
(unsigned) proto.guid.data4[4],
|
|
(unsigned) proto.guid.data4[5],
|
|
(unsigned) proto.guid.data4[6],
|
|
(unsigned) proto.guid.data4[7]);
|
|
}
|
|
break;
|
|
default:
|
|
grub_printf ("/UnknownMedia(%x)", (unsigned) subtype);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case GRUB_EFI_BIOS_DEVICE_PATH_TYPE:
|
|
switch (subtype)
|
|
{
|
|
case GRUB_EFI_BIOS_DEVICE_PATH_SUBTYPE:
|
|
{
|
|
grub_efi_bios_device_path_t bios;
|
|
grub_memcpy (&bios, dp, sizeof (bios));
|
|
grub_printf ("/BIOS(%x,%x,%s)",
|
|
(unsigned) bios.device_type,
|
|
(unsigned) bios.status_flags,
|
|
(char *) (dp + 1));
|
|
}
|
|
break;
|
|
default:
|
|
grub_printf ("/UnknownBIOS(%x)", (unsigned) subtype);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
grub_printf ("/UnknownType(%x,%x)\n",
|
|
(unsigned) type,
|
|
(unsigned) subtype);
|
|
return;
|
|
break;
|
|
}
|
|
|
|
if (GRUB_EFI_END_ENTIRE_DEVICE_PATH (dp))
|
|
break;
|
|
|
|
dp = (grub_efi_device_path_t *) ((char *) dp + len);
|
|
}
|
|
}
|