2006-04-23 Yoshinori K. Okuji <okuji@enbug.org>
Use grub_abort instead of grub_stop, and grub_exit must be
define in each architecture now. Also, this change adds support
for EFI disks.
* util/i386/pc/grub-probefs.c: Include grub/term.h.
(grub_getkey): New function.
(grub_term_get_current): Likewise.
* util/i386/pc/grub-setup.c: Include grub/term.h.
(grub_getkey): New function.
(grub_term_get_current): Likewise.
* util/misc.c (grub_stop): Renamed to ...
(grub_exit): ... this.
* kern/powerpc/ieee1275/init.c (abort): Renamed to ...
(grub_exit): ... this.
(grub_machine_init): Use grub_abort instead of abort.
(grub_stop): Removed.
* kern/powerpc/ieee1275/cmain.c (cmain): Use grub_abort instead of
abort.
* kern/i386/pc/startup.S (grub_exit): New function.
(cold_reboot): New label.
* kern/efi/init.c: Include grub/efi/disk.h and grub/env.h.
(grub_efi_init): Call grub_efidisk_init.
(grub_efi_fini): Call grub_efidisk_fini.
* kern/efi/efi.c: Include grub/mm.h.
(grub_efi_console_control_guid): Renamed to ...
(console_control_guid): ... this.
(grub_efi_loaded_image_guid): Renamed to ...
(loaded_image_guid): ... this.
(grub_efi_locate_handle): New function.
(grub_efi_open_protocol): Likewise.
(grub_efi_set_text_mode): Use CONSOLE_CONTROL_GUID instead of
GRUB_EFI_CONSOLE_CONTROL_GUID.
(grub_efi_exit): Removed.
(grub_stop): Likewise.
(grub_efi_get_loaded_image): Use grub_efi_open_protocol.
(grub_exit): New function.
(grub_print_device_path): Likewise.
* kern/rescue.c (grub_rescue_cmd_exit): New function.
(grub_enter_rescue_mode): Register "exit".
* kern/misc.c (grub_real_dprintf): A cosmetic change.
(grub_abort): New function.
* kern/err.c (grub_fatal): Use grub_abort instead of grub_stop.
* include/grub/sparc64/ieee1275/kernel.h (abort): Removed.
* include/grub/powerpc/ieee1275/kernel.h (abort): Removed.
* include/grub/efi/efi.h (grub_efi_exit): Removed.
(grub_print_device_path): New prototype.
(grub_efi_locate_handle): Likewise.
(grub_efi_open_protocol): Likewise.
* include/grub/efi/disk.h (grub_efidisk_fini): New file.
* disk/efi/efidisk.c: Likewise.
* DISTLIST: Added disk/efi/efidisk.c and include/grub/efi/disk.h.
* include/grub/efi/console_control.h
(GRUB_EFI_CONSOLE_CONTROL_GUID): Use an array for the last 8 bytes.
* include/grub/efi/api.h (GRUB_EFI_LOADED_IMAGE_GUID): Specify the
last 8 bytes as an array.
(GRUB_EFI_DISK_IO_GUID): New macro.
(GRUB_EFI_BLOCK_IO_GUID): Likewise.
(GRUB_EFI_DEVICE_PATH_GUID): Likewise.
(grub_efi_ipv6_address_t): Change the type to grub_uint16_t from
grub_uint8_t.
(struct grub_efi_guid): Use an array to specify the last 8 bytes.
(struct grub_efi_device_path): Rename the member "sub_type" to
"subtype".
(GRUB_EFI_DEVICE_PATH_TYPE): New macro.
(GRUB_EFI_DEVICE_PATH_SUBTYPE): Likewise.
(GRUB_EFI_DEVICE_PATH_LENGTH): Likewise.
(GRUB_EFI_END_DEVICE_PATH_TYPE): Likewise.
(GRUB_EFI_END_ENTIRE_DEVICE_PATH_SUBTYPE): Likewise.
(GRUB_EFI_END_THIS_DEVICE_PATH_SUBTYPE): Likewise.
(GRUB_EFI_END_ENTIRE_DEVICE_PATH): Likewise.
(GRUB_EFI_NEXT_DEVICE_PATH): Likewise.
(GRUB_EFI_HARDWARE_DEVICE_PATH_TYPE): Likewise.
(GRUB_EFI_PCI_DEVICE_PATH_SUBTYPE): Likewise.
(struct grub_efi_pci_device_path): New structure.
(grub_efi_pci_device_path_t): New type.
(GRUB_EFI_PCCARD_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_pccard_device_path): New structure.
(grub_efi_pccard_device_path_t): New type.
(GRUB_EFI_MEMORY_MAPPED_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_memory_mapped_device_path): New structure.
(grub_efi_memory_mapped_device_path_t): New type.
(GRUB_EFI_VENDOR_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_vendor_device_path): New structure.
(grub_efi_vendor_device_path_t): New type.
(GRUB_EFI_CONTROLLER_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_controller_device_path): New structure.
(grub_efi_controller_device_path_t): New type.
(GRUB_EFI_ACPI_DEVICE_PATH_TYPE): New macro.
(GRUB_EFI_ACPI_DEVICE_PATH_SUBTYPE): Likewise.
(struct grub_efi_acpi_device_path): New structure.
(grub_efi_acpi_device_path_t): New type.
(GRUB_EFI_EXPANDED_ACPI_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_expanded_acpi_device_path): New structure.
(grub_efi_expanded_acpi_device_path_t): New type.
(GRUB_EFI_EXPANDED_ACPI_HIDSTR): New macro.
(GRUB_EFI_EXPANDED_ACPI_UIDSTR): Likewise.
(GRUB_EFI_EXPANDED_ACPI_CIDSTR): Likewise.
(GRUB_EFI_MESSAGING_DEVICE_PATH_TYPE): Likewise.
(GRUB_EFI_ATAPI_DEVICE_PATH_SUBTYPE): Likewise.
(struct grub_efi_atapi_device_path): New structure.
(grub_efi_atapi_device_path_t): New type.
(GRUB_EFI_FIBRE_CHANNEL_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_fibre_channel_device_path): New structure.
(grub_efi_fibre_channel_device_path_t): New type.
(GRUB_EFI_1394_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_1394_device_path): New structure.
(grub_efi_1394_device_path_t): New type.
(GRUB_EFI_USB_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_usb_device_path): New structure.
(grub_efi_usb_device_path_t): New type.
(GRUB_EFI_USB_CLASS_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_usb_class_device_path): New structure.
(grub_efi_usb_class_device_path_t): New type.
(GRUB_EFI_I2O_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_i2o_device_path): New structure.
(grub_efi_i2o_device_path_t): New type.
(GRUB_EFI_MAC_ADDRESS_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_mac_address_device_path): New structure.
(grub_efi_mac_address_device_path_t): New type.
(GRUB_EFI_IPV4_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_ipv4_device_path): New structure.
(grub_efi_ipv4_device_path_t): New type.
(GRUB_EFI_IPV6_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_ipv6_device_path): New structure.
(grub_efi_ipv6_device_path_t): New type.
(GRUB_EFI_INFINIBAND_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_infiniband_device_path): New structure.
(grub_efi_infiniband_device_path_t): New type.
(GRUB_EFI_UART_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_uart_device_path): New structure.
(grub_efi_uart_device_path_t): New type.
(GRUB_EFI_VENDOR_MESSAGING_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_vendor_messaging_device_path): New structure.
(grub_efi_vendor_messaging_device_path_t): New type.
(GRUB_EFI_MEDIA_DEVICE_PATH_TYPE): New macro.
(GRUB_EFI_HARD_DRIVE_DEVICE_PATH_SUBTYPE): Likewise.
(struct grub_efi_hard_drive_device_path): New structure.
(grub_efi_hard_drive_device_path_t): New type.
(GRUB_EFI_CDROM_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_cdrom_device_path): New structure.
(grub_efi_cdrom_device_path_t): New type.
(GRUB_EFI_VENDOR_MEDIA_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_vendor_media_device_path): New structure.
(grub_efi_vendor_media_device_path_t): New type.
(GRUB_EFI_FILE_PATH_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_file_path_device_path): New structure.
(grub_efi_file_path_device_path_t): New type.
(GRUB_EFI_PROTOCOL_DEVICE_PATH_SUBTYPE): New macro.
(struct grub_efi_protocol_device_path): New structure.
(grub_efi_protocol_device_path_t): New type.
(GRUB_EFI_BIOS_DEVICE_PATH_TYPE): New macro.
(GRUB_EFI_BIOS_DEVICE_PATH_SUBTYPE): Likewise.
(struct grub_efi_bios_device_path): New structure.
(grub_efi_bios_device_path_t): New type.
(struct grub_efi_disk_io): New structure.
(grub_efi_disk_io_t): New type.
(struct grub_efi_block_io_media): New structure.
(grub_efi_block_io_media_t): New type.
(struct grub_efi_block_io): New structure.
(grub_efi_block_io_t): New type.
* include/grub/misc.h (grub_stop): Removed.
(grub_exit): New prototype.
(grub_abort): Likewise.
* include/grub/disk.h (enum grub_disk_dev_id): Added
GRUB_DISK_DEVICE_EFIDISK_ID.
* conf/i386-efi.rmk (kernel_mod_SOURCES): Added
disk/efi/efidisk.c.
(kernel_syms.lst): Remove the target if an error occurs.
This commit is contained in:
okuji
parent
49986a9f99
commit
9cacaa174c
24 changed files with 1853 additions and 85 deletions
603
disk/efi/efidisk.c
Normal file
603
disk/efi/efidisk.c
Normal file
|
|
@ -0,0 +1,603 @@
|
|||
/*
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 2006 Free Software Foundation, Inc.
|
||||
*
|
||||
* GRUB 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 GRUB; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <grub/disk.h>
|
||||
#include <grub/mm.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/err.h>
|
||||
#include <grub/term.h>
|
||||
#include <grub/efi/api.h>
|
||||
#include <grub/efi/efi.h>
|
||||
#include <grub/efi/disk.h>
|
||||
|
||||
struct grub_efidisk_data
|
||||
{
|
||||
grub_efi_handle_t handle;
|
||||
grub_efi_device_path_t *device_path;
|
||||
grub_efi_device_path_t *last_device_path;
|
||||
grub_efi_block_io_t *block_io;
|
||||
grub_efi_disk_io_t *disk_io;
|
||||
struct grub_efidisk_data *next;
|
||||
};
|
||||
|
||||
/* GUIDs. */
|
||||
static grub_efi_guid_t disk_io_guid = GRUB_EFI_DISK_IO_GUID;
|
||||
static grub_efi_guid_t block_io_guid = GRUB_EFI_BLOCK_IO_GUID;
|
||||
static grub_efi_guid_t device_path_guid = GRUB_EFI_DEVICE_PATH_GUID;
|
||||
|
||||
static struct grub_efidisk_data *fd_devices;
|
||||
static struct grub_efidisk_data *hd_devices;
|
||||
static struct grub_efidisk_data *cd_devices;
|
||||
|
||||
/* Duplicate a device path. */
|
||||
static grub_efi_device_path_t *
|
||||
duplicate_device_path (const grub_efi_device_path_t *dp)
|
||||
{
|
||||
grub_efi_device_path_t *p;
|
||||
grub_size_t total_size = 0;
|
||||
|
||||
for (p = (grub_efi_device_path_t *) dp;
|
||||
;
|
||||
p = GRUB_EFI_NEXT_DEVICE_PATH (p))
|
||||
{
|
||||
total_size += GRUB_EFI_DEVICE_PATH_LENGTH (p);
|
||||
if (GRUB_EFI_END_ENTIRE_DEVICE_PATH (p))
|
||||
break;
|
||||
}
|
||||
|
||||
p = grub_malloc (total_size);
|
||||
if (! p)
|
||||
return 0;
|
||||
|
||||
grub_memcpy (p, dp, total_size);
|
||||
return p;
|
||||
}
|
||||
|
||||
/* Return the device path node right before the end node. */
|
||||
static grub_efi_device_path_t *
|
||||
find_last_device_path (const grub_efi_device_path_t *dp)
|
||||
{
|
||||
grub_efi_device_path_t *next, *p;
|
||||
|
||||
if (GRUB_EFI_END_ENTIRE_DEVICE_PATH (dp))
|
||||
return 0;
|
||||
|
||||
for (p = (grub_efi_device_path_t *) dp, next = GRUB_EFI_NEXT_DEVICE_PATH (p);
|
||||
! GRUB_EFI_END_ENTIRE_DEVICE_PATH (next);
|
||||
p = next, next = GRUB_EFI_NEXT_DEVICE_PATH (next))
|
||||
;
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
/* Compare device paths. */
|
||||
static int
|
||||
compare_device_paths (const grub_efi_device_path_t *dp1,
|
||||
const grub_efi_device_path_t *dp2)
|
||||
{
|
||||
if (! dp1 || ! dp2)
|
||||
/* Return non-zero. */
|
||||
return 1;
|
||||
|
||||
while (1)
|
||||
{
|
||||
grub_efi_uint8_t type1, type2;
|
||||
grub_efi_uint8_t subtype1, subtype2;
|
||||
grub_efi_uint16_t len1, len2;
|
||||
int ret;
|
||||
|
||||
type1 = GRUB_EFI_DEVICE_PATH_TYPE (dp1);
|
||||
type2 = GRUB_EFI_DEVICE_PATH_TYPE (dp2);
|
||||
|
||||
if (type1 != type2)
|
||||
return (int) type2 - (int) type1;
|
||||
|
||||
subtype1 = GRUB_EFI_DEVICE_PATH_SUBTYPE (dp1);
|
||||
subtype2 = GRUB_EFI_DEVICE_PATH_SUBTYPE (dp2);
|
||||
|
||||
if (subtype1 != subtype2)
|
||||
return (int) subtype1 - (int) subtype2;
|
||||
|
||||
len1 = GRUB_EFI_DEVICE_PATH_LENGTH (dp1);
|
||||
len2 = GRUB_EFI_DEVICE_PATH_LENGTH (dp2);
|
||||
|
||||
if (len1 != len2)
|
||||
return (int) len1 - (int) len2;
|
||||
|
||||
ret = grub_memcmp (dp1, dp2, len1);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
|
||||
if (GRUB_EFI_END_ENTIRE_DEVICE_PATH (dp1))
|
||||
break;
|
||||
|
||||
dp1 = (grub_efi_device_path_t *) ((char *) dp1 + len1);
|
||||
dp2 = (grub_efi_device_path_t *) ((char *) dp2 + len2);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct grub_efidisk_data *
|
||||
make_devices (void)
|
||||
{
|
||||
grub_efi_uintn_t num_handles;
|
||||
grub_efi_handle_t *handles;
|
||||
grub_efi_handle_t *handle;
|
||||
struct grub_efidisk_data *devices = 0;
|
||||
|
||||
/* Find handles which support the disk io interface. */
|
||||
handles = grub_efi_locate_handle (GRUB_EFI_BY_PROTOCOL, &disk_io_guid,
|
||||
0, &num_handles);
|
||||
if (! handles)
|
||||
return 0;
|
||||
|
||||
/* Make a linked list of devices. */
|
||||
for (handle = handles; num_handles--; handle++)
|
||||
{
|
||||
grub_efi_device_path_t *dp;
|
||||
grub_efi_device_path_t *ldp;
|
||||
struct grub_efidisk_data *d;
|
||||
grub_efi_block_io_t *bio;
|
||||
grub_efi_disk_io_t *dio;
|
||||
|
||||
dp = grub_efi_open_protocol (*handle, &device_path_guid,
|
||||
GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL);
|
||||
if (! dp)
|
||||
continue;
|
||||
|
||||
ldp = find_last_device_path (dp);
|
||||
if (! ldp)
|
||||
/* This is empty. Why? */
|
||||
continue;
|
||||
|
||||
bio = grub_efi_open_protocol (*handle, &block_io_guid,
|
||||
GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL);
|
||||
dio = grub_efi_open_protocol (*handle, &disk_io_guid,
|
||||
GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL);
|
||||
if (! bio || ! dio)
|
||||
/* This should not happen... Why? */
|
||||
continue;
|
||||
|
||||
d = grub_malloc (sizeof (*d));
|
||||
if (! d)
|
||||
{
|
||||
/* Uggh. */
|
||||
grub_free (handles);
|
||||
return 0;
|
||||
}
|
||||
|
||||
d->handle = *handle;
|
||||
d->device_path = dp;
|
||||
d->last_device_path = ldp;
|
||||
d->block_io = bio;
|
||||
d->disk_io = dio;
|
||||
d->next = devices;
|
||||
devices = d;
|
||||
}
|
||||
|
||||
grub_free (handles);
|
||||
|
||||
return devices;
|
||||
}
|
||||
|
||||
/* Find the parent device. */
|
||||
static struct grub_efidisk_data *
|
||||
find_parent_device (struct grub_efidisk_data *devices,
|
||||
struct grub_efidisk_data *d)
|
||||
{
|
||||
grub_efi_device_path_t *dp, *ldp;
|
||||
struct grub_efidisk_data *parent;
|
||||
|
||||
dp = duplicate_device_path (d->device_path);
|
||||
if (! dp)
|
||||
return 0;
|
||||
|
||||
ldp = find_last_device_path (dp);
|
||||
ldp->type = GRUB_EFI_END_DEVICE_PATH_TYPE;
|
||||
ldp->subtype = GRUB_EFI_END_ENTIRE_DEVICE_PATH_SUBTYPE;
|
||||
ldp->length[0] = sizeof (*ldp);
|
||||
ldp->length[1] = 0;
|
||||
|
||||
for (parent = devices; parent; parent = parent->next)
|
||||
{
|
||||
/* Ignore itself. */
|
||||
if (parent == d)
|
||||
continue;
|
||||
|
||||
if (compare_device_paths (parent->device_path, dp) == 0)
|
||||
{
|
||||
/* Found. */
|
||||
if (! parent->last_device_path)
|
||||
parent = 0;
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
grub_free (dp);
|
||||
return parent;
|
||||
}
|
||||
|
||||
/* Add a device into a list of devices in an ascending order. */
|
||||
static void
|
||||
add_device (struct grub_efidisk_data **devices, struct grub_efidisk_data *d)
|
||||
{
|
||||
struct grub_efidisk_data **p;
|
||||
struct grub_efidisk_data *n;
|
||||
|
||||
for (p = devices; *p; p = &((*p)->next))
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = compare_device_paths ((*p)->device_path, d->device_path);
|
||||
if (ret == 0)
|
||||
return;
|
||||
else if (ret > 0)
|
||||
break;
|
||||
}
|
||||
|
||||
n = grub_malloc (sizeof (*n));
|
||||
if (! n)
|
||||
return;
|
||||
|
||||
grub_memcpy (n, d, sizeof (*n));
|
||||
n->next = (*p);
|
||||
(*p) = n;
|
||||
}
|
||||
|
||||
/* Name the devices. */
|
||||
static void
|
||||
name_devices (struct grub_efidisk_data *devices)
|
||||
{
|
||||
struct grub_efidisk_data *d;
|
||||
|
||||
/* First, identify devices by media device paths. */
|
||||
for (d = devices; d; d = d->next)
|
||||
{
|
||||
grub_efi_device_path_t *dp;
|
||||
|
||||
dp = d->last_device_path;
|
||||
if (! dp)
|
||||
continue;
|
||||
|
||||
if (GRUB_EFI_DEVICE_PATH_TYPE (dp) == GRUB_EFI_MEDIA_DEVICE_PATH_TYPE)
|
||||
{
|
||||
int is_hard_drive = 0;
|
||||
|
||||
switch (GRUB_EFI_DEVICE_PATH_SUBTYPE (dp))
|
||||
{
|
||||
case GRUB_EFI_HARD_DRIVE_DEVICE_PATH_SUBTYPE:
|
||||
is_hard_drive = 1;
|
||||
/* Fall through by intention. */
|
||||
case GRUB_EFI_CDROM_DEVICE_PATH_SUBTYPE:
|
||||
{
|
||||
struct grub_efidisk_data *parent;
|
||||
|
||||
parent = find_parent_device (devices, d);
|
||||
if (parent)
|
||||
{
|
||||
if (is_hard_drive)
|
||||
{
|
||||
#if 0
|
||||
grub_printf ("adding a hard drive by a partition: ");
|
||||
grub_print_device_path (parent->device_path);
|
||||
#endif
|
||||
add_device (&hd_devices, parent);
|
||||
}
|
||||
else
|
||||
{
|
||||
#if 0
|
||||
grub_printf ("adding a cdrom by a partition: ");
|
||||
grub_print_device_path (parent->device_path);
|
||||
#endif
|
||||
add_device (&cd_devices, parent);
|
||||
}
|
||||
|
||||
/* Mark the parent as used. */
|
||||
parent->last_device_path = 0;
|
||||
}
|
||||
}
|
||||
/* Mark itself as used. */
|
||||
d->last_device_path = 0;
|
||||
break;
|
||||
|
||||
default:
|
||||
/* For now, ignore the others. */
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Let's see what can be added more. */
|
||||
for (d = devices; d; d = d->next)
|
||||
{
|
||||
grub_efi_device_path_t *dp;
|
||||
grub_efi_block_io_media_t *m;
|
||||
|
||||
dp = d->last_device_path;
|
||||
if (! dp)
|
||||
continue;
|
||||
|
||||
m = d->block_io->media;
|
||||
if (m->logical_partition)
|
||||
{
|
||||
/* Only one partition in a non-media device. Assume that this
|
||||
is a floppy drive. */
|
||||
#if 0
|
||||
grub_printf ("adding a floppy by guessing: ");
|
||||
grub_print_device_path (d->device_path);
|
||||
#endif
|
||||
add_device (&fd_devices, d);
|
||||
}
|
||||
else if (m->read_only && m->block_size > GRUB_DISK_SECTOR_SIZE)
|
||||
{
|
||||
/* This check is too heuristic, but assume that this is a
|
||||
CDROM drive. */
|
||||
#if 0
|
||||
grub_printf ("adding a cdrom by guessing: ");
|
||||
grub_print_device_path (d->device_path);
|
||||
#endif
|
||||
add_device (&cd_devices, d);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* The default is a hard drive. */
|
||||
#if 0
|
||||
grub_printf ("adding a hard drive by guessing: ");
|
||||
grub_print_device_path (d->device_path);
|
||||
#endif
|
||||
add_device (&hd_devices, d);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
free_devices (struct grub_efidisk_data *devices)
|
||||
{
|
||||
struct grub_efidisk_data *p, *q;
|
||||
|
||||
for (p = devices; p; p = q)
|
||||
{
|
||||
q = p->next;
|
||||
grub_free (p);
|
||||
}
|
||||
}
|
||||
|
||||
/* Enumerate all disks to name devices. */
|
||||
static void
|
||||
enumerate_disks (void)
|
||||
{
|
||||
struct grub_efidisk_data *devices;
|
||||
|
||||
devices = make_devices ();
|
||||
if (! devices)
|
||||
return;
|
||||
|
||||
name_devices (devices);
|
||||
free_devices (devices);
|
||||
}
|
||||
|
||||
static int
|
||||
grub_efidisk_iterate (int (*hook) (const char *name))
|
||||
{
|
||||
struct grub_efidisk_data *d;
|
||||
char buf[16];
|
||||
int count;
|
||||
|
||||
for (d = fd_devices, count = 0; d; d = d->next, count++)
|
||||
{
|
||||
grub_sprintf (buf, "fd%d", count);
|
||||
grub_dprintf ("efidisk", "iterating %s\n", buf);
|
||||
if (hook (buf))
|
||||
return 1;
|
||||
}
|
||||
|
||||
for (d = hd_devices, count = 0; d; d = d->next, count++)
|
||||
{
|
||||
grub_sprintf (buf, "hd%d", count);
|
||||
grub_dprintf ("efidisk", "iterating %s\n", buf);
|
||||
if (hook (buf))
|
||||
return 1;
|
||||
}
|
||||
|
||||
for (d = cd_devices, count = 0; d; d = d->next, count++)
|
||||
{
|
||||
grub_sprintf (buf, "cd%d", count);
|
||||
grub_dprintf ("efidisk", "iterating %s\n", buf);
|
||||
if (hook (buf))
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
get_drive_number (const char *name)
|
||||
{
|
||||
unsigned long drive;
|
||||
|
||||
if ((name[0] != 'f' && name[0] != 'h' && name[0] != 'c') || name[1] != 'd')
|
||||
goto fail;
|
||||
|
||||
drive = grub_strtoul (name + 2, 0, 10);
|
||||
if (grub_errno != GRUB_ERR_NONE)
|
||||
goto fail;
|
||||
|
||||
return (int) drive ;
|
||||
|
||||
fail:
|
||||
grub_error (GRUB_ERR_UNKNOWN_DEVICE, "not a efidisk");
|
||||
return -1;
|
||||
}
|
||||
|
||||
static struct grub_efidisk_data *
|
||||
get_device (struct grub_efidisk_data *devices, int num)
|
||||
{
|
||||
struct grub_efidisk_data *d;
|
||||
|
||||
for (d = devices; d && num; d = d->next, num--)
|
||||
;
|
||||
|
||||
if (num == 0)
|
||||
return d;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_efidisk_open (const char *name, struct grub_disk *disk)
|
||||
{
|
||||
int num;
|
||||
struct grub_efidisk_data *d = 0;
|
||||
grub_efi_block_io_media_t *m;
|
||||
|
||||
grub_dprintf ("efidisk", "opening %s\n", name);
|
||||
|
||||
num = get_drive_number (name);
|
||||
if (num < 0)
|
||||
return grub_errno;
|
||||
|
||||
switch (name[0])
|
||||
{
|
||||
case 'f':
|
||||
disk->has_partitions = 0;
|
||||
d = get_device (fd_devices, num);
|
||||
break;
|
||||
case 'c':
|
||||
/* FIXME: a CDROM should have partitions, but not implemented yet. */
|
||||
disk->has_partitions = 0;
|
||||
d = get_device (cd_devices, num);
|
||||
break;
|
||||
case 'h':
|
||||
disk->has_partitions = 1;
|
||||
d = get_device (hd_devices, num);
|
||||
break;
|
||||
default:
|
||||
/* Never reach here. */
|
||||
break;
|
||||
}
|
||||
|
||||
if (! d)
|
||||
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no such device");
|
||||
|
||||
disk->id = ((num << 8) | name[0]);
|
||||
m = d->block_io->media;
|
||||
/* FIXME: Probably it is better to store the block size in the disk,
|
||||
and total sectors should be replaced with total blocks. */
|
||||
grub_dprintf ("efidisk", "m = %p, last block = %llx, block size = %x\n",
|
||||
m, m->last_block, m->block_size);
|
||||
disk->total_sectors = (m->last_block
|
||||
* (m->block_size >> GRUB_DISK_SECTOR_BITS));
|
||||
disk->data = d;
|
||||
|
||||
grub_dprintf ("efidisk", "opening %s succeeded\n", name);
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static void
|
||||
grub_efidisk_close (struct grub_disk *disk __attribute__ ((unused)))
|
||||
{
|
||||
/* EFI disks do not allocate extra memory, so nothing to do here. */
|
||||
grub_dprintf ("efidisk", "closing %s", disk->name);
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_efidisk_read (struct grub_disk *disk, unsigned long sector,
|
||||
unsigned long size, char *buf)
|
||||
{
|
||||
/* For now, use the disk io interface rather than the block io's. */
|
||||
struct grub_efidisk_data *d;
|
||||
grub_efi_disk_io_t *dio;
|
||||
grub_efi_block_io_t *bio;
|
||||
grub_efi_status_t status;
|
||||
|
||||
d = disk->data;
|
||||
dio = d->disk_io;
|
||||
bio = d->block_io;
|
||||
|
||||
grub_dprintf ("efidisk", "reading 0x%lx sectors at the sector 0x%lx from %s\n",
|
||||
size, sector, disk->name);
|
||||
|
||||
status = dio->read (dio, bio->media->media_id,
|
||||
(grub_efi_uint64_t) sector << GRUB_DISK_SECTOR_BITS,
|
||||
(grub_efi_uintn_t) size << GRUB_DISK_SECTOR_BITS,
|
||||
buf);
|
||||
if (status != GRUB_EFI_SUCCESS)
|
||||
return grub_error (GRUB_ERR_READ_ERROR, "efidisk read error");
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_efidisk_write (struct grub_disk *disk, unsigned long sector,
|
||||
unsigned long size, const char *buf)
|
||||
{
|
||||
/* For now, use the disk io interface rather than the block io's. */
|
||||
struct grub_efidisk_data *d;
|
||||
grub_efi_disk_io_t *dio;
|
||||
grub_efi_block_io_t *bio;
|
||||
grub_efi_status_t status;
|
||||
|
||||
d = disk->data;
|
||||
dio = d->disk_io;
|
||||
bio = d->block_io;
|
||||
|
||||
grub_dprintf ("efidisk", "writing 0x%lx sectors at the sector 0x%lx to %s\n",
|
||||
size, sector, disk->name);
|
||||
|
||||
status = dio->write (dio, bio->media->media_id,
|
||||
(grub_efi_uint64_t) sector << GRUB_DISK_SECTOR_BITS,
|
||||
(grub_efi_uintn_t) size << GRUB_DISK_SECTOR_BITS,
|
||||
(void *) buf);
|
||||
if (status != GRUB_EFI_SUCCESS)
|
||||
return grub_error (GRUB_ERR_WRITE_ERROR, "efidisk write error");
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static struct grub_disk_dev grub_efidisk_dev =
|
||||
{
|
||||
.name = "efidisk",
|
||||
.id = GRUB_DISK_DEVICE_EFIDISK_ID,
|
||||
.iterate = grub_efidisk_iterate,
|
||||
.open = grub_efidisk_open,
|
||||
.close = grub_efidisk_close,
|
||||
.read = grub_efidisk_read,
|
||||
.write = grub_efidisk_write,
|
||||
.next = 0
|
||||
};
|
||||
|
||||
void
|
||||
grub_efidisk_init (void)
|
||||
{
|
||||
enumerate_disks ();
|
||||
grub_disk_dev_register (&grub_efidisk_dev);
|
||||
}
|
||||
|
||||
void
|
||||
grub_efidisk_fini (void)
|
||||
{
|
||||
free_devices (fd_devices);
|
||||
free_devices (hd_devices);
|
||||
free_devices (cd_devices);
|
||||
grub_disk_dev_unregister (&grub_efidisk_dev);
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue