a492f4ebdb
Add a new disk driver called obdisk for IEEE1275 platforms. Currently the only platform using this disk driver is SPARC, however other IEEE1275 platforms could start using it if they so choose. While the functionality within the current IEEE1275 ofdisk driver may be suitable for PPC and x86, it presented too many problems on SPARC hardware. Within the old ofdisk, there is not a way to determine the true canonical name for the disk. Within Open Boot, the same disk can have multiple names but all reference the same disk. For example the same disk can be referenced by its SAS WWN, using this form: /pci@302/pci@2/pci@0/pci@17/LSI,sas@0/disk@w5000cca02f037d6d,0 It can also be referenced by its PHY identifier using this form: /pci@302/pci@2/pci@0/pci@17/LSI,sas@0/disk@p0 It can also be referenced by its Target identifier using this form: /pci@302/pci@2/pci@0/pci@17/LSI,sas@0/disk@0 Also, when the LUN=0, it is legal to omit the ,0 from the device name. So with the disk above, before taking into account the device aliases, there are 6 ways to reference the same disk. Then it is possible to have 0 .. n device aliases all representing the same disk. Within this new driver the true canonical name is determined using the the IEEE1275 encode-unit and decode-unit commands when address_cells == 4. This will determine the true single canonical name for the device so multiple ihandles are not opened for the same device. This is what frequently happens with the old ofdisk driver. With some devices when they are opened multiple times it causes the entire system to hang. Another problem solved with this driver is devices that do not have a device alias can be booted and used within GRUB. Within the old ofdisk, this was not possible, unless it was the original boot device. All devices behind a SAS or SCSI parent can be found. Within the old ofdisk, finding these disks relied on there being an alias defined. The alias requirement is not necessary with this new driver. It can also find devices behind a parent after they have been hot-plugged. This is something that is not possible with the old ofdisk driver. The old ofdisk driver also incorrectly assumes that the device pointing to by a device alias is in its true canonical form. This assumption is never made with this new driver. Another issue solved with this driver is that it properly caches the ihandle for all open devices. The old ofdisk tries to do this by caching the last opened ihandle. However this does not work properly because the layer above does not use a consistent device name for the same disk when calling into the driver. This is because the upper layer uses the bootpath value returned within /chosen, other times it uses the device alias, and other times it uses the value within grub.cfg. It does not have a way to figure out that these devices are the same disk. This is not a problem with this new driver. Due to the way GRUB repeatedly opens and closes the same disk. Caching the ihandle is important on SPARC. Without caching, some SAS devices can take 15 - 20 minutes to get to the GRUB menu. This ihandle caching is not possible without correctly having the canonical disk name. When available, this driver also tries to use the deblocker #blocks and a way of determining the disk size. Finally and probably most importantly, this new driver is also capable of seeing all partitions on a GPT disk. With the old driver, the GPT partition table can not be read and only the first partition on the disk can be seen. Signed-off-by: Eric Snowberg <eric.snowberg@oracle.com> Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
322 lines
7.6 KiB
C
322 lines
7.6 KiB
C
/* init.c -- Initialize GRUB on the newworld mac (PPC). */
|
|
/*
|
|
* GRUB -- GRand Unified Bootloader
|
|
* Copyright (C) 2003,2004,2005,2007,2008,2009 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/kernel.h>
|
|
#include <grub/dl.h>
|
|
#include <grub/disk.h>
|
|
#include <grub/mm.h>
|
|
#include <grub/partition.h>
|
|
#include <grub/normal.h>
|
|
#include <grub/fs.h>
|
|
#include <grub/setjmp.h>
|
|
#include <grub/env.h>
|
|
#include <grub/misc.h>
|
|
#include <grub/time.h>
|
|
#include <grub/ieee1275/console.h>
|
|
#include <grub/ieee1275/ofdisk.h>
|
|
#ifdef __sparc__
|
|
#include <grub/ieee1275/obdisk.h>
|
|
#endif
|
|
#include <grub/ieee1275/ieee1275.h>
|
|
#include <grub/net.h>
|
|
#include <grub/offsets.h>
|
|
#include <grub/memory.h>
|
|
#include <grub/loader.h>
|
|
#ifdef __i386__
|
|
#include <grub/cpu/tsc.h>
|
|
#endif
|
|
#ifdef __sparc__
|
|
#include <grub/machine/kernel.h>
|
|
#endif
|
|
|
|
/* The minimal heap size we can live with. */
|
|
#define HEAP_MIN_SIZE (unsigned long) (2 * 1024 * 1024)
|
|
|
|
/* The maximum heap size we're going to claim */
|
|
#ifdef __i386__
|
|
#define HEAP_MAX_SIZE (unsigned long) (64 * 1024 * 1024)
|
|
#else
|
|
#define HEAP_MAX_SIZE (unsigned long) (32 * 1024 * 1024)
|
|
#endif
|
|
|
|
/* If possible, we will avoid claiming heap above this address, because it
|
|
seems to cause relocation problems with OSes that link at 4 MiB */
|
|
#ifdef __i386__
|
|
#define HEAP_MAX_ADDR (unsigned long) (64 * 1024 * 1024)
|
|
#else
|
|
#define HEAP_MAX_ADDR (unsigned long) (32 * 1024 * 1024)
|
|
#endif
|
|
|
|
extern char _start[];
|
|
extern char _end[];
|
|
|
|
#ifdef __sparc__
|
|
grub_addr_t grub_ieee1275_original_stack;
|
|
#endif
|
|
|
|
void
|
|
grub_exit (void)
|
|
{
|
|
grub_ieee1275_exit ();
|
|
}
|
|
|
|
/* Translate an OF filesystem path (separated by backslashes), into a GRUB
|
|
path (separated by forward slashes). */
|
|
static void
|
|
grub_translate_ieee1275_path (char *filepath)
|
|
{
|
|
char *backslash;
|
|
|
|
backslash = grub_strchr (filepath, '\\');
|
|
while (backslash != 0)
|
|
{
|
|
*backslash = '/';
|
|
backslash = grub_strchr (filepath, '\\');
|
|
}
|
|
}
|
|
|
|
void (*grub_ieee1275_net_config) (const char *dev, char **device, char **path,
|
|
char *bootpath);
|
|
void
|
|
grub_machine_get_bootlocation (char **device, char **path)
|
|
{
|
|
char *bootpath;
|
|
char *filename;
|
|
char *type;
|
|
|
|
bootpath = grub_ieee1275_get_boot_dev ();
|
|
if (! bootpath)
|
|
return;
|
|
|
|
/* Transform an OF device path to a GRUB path. */
|
|
|
|
type = grub_ieee1275_get_device_type (bootpath);
|
|
if (type && grub_strcmp (type, "network") == 0)
|
|
{
|
|
char *dev, *canon;
|
|
char *ptr;
|
|
dev = grub_ieee1275_get_aliasdevname (bootpath);
|
|
canon = grub_ieee1275_canonicalise_devname (dev);
|
|
if (! canon)
|
|
return;
|
|
ptr = canon + grub_strlen (canon) - 1;
|
|
while (ptr > canon && (*ptr == ',' || *ptr == ':'))
|
|
ptr--;
|
|
ptr++;
|
|
*ptr = 0;
|
|
|
|
if (grub_ieee1275_net_config)
|
|
grub_ieee1275_net_config (canon, device, path, bootpath);
|
|
grub_free (dev);
|
|
grub_free (canon);
|
|
}
|
|
else
|
|
*device = grub_ieee1275_encode_devname (bootpath);
|
|
grub_free (type);
|
|
|
|
filename = grub_ieee1275_get_filename (bootpath);
|
|
if (filename)
|
|
{
|
|
char *lastslash = grub_strrchr (filename, '\\');
|
|
|
|
/* Truncate at last directory. */
|
|
if (lastslash)
|
|
{
|
|
*lastslash = '\0';
|
|
grub_translate_ieee1275_path (filename);
|
|
|
|
*path = filename;
|
|
}
|
|
}
|
|
grub_free (bootpath);
|
|
}
|
|
|
|
/* Claim some available memory in the first /memory node. */
|
|
#ifdef __sparc__
|
|
static void
|
|
grub_claim_heap (void)
|
|
{
|
|
grub_mm_init_region ((void *) (grub_modules_get_end ()
|
|
+ GRUB_KERNEL_MACHINE_STACK_SIZE), 0x200000);
|
|
}
|
|
#else
|
|
/* Helper for grub_claim_heap. */
|
|
static int
|
|
heap_init (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type,
|
|
void *data)
|
|
{
|
|
unsigned long *total = data;
|
|
|
|
if (type != GRUB_MEMORY_AVAILABLE)
|
|
return 0;
|
|
|
|
if (grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_NO_PRE1_5M_CLAIM))
|
|
{
|
|
if (addr + len <= 0x180000)
|
|
return 0;
|
|
|
|
if (addr < 0x180000)
|
|
{
|
|
len = addr + len - 0x180000;
|
|
addr = 0x180000;
|
|
}
|
|
}
|
|
len -= 1; /* Required for some firmware. */
|
|
|
|
/* Never exceed HEAP_MAX_SIZE */
|
|
if (*total + len > HEAP_MAX_SIZE)
|
|
len = HEAP_MAX_SIZE - *total;
|
|
|
|
/* Avoid claiming anything above HEAP_MAX_ADDR, if possible. */
|
|
if ((addr < HEAP_MAX_ADDR) && /* if it's too late, don't bother */
|
|
(addr + len > HEAP_MAX_ADDR) && /* if it wasn't available anyway, don't bother */
|
|
(*total + (HEAP_MAX_ADDR - addr) > HEAP_MIN_SIZE)) /* only limit ourselves when we can afford to */
|
|
len = HEAP_MAX_ADDR - addr;
|
|
|
|
/* In theory, firmware should already prevent this from happening by not
|
|
listing our own image in /memory/available. The check below is intended
|
|
as a safeguard in case that doesn't happen. However, it doesn't protect
|
|
us from corrupting our module area, which extends up to a
|
|
yet-undetermined region above _end. */
|
|
if ((addr < (grub_addr_t) _end) && ((addr + len) > (grub_addr_t) _start))
|
|
{
|
|
grub_printf ("Warning: attempt to claim over our own code!\n");
|
|
len = 0;
|
|
}
|
|
|
|
if (len)
|
|
{
|
|
grub_err_t err;
|
|
/* Claim and use it. */
|
|
err = grub_claimmap (addr, len);
|
|
if (err)
|
|
return err;
|
|
grub_mm_init_region ((void *) (grub_addr_t) addr, len);
|
|
}
|
|
|
|
*total += len;
|
|
if (*total >= HEAP_MAX_SIZE)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
grub_claim_heap (void)
|
|
{
|
|
unsigned long total = 0;
|
|
|
|
if (grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_FORCE_CLAIM))
|
|
heap_init (GRUB_IEEE1275_STATIC_HEAP_START, GRUB_IEEE1275_STATIC_HEAP_LEN,
|
|
1, &total);
|
|
else
|
|
grub_machine_mmap_iterate (heap_init, &total);
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
grub_parse_cmdline (void)
|
|
{
|
|
grub_ssize_t actual;
|
|
char args[256];
|
|
|
|
if (grub_ieee1275_get_property (grub_ieee1275_chosen, "bootargs", &args,
|
|
sizeof args, &actual) == 0
|
|
&& actual > 1)
|
|
{
|
|
int i = 0;
|
|
|
|
while (i < actual)
|
|
{
|
|
char *command = &args[i];
|
|
char *end;
|
|
char *val;
|
|
|
|
end = grub_strchr (command, ';');
|
|
if (end == 0)
|
|
i = actual; /* No more commands after this one. */
|
|
else
|
|
{
|
|
*end = '\0';
|
|
i += end - command + 1;
|
|
while (grub_isspace(args[i]))
|
|
i++;
|
|
}
|
|
|
|
/* Process command. */
|
|
val = grub_strchr (command, '=');
|
|
if (val)
|
|
{
|
|
*val = '\0';
|
|
grub_env_set (command, val + 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
grub_addr_t grub_modbase;
|
|
|
|
void
|
|
grub_machine_init (void)
|
|
{
|
|
grub_modbase = ALIGN_UP((grub_addr_t) _end
|
|
+ GRUB_KERNEL_MACHINE_MOD_GAP,
|
|
GRUB_KERNEL_MACHINE_MOD_ALIGN);
|
|
grub_ieee1275_init ();
|
|
|
|
grub_console_init_early ();
|
|
grub_claim_heap ();
|
|
grub_console_init_lately ();
|
|
#ifdef __sparc__
|
|
grub_obdisk_init ();
|
|
#else
|
|
grub_ofdisk_init ();
|
|
#endif
|
|
grub_parse_cmdline ();
|
|
|
|
#ifdef __i386__
|
|
grub_tsc_init ();
|
|
#else
|
|
grub_install_get_time_ms (grub_rtc_get_time_ms);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
grub_machine_fini (int flags)
|
|
{
|
|
if (flags & GRUB_LOADER_FLAG_NORETURN)
|
|
{
|
|
#ifdef __sparc__
|
|
grub_obdisk_fini ();
|
|
#else
|
|
grub_ofdisk_fini ();
|
|
#endif
|
|
grub_console_fini ();
|
|
}
|
|
}
|
|
|
|
grub_uint64_t
|
|
grub_rtc_get_time_ms (void)
|
|
{
|
|
grub_uint32_t msecs = 0;
|
|
|
|
grub_ieee1275_milliseconds (&msecs);
|
|
|
|
return msecs;
|
|
}
|