vbatts/grub
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
grub/grub-core/disk/ieee1275/obdisk.c
Vladimir Serbinenko f762850a1c Rename grub_disk members 
Otherwise it horribly clashes with gnulib when it's
replacing open/write/read/close

Signed-off-by: Vladimir Serbinenko <phcoder@google.com>
2020-09-21 19:37:19 -04:00

1076 lines
24 KiB
C
Raw Blame History

/* obdisk.c - Open Boot disk access. */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2019 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 3 of the License, or
* (at your option) any later version.
*
* GRUB 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, see <http://www.gnu.org/licenses/>.
*/
#include <grub/disk.h>
#include <grub/env.h>
#include <grub/i18n.h>
#include <grub/kernel.h>
#include <grub/list.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/scsicmd.h>
#include <grub/time.h>
#include <grub/ieee1275/ieee1275.h>
#include <grub/ieee1275/obdisk.h>
#define IEEE1275_DEV "ieee1275/"
#define IEEE1275_DISK_ALIAS "/disk@"
struct disk_dev
{
struct disk_dev *next;
struct disk_dev **prev;
char *name;
char *raw_name;
char *grub_devpath;
char *grub_alias_devpath;
grub_ieee1275_ihandle_t ihandle;
grub_uint32_t block_size;
grub_uint64_t num_blocks;
unsigned int log_sector_size;
grub_uint32_t opened;
grub_uint32_t valid;
grub_uint32_t boot_dev;
};
struct parent_dev
{
struct parent_dev *next;
struct parent_dev **prev;
char *name;
char *type;
grub_ieee1275_ihandle_t ihandle;
grub_uint32_t address_cells;
};
static struct grub_scsi_test_unit_ready tur =
{
.opcode = grub_scsi_cmd_test_unit_ready,
.lun = 0,
.reserved1 = 0,
.reserved2 = 0,
.reserved3 = 0,
.control = 0,
};
static int disks_enumerated;
static struct disk_dev *disk_devs;
static struct parent_dev *parent_devs;
static const char *block_blacklist[] = {
/* Requires additional work in grub before being able to be used. */
"/iscsi-hba",
/* This block device should never be used by grub. */
"/reboot-memory@0",
0
};
#define STRCMP(a, b) ((a) && (b) && (grub_strcmp (a, b) == 0))
static char *
strip_ob_partition (char *path)
{
char *sptr;
sptr = grub_strstr (path, ":");
if (sptr != NULL)
*sptr = '\0';
return path;
}
static void
escape_commas (const char *src, char *dest)
{
const char *iptr;
for (iptr = src; *iptr; )
{
if (*iptr == ',')
*dest++ ='\\';
*dest++ = *iptr++;
}
*dest = '\0';
}
static int
count_commas (const char *src)
{
int count = 0;
for ( ; *src; src++)
if (*src == ',')
count++;
return count;
}
static char *
decode_grub_devname (const char *name)
{
char *devpath = grub_malloc (grub_strlen (name) + 1);
char *p, c;
if (devpath == NULL)
return NULL;
/* Un-escape commas. */
p = devpath;
while ((c = *name++) != '\0')
{
if (c == '\\' && *name == ',')
{
*p++ = ',';
name++;
}
else
*p++ = c;
}
*p++ = '\0';
return devpath;
}
static char *
encode_grub_devname (const char *path)
{
char *encoding, *optr;
if (path == NULL)
return NULL;
encoding = grub_malloc (sizeof (IEEE1275_DEV) + count_commas (path) +
grub_strlen (path) + 1);
if (encoding == NULL)
{
grub_print_error ();
return NULL;
}
optr = grub_stpcpy (encoding, IEEE1275_DEV);
escape_commas (path, optr);
return encoding;
}
static char *
get_parent_devname (const char *devname)
{
char *parent, *pptr;
parent = grub_strdup (devname);
if (parent == NULL)
{
grub_print_error ();
return NULL;
}
pptr = grub_strstr (parent, IEEE1275_DISK_ALIAS);
if (pptr != NULL)
*pptr = '\0';
return parent;
}
static void
free_parent_dev (struct parent_dev *parent)
{
if (parent != NULL)
{
grub_free (parent->name);
grub_free (parent->type);
grub_free (parent);
}
}
static struct parent_dev *
init_parent (const char *parent)
{
struct parent_dev *op;
op = grub_zalloc (sizeof (struct parent_dev));
if (op == NULL)
{
grub_print_error ();
return NULL;
}
op->name = grub_strdup (parent);
op->type = grub_malloc (IEEE1275_MAX_PROP_LEN);
if ((op->name == NULL) || (op->type == NULL))
{
grub_print_error ();
free_parent_dev (op);
return NULL;
}
return op;
}
static struct parent_dev *
open_new_parent (const char *parent)
{
struct parent_dev *op = init_parent(parent);
grub_ieee1275_ihandle_t ihandle;
grub_ieee1275_phandle_t phandle;
grub_uint32_t address_cells = 2;
if (op == NULL)
return NULL;
grub_ieee1275_open (parent, &ihandle);
if (ihandle == 0)
{
grub_error (GRUB_ERR_BAD_DEVICE, "unable to open %s", parent);
grub_print_error ();
free_parent_dev (op);
return NULL;
}
if (grub_ieee1275_instance_to_package (ihandle, &phandle))
{
grub_error (GRUB_ERR_BAD_DEVICE, "unable to get parent %s", parent);
grub_print_error ();
free_parent_dev (op);
return NULL;
}
/*
* IEEE Std 1275-1994 page 110: A missing "address-cells" property
* signifies that the number of address cells is two. So ignore on error.
*/
if (grub_ieee1275_get_integer_property (phandle, "#address-cells",
&address_cells,
sizeof (address_cells), 0) != 0)
address_cells = 2;
grub_ieee1275_get_property (phandle, "device_type", op->type,
IEEE1275_MAX_PROP_LEN, NULL);
op->ihandle = ihandle;
op->address_cells = address_cells;
return op;
}
static struct parent_dev *
open_parent (const char *parent)
{
struct parent_dev *op;
op = grub_named_list_find (GRUB_AS_NAMED_LIST (parent_devs), parent);
if (op == NULL)
{
op = open_new_parent (parent);
if (op != NULL)
grub_list_push (GRUB_AS_LIST_P (&parent_devs), GRUB_AS_LIST (op));
}
return op;
}
static void
display_parents (void)
{
struct parent_dev *parent;
grub_printf ("-------------------- PARENTS --------------------\n");
FOR_LIST_ELEMENTS (parent, parent_devs)
{
grub_printf ("name: %s\n", parent->name);
grub_printf ("type: %s\n", parent->type);
grub_printf ("address_cells %x\n", parent->address_cells);
}
grub_printf ("-------------------------------------------------\n");
}
static char *
canonicalise_4cell_ua (grub_ieee1275_ihandle_t ihandle, char *unit_address)
{
grub_uint32_t phy_lo, phy_hi, lun_lo, lun_hi;
int valid_phy = 0;
grub_size_t size;
char *canon = NULL;
valid_phy = grub_ieee1275_decode_unit4 (ihandle, unit_address,
grub_strlen (unit_address), &phy_lo,
&phy_hi, &lun_lo, &lun_hi);
if ((valid_phy == 0) && (phy_hi != 0xffffffff))
canon = grub_ieee1275_encode_uint4 (ihandle, phy_lo, phy_hi,
lun_lo, lun_hi, &size);
return canon;
}
static char *
canonicalise_disk (const char *devname)
{
char *canon, *parent;
struct parent_dev *op;
canon = grub_ieee1275_canonicalise_devname (devname);
if (canon == NULL)
{
/* This should not happen. */
grub_error (GRUB_ERR_BAD_DEVICE, "canonicalise devname failed");
grub_print_error ();
return NULL;
}
/* Don't try to open the parent of a virtual device. */
if (grub_strstr (canon, "virtual-devices"))
return canon;
parent = get_parent_devname (canon);
if (parent == NULL)
return NULL;
op = open_parent (parent);
/*
* Devices with 4 address cells can have many different types of addressing
* (phy, wwn, and target lun). Use the parents encode-unit / decode-unit
* to find the true canonical name.
*/
if ((op) && (op->address_cells == 4))
{
char *unit_address, *real_unit_address, *real_canon;
grub_size_t real_unit_str_len;
unit_address = grub_strstr (canon, IEEE1275_DISK_ALIAS);
unit_address += grub_strlen (IEEE1275_DISK_ALIAS);
if (unit_address == NULL)
{
/*
* This should not be possible, but return the canonical name for
* the non-disk block device.
*/
grub_free (parent);
return (canon);
}
real_unit_address = canonicalise_4cell_ua (op->ihandle, unit_address);
if (real_unit_address == NULL)
{
/*
* This is not an error, since this function could be called with a devalias
* containing a drive that isn't installed in the system.
*/
grub_free (parent);
return NULL;
}
real_unit_str_len = grub_strlen (op->name) + sizeof (IEEE1275_DISK_ALIAS)
+ grub_strlen (real_unit_address);
real_canon = grub_malloc (real_unit_str_len);
grub_snprintf (real_canon, real_unit_str_len, "%s/disk@%s",
op->name, real_unit_address);
grub_free (canon);
canon = real_canon;
}
grub_free (parent);
return (canon);
}
static struct disk_dev *
add_canon_disk (const char *cname)
{
struct disk_dev *dev;
dev = grub_zalloc (sizeof (struct disk_dev));
if (dev == NULL)
goto failed;
if (grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_RAW_DEVNAMES))
{
/*
* Append :nolabel to the end of all SPARC disks.
* nolabel is mutually exclusive with all other
* arguments and allows a client program to open
* the entire (raw) disk. Any disk label is ignored.
*/
dev->raw_name = grub_malloc (grub_strlen (cname) + sizeof (":nolabel"));
if (dev->raw_name == NULL)
goto failed;
grub_snprintf (dev->raw_name, grub_strlen (cname) + sizeof (":nolabel"),
"%s:nolabel", cname);
}
/*
* Don't use grub_ieee1275_encode_devname here, the devpath in grub.cfg doesn't
* understand device aliases, which the layer above sometimes sends us.
*/
dev->grub_devpath = encode_grub_devname(cname);
if (dev->grub_devpath == NULL)
goto failed;
dev->name = grub_strdup (cname);
if (dev->name == NULL)
goto failed;
dev->valid = 1;
grub_list_push (GRUB_AS_LIST_P (&disk_devs), GRUB_AS_LIST (dev));
return dev;
failed:
grub_print_error ();
if (dev != NULL)
{
grub_free (dev->name);
grub_free (dev->grub_devpath);
grub_free (dev->raw_name);
}
grub_free (dev);
return NULL;
}
static grub_err_t
add_disk (const char *path)
{
grub_err_t ret = GRUB_ERR_NONE;
struct disk_dev *dev;
char *canon;
canon = canonicalise_disk (path);
dev = grub_named_list_find (GRUB_AS_NAMED_LIST (disk_devs), canon);
if ((canon != NULL) && (dev == NULL))
{
struct disk_dev *ob_device;
ob_device = add_canon_disk (canon);
if (ob_device == NULL)
ret = grub_error (GRUB_ERR_OUT_OF_MEMORY, "failure to add disk");
}
else if (dev != NULL)
dev->valid = 1;
grub_free (canon);
return (ret);
}
static grub_err_t
grub_obdisk_read (grub_disk_t disk, grub_disk_addr_t sector,
grub_size_t size, char *dest)
{
grub_err_t ret = GRUB_ERR_NONE;
struct disk_dev *dev;
unsigned long long pos;
grub_ssize_t result = 0;
if (disk->data == NULL)
return grub_error (GRUB_ERR_BAD_DEVICE, "invalid disk data");
dev = (struct disk_dev *)disk->data;
pos = sector << disk->log_sector_size;
grub_ieee1275_seek (dev->ihandle, pos, &result);
if (result < 0)
{
dev->opened = 0;
return grub_error (GRUB_ERR_READ_ERROR, "seek error, can't seek block %llu",
(long long) sector);
}
grub_ieee1275_read (dev->ihandle, dest, size << disk->log_sector_size,
&result);
if (result != (grub_ssize_t) (size << disk->log_sector_size))
{
dev->opened = 0;
return grub_error (GRUB_ERR_READ_ERROR, N_("failure reading sector 0x%llx "
"from `%s'"),
(unsigned long long) sector,
disk->name);
}
return ret;
}
static void
grub_obdisk_close (grub_disk_t disk)
{
grub_memset (disk, 0, sizeof (*disk));
}
static void
scan_usb_disk (const char *parent)
{
struct parent_dev *op;
grub_ssize_t result;
op = open_parent (parent);
if (op == NULL)
{
grub_error (GRUB_ERR_BAD_DEVICE, "unable to open %s", parent);
grub_print_error ();
return;
}
if ((grub_ieee1275_set_address (op->ihandle, 0, 0) == 0) &&
(grub_ieee1275_no_data_command (op->ihandle, &tur, &result) == 0) &&
(result == 0))
{
char *buf;
buf = grub_malloc (IEEE1275_MAX_PATH_LEN);
if (buf == NULL)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY, "disk scan failure");
grub_print_error ();
return;
}
grub_snprintf (buf, IEEE1275_MAX_PATH_LEN, "%s/disk@0", parent);
add_disk (buf);
grub_free (buf);
}
}
static void
scan_nvme_disk (const char *path)
{
char *buf;
buf = grub_malloc (IEEE1275_MAX_PATH_LEN);
if (buf == NULL)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY, "disk scan failure");
grub_print_error ();
return;
}
grub_snprintf (buf, IEEE1275_MAX_PATH_LEN, "%s/disk@1", path);
add_disk (buf);
grub_free (buf);
}
static void
scan_sparc_sas_2cell (struct parent_dev *op)
{
grub_ssize_t result;
grub_uint8_t tgt;
char *buf;
buf = grub_malloc (IEEE1275_MAX_PATH_LEN);
if (buf == NULL)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY, "disk scan failure");
grub_print_error ();
return;
}
for (tgt = 0; tgt < 0xf; tgt++)
{
if ((grub_ieee1275_set_address(op->ihandle, tgt, 0) == 0) &&
(grub_ieee1275_no_data_command (op->ihandle, &tur, &result) == 0) &&
(result == 0))
{
grub_snprintf (buf, IEEE1275_MAX_PATH_LEN, "%s/disk@%"
PRIxGRUB_UINT32_T, op->name, tgt);
add_disk (buf);
}
}
}
static void
scan_sparc_sas_4cell (struct parent_dev *op)
{
grub_uint16_t exp;
grub_uint8_t phy;
char *buf;
buf = grub_malloc (IEEE1275_MAX_PATH_LEN);
if (buf == NULL)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY, "disk scan failure");
grub_print_error ();
return;
}
/*
* Cycle thru the potential for dual ported SAS disks
* behind a SAS expander.
*/
for (exp = 0; exp <= 0x100; exp+=0x100)
/* The current limit is 32 disks on a phy. */
for (phy = 0; phy < 0x20; phy++)
{
char *canon = NULL;
grub_snprintf (buf, IEEE1275_MAX_PATH_LEN, "p%" PRIxGRUB_UINT32_T ",0",
exp | phy);
canon = canonicalise_4cell_ua (op->ihandle, buf);
if (canon != NULL)
{
grub_snprintf (buf, IEEE1275_MAX_PATH_LEN, "%s/disk@%s",
op->name, canon);
add_disk (buf);
grub_free (canon);
}
}
grub_free (buf);
}
static void
scan_sparc_sas_disk (const char *parent)
{
struct parent_dev *op;
op = open_parent (parent);
if ((op != NULL) && (op->address_cells == 4))
scan_sparc_sas_4cell (op);
else if ((op != NULL) && (op->address_cells == 2))
scan_sparc_sas_2cell (op);
}
static void
iterate_devtree (const struct grub_ieee1275_devalias *alias)
{
struct grub_ieee1275_devalias child;
if ((grub_strcmp (alias->type, "scsi-2") == 0) ||
(grub_strcmp (alias->type, "scsi-sas") == 0))
return scan_sparc_sas_disk (alias->path);
else if (grub_strcmp (alias->type, "nvme") == 0)
return scan_nvme_disk (alias->path);
else if (grub_strcmp (alias->type, "scsi-usb") == 0)
return scan_usb_disk (alias->path);
else if (grub_strcmp (alias->type, "block") == 0)
{
const char **bl = block_blacklist;
while (*bl != NULL)
{
if (grub_strstr (alias->path, *bl))
return;
bl++;
}
add_disk (alias->path);
return;
}
FOR_IEEE1275_DEVCHILDREN (alias->path, child)
iterate_devtree (&child);
}
static void
enumerate_disks (void)
{
struct grub_ieee1275_devalias alias;
FOR_IEEE1275_DEVCHILDREN("/", alias)
iterate_devtree (&alias);
}
static grub_err_t
add_bootpath (void)
{
struct disk_dev *ob_device;
grub_err_t ret = GRUB_ERR_NONE;
char *dev, *alias;
char *type;
dev = grub_ieee1275_get_boot_dev ();
if (dev == NULL)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "failure adding boot device");
type = grub_ieee1275_get_device_type (dev);
if (type == NULL)
{
grub_free (dev);
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "failure adding boot device");
}
alias = NULL;
if (grub_strcmp (type, "network") != 0)
{
dev = strip_ob_partition (dev);
ob_device = add_canon_disk (dev);
if (ob_device == NULL)
ret = grub_error (GRUB_ERR_OUT_OF_MEMORY, "failure adding boot device");
ob_device->valid = 1;
alias = grub_ieee1275_get_devname (dev);
if (alias && grub_strcmp (alias, dev) != 0)
ob_device->grub_alias_devpath = grub_ieee1275_encode_devname (dev);
ob_device->boot_dev = 1;
}
grub_free (type);
grub_free (dev);
grub_free (alias);
return ret;
}
static void
enumerate_aliases (void)
{
struct grub_ieee1275_devalias alias;
/*
* Some block device aliases are not in canonical form
*
* For example:
*
* disk3 /pci@301/pci@1/scsi@0/disk@p3
* disk2 /pci@301/pci@1/scsi@0/disk@p2
* disk1 /pci@301/pci@1/scsi@0/disk@p1
* disk /pci@301/pci@1/scsi@0/disk@p0
* disk0 /pci@301/pci@1/scsi@0/disk@p0
*
* None of these devices are in canonical form.
*
* Also, just because there is a devalias, doesn't mean there is a disk
* at that location. And a valid boot block device doesn't have to have
* a devalias at all.
*
* At this point, all valid disks have been found in the system
* and devaliases that point to canonical names are stored in the
* disk_devs list already.
*/
FOR_IEEE1275_DEVALIASES (alias)
{
struct disk_dev *dev;
char *canon;
if (grub_strcmp (alias.type, "block") != 0)
continue;
canon = canonicalise_disk (alias.name);
if (canon == NULL)
/* This is not an error, a devalias could point to a nonexistent disk. */
continue;
dev = grub_named_list_find (GRUB_AS_NAMED_LIST (disk_devs), canon);
if (dev != NULL)
{
/*
* If more than one alias points to the same device,
* remove the previous one unless it is the boot dev,
* since the upper level will use the first one. The reason
* all the others are redone is in the case of hot-plugging
* a disk. If the boot disk gets hot-plugged, it will come
* thru here with a different name without the boot_dev flag
* set.
*/
if ((dev->boot_dev) && (dev->grub_alias_devpath))
continue;
grub_free (dev->grub_alias_devpath);
dev->grub_alias_devpath = grub_ieee1275_encode_devname (alias.path);
}
grub_free (canon);
}
}
static void
display_disks (void)
{
struct disk_dev *dev;
grub_printf ("--------------------- DISKS ---------------------\n");
FOR_LIST_ELEMENTS (dev, disk_devs)
{
grub_printf ("name: %s\n", dev->name);
grub_printf ("grub_devpath: %s\n", dev->grub_devpath);
grub_printf ("grub_alias_devpath: %s\n", dev->grub_alias_devpath);
grub_printf ("valid: %s\n", (dev->valid) ? "yes" : "no");
grub_printf ("boot_dev: %s\n", (dev->boot_dev) ? "yes" : "no");
grub_printf ("opened: %s\n", (dev->ihandle) ? "yes" : "no");
grub_printf ("block size: %" PRIuGRUB_UINT32_T "\n",
dev->block_size);
grub_printf ("num blocks: %" PRIuGRUB_UINT64_T "\n",
dev->num_blocks);
grub_printf ("log sector size: %" PRIuGRUB_UINT32_T "\n",
dev->log_sector_size);
grub_printf ("\n");
}
grub_printf ("-------------------------------------------------\n");
}
static void
display_stats (void)
{
const char *debug = grub_env_get ("debug");
if (debug == NULL)
return;
if (grub_strword (debug, "all") || grub_strword (debug, "obdisk"))
{
display_parents ();
display_disks ();
}
}
static void
invalidate_all_disks (void)
{
struct disk_dev *dev = NULL;
if (disks_enumerated != 0)
FOR_LIST_ELEMENTS (dev, disk_devs)
dev->valid = 0;
}
static struct disk_dev *
find_legacy_grub_devpath (const char *name)
{
struct disk_dev *dev = NULL;
char *canon, *devpath = NULL;
devpath = decode_grub_devname (name + sizeof ("ieee1275"));
canon = canonicalise_disk (devpath);
if (canon != NULL)
dev = grub_named_list_find (GRUB_AS_NAMED_LIST (disk_devs), canon);
grub_free (devpath);
grub_free (canon);
return dev;
}
static void
enumerate_devices (void)
{
invalidate_all_disks ();
enumerate_disks ();
enumerate_aliases ();
disks_enumerated = 1;
display_stats ();
}
static struct disk_dev *
find_grub_devpath_real (const char *name)
{
struct disk_dev *dev = NULL;
FOR_LIST_ELEMENTS (dev, disk_devs)
{
if ((STRCMP (dev->grub_devpath, name))
|| (STRCMP (dev->grub_alias_devpath, name)))
break;
}
return dev;
}
static struct disk_dev *
find_grub_devpath (const char *name)
{
struct disk_dev *dev = NULL;
int enumerated;
do {
enumerated = disks_enumerated;
dev = find_grub_devpath_real (name);
if (dev != NULL)
break;
dev = find_legacy_grub_devpath (name);
if (dev != NULL)
break;
enumerate_devices ();
} while (enumerated == 0);
return dev;
}
static int
grub_obdisk_iterate (grub_disk_dev_iterate_hook_t hook, void *hook_data,
grub_disk_pull_t pull)
{
struct disk_dev *dev;
const char *name;
if (pull != GRUB_DISK_PULL_NONE)
return 0;
enumerate_devices ();
FOR_LIST_ELEMENTS (dev, disk_devs)
{
if (dev->valid == 1)
{
if (dev->grub_alias_devpath)
name = dev->grub_alias_devpath;
else
name = dev->grub_devpath;
if (hook (name, hook_data))
return 1;
}
}
return 0;
}
static grub_err_t
grub_obdisk_open (const char *name, grub_disk_t disk)
{
grub_ieee1275_ihandle_t ihandle = 0;
struct disk_dev *dev = NULL;
if (grub_strncmp (name, IEEE1275_DEV, sizeof (IEEE1275_DEV) - 1) != 0)
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "not IEEE1275 device");
dev = find_grub_devpath (name);
if (dev == NULL)
{
grub_printf ("UNKNOWN DEVICE: %s\n", name);
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "%s", name);
}
if (dev->opened == 0)
{
if (dev->raw_name != NULL)
grub_ieee1275_open (dev->raw_name, &ihandle);
else
grub_ieee1275_open (dev->name, &ihandle);
if (ihandle == 0)
{
grub_printf ("Can't open device %s\n", name);
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "can't open device %s", name);
}
dev->block_size = grub_ieee1275_get_block_size (ihandle);
dev->num_blocks = grub_ieee1275_num_blocks (ihandle);
if (dev->num_blocks == 0)
dev->num_blocks = grub_ieee1275_num_blocks64 (ihandle);
if (dev->num_blocks == 0)
dev->num_blocks = GRUB_DISK_SIZE_UNKNOWN;
if (dev->block_size != 0)
{
for (dev->log_sector_size = 0;
(1U << dev->log_sector_size) < dev->block_size;
dev->log_sector_size++);
}
else
dev->log_sector_size = 9;
dev->ihandle = ihandle;
dev->opened = 1;
}
disk->total_sectors = dev->num_blocks;
disk->id = dev->ihandle;
disk->data = dev;
disk->log_sector_size = dev->log_sector_size;
return GRUB_ERR_NONE;
}
static struct grub_disk_dev grub_obdisk_dev =
{
.name = "obdisk",
.id = GRUB_DISK_DEVICE_OBDISK_ID,
.disk_iterate = grub_obdisk_iterate,
.disk_open = grub_obdisk_open,
.disk_close = grub_obdisk_close,
.disk_read = grub_obdisk_read,
};
void
grub_obdisk_init (void)
{
grub_disk_firmware_fini = grub_obdisk_fini;
add_bootpath ();
grub_disk_dev_register (&grub_obdisk_dev);
}
void
grub_obdisk_fini (void)
{
struct disk_dev *dev;
FOR_LIST_ELEMENTS (dev, disk_devs)
{
if (dev->opened != 0)
grub_ieee1275_close (dev->ihandle);
}
grub_disk_dev_unregister (&grub_obdisk_dev);
}
Reference in a new issue View git blame Copy permalink