vbatts/grub
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

remove all trailing whitespace

Browse source
This commit is contained in:
fzielcke 2009-06-10 21:04:23 +00:00
parent d2d4966571
commit b39f9d20a9
222 changed files with 3286 additions and 3286 deletions
Download patch file Download diff file Expand all files Collapse all files

42
loader/efi/chainloader.c
View file

@ -45,7 +45,7 @@ static grub_err_t
grub_chainloader_unload (void)
{
grub_efi_boot_services_t *b;
b = grub_efi_system_table->boot_services;
efi_call_1 (b->unload_image, image_handle);
efi_call_2 (b->free_pages, address, pages);
@ -53,7 +53,7 @@ grub_chainloader_unload (void)
grub_free (file_path);
grub_free (cmdline);
cmdline = 0;
grub_dl_unref (my_mod);
return GRUB_ERR_NONE;
}
@ -65,7 +65,7 @@ grub_chainloader_boot (void)
grub_efi_status_t status;
grub_efi_uintn_t exit_data_size;
grub_efi_char16_t *exit_data;
b = grub_efi_system_table->boot_services;
status = efi_call_3 (b->start_image, image_handle, &exit_data_size, &exit_data);
if (status != GRUB_EFI_SUCCESS)
@ -73,13 +73,13 @@ grub_chainloader_boot (void)
if (exit_data)
{
char *buf;
buf = grub_malloc (exit_data_size * 4 + 1);
if (buf)
{
*grub_utf16_to_utf8 ((grub_uint8_t *) buf,
exit_data, exit_data_size) = 0;
grub_error (GRUB_ERR_BAD_OS, buf);
grub_free (buf);
}
@ -92,7 +92,7 @@ grub_chainloader_boot (void)
efi_call_1 (b->free_pool, exit_data);
grub_chainloader_unload ();
return grub_errno;
}
@ -102,7 +102,7 @@ copy_file_path (grub_efi_file_path_device_path_t *fp,
{
grub_efi_char16_t *p;
grub_efi_uint16_t size;
fp->header.type = GRUB_EFI_MEDIA_DEVICE_PATH_TYPE;
fp->header.subtype = GRUB_EFI_FILE_PATH_DEVICE_PATH_SUBTYPE;
size = len * sizeof (grub_efi_char16_t) + sizeof (*fp);
@ -135,7 +135,7 @@ make_file_path (grub_efi_device_path_t *dp, const char *filename)
grub_error (GRUB_ERR_BAD_FILENAME, "invalid EFI file path");
return 0;
}
size = 0;
d = dp;
while (1)
@ -145,7 +145,7 @@ make_file_path (grub_efi_device_path_t *dp, const char *filename)
break;
d = GRUB_EFI_NEXT_DEVICE_PATH (d);
}
file_path = grub_malloc (size
+ ((grub_strlen (dir_start) + 1)
* sizeof (grub_efi_char16_t))
@ -154,7 +154,7 @@ make_file_path (grub_efi_device_path_t *dp, const char *filename)
return 0;
grub_memcpy (file_path, dp, size);
/* Fill the file path for the directory. */
d = (grub_efi_device_path_t *) ((char *) file_path
+ ((char *) d - (char *) dp));
@ -194,14 +194,14 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no file specified");
filename = argv[0];
grub_dl_ref (my_mod);
/* Initialize some global variables. */
address = 0;
image_handle = 0;
file_path = 0;
b = grub_efi_system_table->boot_services;
file = grub_file_open (filename);
@ -219,7 +219,7 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
if (dev_handle)
dp = grub_efi_get_device_path (dev_handle);
}
if (! dev->disk || ! dev_handle || ! dp)
{
grub_error (GRUB_ERR_BAD_DEVICE, "not a valid root device");
@ -232,10 +232,10 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
grub_printf ("file path: ");
grub_efi_print_device_path (file_path);
size = grub_file_size (file);
pages = (((grub_efi_uintn_t) size + ((1 << 12) - 1)) >> 12);
status = efi_call_4 (b->allocate_pages, GRUB_EFI_ALLOCATE_ANY_PAGES,
GRUB_EFI_LOADER_CODE,
pages, &address);
@ -262,7 +262,7 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
grub_error (GRUB_ERR_OUT_OF_MEMORY, "out of resources");
else
grub_error (GRUB_ERR_BAD_OS, "cannot load image");
goto fail;
}
@ -276,7 +276,7 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
goto fail;
}
loaded_image->device_handle = dev_handle;
grub_file_close (file);
if (argc > 1)
@ -310,21 +310,21 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
grub_loader_set (grub_chainloader_boot, grub_chainloader_unload, 0);
return 0;
fail:
if (dev)
grub_device_close (dev);
if (file)
grub_file_close (file);
if (file_path)
grub_free (file_path);
if (address)
efi_call_2 (b->free_pages, address, pages);
grub_dl_unref (my_mod);
return grub_errno;

36
loader/i386/bsd.c
View file

@ -168,7 +168,7 @@ grub_freebsd_add_mmap (void)
int NESTED_FUNC_ATTR hook (grub_uint64_t addr, grub_uint64_t size,
grub_uint32_t type)
{
/* FreeBSD assumes that first 64KiB are available.
/* FreeBSD assumes that first 64KiB are available.
Not always true but try to prevent panic somehow. */
if (isfirstrun && addr != 0)
{
@ -180,7 +180,7 @@ grub_freebsd_add_mmap (void)
mmap++;
}
else
len += sizeof (struct grub_e820_mmap);
len += sizeof (struct grub_e820_mmap);
}
isfirstrun = 0;
if (mmap)
@ -242,9 +242,9 @@ grub_freebsd_add_mmap (void)
for (i = 0; i < mmap - mmap_buf; i++)
grub_dprintf ("bsd", "smap %d, %d:%llx - %llx\n", i,
mmap_buf[i].type,
(unsigned long long) mmap_buf[i].addr,
(unsigned long long) mmap_buf[i].addr,
(unsigned long long) mmap_buf[i].size);
grub_dprintf ("bsd", "%d entries in smap\n", mmap - mmap_buf);
grub_freebsd_add_meta (FREEBSD_MODINFO_METADATA |
FREEBSD_MODINFOMD_SMAP, mmap_buf, len);
@ -286,12 +286,12 @@ grub_freebsd_add_meta_module (int is_kern, int argc, char **argv,
if (is_64bit)
{
grub_uint64_t addr64 = addr, size64 = size;
grub_uint64_t addr64 = addr, size64 = size;
if ((grub_freebsd_add_meta (FREEBSD_MODINFO_TYPE, type,
grub_strlen (type) + 1)) ||
(grub_freebsd_add_meta (FREEBSD_MODINFO_ADDR, &addr64,
(grub_freebsd_add_meta (FREEBSD_MODINFO_ADDR, &addr64,
sizeof (addr64))) ||
(grub_freebsd_add_meta (FREEBSD_MODINFO_SIZE, &size64,
(grub_freebsd_add_meta (FREEBSD_MODINFO_SIZE, &size64,
sizeof (size64))))
return grub_errno;
}
@ -299,9 +299,9 @@ grub_freebsd_add_meta_module (int is_kern, int argc, char **argv,
{
if ((grub_freebsd_add_meta (FREEBSD_MODINFO_TYPE, type,
grub_strlen (type) + 1)) ||
(grub_freebsd_add_meta (FREEBSD_MODINFO_ADDR, &addr,
(grub_freebsd_add_meta (FREEBSD_MODINFO_ADDR, &addr,
sizeof (addr))) ||
(grub_freebsd_add_meta (FREEBSD_MODINFO_SIZE, &size,
(grub_freebsd_add_meta (FREEBSD_MODINFO_SIZE, &size,
sizeof (size))))
return grub_errno;
}
@ -502,22 +502,22 @@ grub_freebsd_boot (void)
gdtdesc->base = gdt;
/* Prepare trampoline. */
trampoline = (grub_uint8_t *) (kern_end - 4096 + 24
trampoline = (grub_uint8_t *) (kern_end - 4096 + 24
+ sizeof (struct gdt_descriptor));
launch_trampoline = (void __attribute__ ((cdecl, regparm (0)))
launch_trampoline = (void __attribute__ ((cdecl, regparm (0)))
(*) (grub_addr_t entry, ...)) trampoline;
grub_bsd64_trampoline_gdt = (grub_uint32_t) gdtdesc;
grub_bsd64_trampoline_selfjump
grub_bsd64_trampoline_selfjump
= (grub_uint32_t) (trampoline + 6
+ ((grub_uint8_t *) &grub_bsd64_trampoline_selfjump
+ ((grub_uint8_t *) &grub_bsd64_trampoline_selfjump
- &grub_bsd64_trampoline_start));
/* Copy trampoline. */
grub_memcpy (trampoline, &grub_bsd64_trampoline_start,
grub_memcpy (trampoline, &grub_bsd64_trampoline_start,
&grub_bsd64_trampoline_end - &grub_bsd64_trampoline_start);
/* Launch trampoline. */
launch_trampoline (entry, entry_hi, pagetable, bi.bi_modulep,
launch_trampoline (entry, entry_hi, pagetable, bi.bi_modulep,
kern_end);
}
else
@ -547,7 +547,7 @@ grub_openbsd_boot (void)
case GRUB_MACHINE_MEMORY_AVAILABLE:
pm->type = OPENBSD_MMAP_AVAILABLE;
break;
default:
pm->type = OPENBSD_MMAP_RESERVED;
break;
@ -574,7 +574,7 @@ grub_openbsd_boot (void)
(part << OPENBSD_B_PARTSHIFT));
grub_unix_real_boot (entry, bootflags, bootdev, OPENBSD_BOOTARG_APIVER,
0, grub_mmap_get_upper () >> 10,
0, grub_mmap_get_upper () >> 10,
grub_mmap_get_lower () >> 10,
(char *) pa - buf, buf);
@ -603,7 +603,7 @@ grub_netbsd_boot (void)
bootinfo->bi_data[0] = rootdev;
grub_unix_real_boot (entry, bootflags, 0, bootinfo,
0, grub_mmap_get_upper () >> 10,
0, grub_mmap_get_upper () >> 10,
grub_mmap_get_lower () >> 10);
/* Not reached. */

4
loader/i386/bsd_helper.S
View file

@ -17,9 +17,9 @@
*/
#include <grub/symbol.h>
.p2align 2
.code32

8
loader/i386/bsd_pagetable.c
View file

@ -17,7 +17,7 @@
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
/* Based on the code from FreeBSD originally distributed under the
/* Based on the code from FreeBSD originally distributed under the
following terms: */
/*-
@ -63,12 +63,12 @@ fill_bsd64_pagetable (grub_uint8_t *target)
pt4 = (grub_uint64_t *) target;
pt3 = (grub_uint64_t *) (target + 4096);
pt2 = (grub_uint64_t *) (target + 8192);
grub_memset ((char *) target, 0, 4096 * 3);
/*
* This is kinda brutal, but every single 1GB VM memory segment points to
* the same first 1GB of physical memory. But it is how BSD expects
* the same first 1GB of physical memory. But it is how BSD expects
* it to be.
*/
for (i = 0; i < 512; i++)
@ -80,7 +80,7 @@ fill_bsd64_pagetable (grub_uint8_t *target)
/* Each slot of the level 3 pages points to the same level 2 page */
pt3[i] = (grub_addr_t) &pt2[0];
pt3[i] |= PG_V | PG_RW | PG_U;
/* The level 2 page slots are mapped with 2MB pages for 1GB. */
pt2[i] = i * (2 * 1024 * 1024);
pt2[i] |= PG_V | PG_RW | PG_PS | PG_U;

12
loader/i386/bsd_trampoline.S
View file

@ -17,7 +17,7 @@
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
/* Based on the code from FreeBSD originally distributed under the
/* Based on the code from FreeBSD originally distributed under the
following terms: */
/*-
@ -48,7 +48,7 @@
* $FreeBSD$
*/
#define MSR_EFER 0xc0000080
#define EFER_LME 0x00000100
#define CR4_PAE 0x00000020
@ -58,10 +58,10 @@
#include <grub/symbol.h>
.p2align 2
.code32
.code32
VARIABLE(grub_bsd64_trampoline_start)
/* Discard `grub_unix_real_boot' return address. */
@ -105,7 +105,7 @@ VARIABLE(grub_bsd64_trampoline_start)
.byte 0x15
VARIABLE (grub_bsd64_trampoline_gdt)
.long 0x0
/* ljmp */
.byte 0xea
VARIABLE (grub_bsd64_trampoline_selfjump)

82
loader/i386/efi/linux.c
View file

@ -103,21 +103,21 @@ find_mmap_size (void)
if (mmap_size != 0)
return mmap_size;
mmap_size = (1 << 12);
while (1)
{
int ret;
grub_efi_memory_descriptor_t *mmap;
grub_efi_uintn_t desc_size;
mmap = grub_malloc (mmap_size);
if (! mmap)
return 0;
ret = grub_efi_get_memory_map (&mmap_size, mmap, 0, &desc_size, 0);
grub_free (mmap);
if (ret < 0)
grub_fatal ("cannot get memory map");
else if (ret > 0)
@ -147,7 +147,7 @@ free_pages (void)
grub_efi_free_pages ((grub_addr_t) prot_mode_mem, prot_mode_pages);
prot_mode_mem = 0;
}
if (initrd_mem)
{
grub_efi_free_pages ((grub_addr_t) initrd_mem, initrd_pages);
@ -165,7 +165,7 @@ allocate_pages (grub_size_t prot_size)
grub_efi_uintn_t mmap_size, tmp_mmap_size;
grub_efi_memory_descriptor_t *desc;
grub_size_t real_size;
/* Make sure that each size is aligned to a page boundary. */
real_size = GRUB_LINUX_CL_END_OFFSET;
prot_size = page_align (prot_size);
@ -173,16 +173,16 @@ allocate_pages (grub_size_t prot_size)
grub_dprintf ("linux", "real_size = %x, prot_size = %x, mmap_size = %x\n",
(unsigned) real_size, (unsigned) prot_size, (unsigned) mmap_size);
/* Calculate the number of pages; Combine the real mode code with
the memory map buffer for simplicity. */
real_mode_pages = ((real_size + mmap_size) >> 12);
prot_mode_pages = (prot_size >> 12);
/* Initialize the memory pointers with NULL for convenience. */
real_mode_mem = 0;
prot_mode_mem = 0;
/* Read the memory map temporarily, to find free space. */
mmap = grub_malloc (mmap_size);
if (! mmap)
@ -193,7 +193,7 @@ allocate_pages (grub_size_t prot_size)
grub_fatal ("cannot get memory map");
mmap_end = NEXT_MEMORY_DESCRIPTOR (mmap, tmp_mmap_size);
/* First, find free pages for the real mode code
and the memory map buffer. */
for (desc = mmap;
@ -208,7 +208,7 @@ allocate_pages (grub_size_t prot_size)
{
grub_efi_physical_address_t physical_end;
grub_efi_physical_address_t addr;
physical_end = desc->physical_start + (desc->num_pages << 12);
if (physical_end > 0x90000)
physical_end = 0x90000;
@ -225,7 +225,7 @@ allocate_pages (grub_size_t prot_size)
real_mode_mem = grub_efi_allocate_pages (addr, real_mode_pages);
if (! real_mode_mem)
grub_fatal ("cannot allocate pages");
desc->num_pages -= real_mode_pages;
break;
}
@ -238,7 +238,7 @@ allocate_pages (grub_size_t prot_size)
}
mmap_buf = (void *) ((char *) real_mode_mem + real_size);
/* Next, find free pages for the protected mode code. */
/* XXX what happens if anything is using this address? */
prot_mode_mem = grub_efi_allocate_pages (0x100000, prot_mode_pages + 1);
@ -299,7 +299,7 @@ grub_linux_boot (void)
grub_efi_uintn_t desc_size;
grub_efi_uint32_t desc_version;
int e820_num;
params = real_mode_mem;
grub_dprintf ("linux", "code32_start = %x, idt_desc = %lx, gdt_desc = %lx\n",
@ -382,12 +382,12 @@ grub_linux_boot (void)
}
#ifdef __x86_64__
grub_memcpy ((char *) prot_mode_mem + (prot_mode_pages << 12),
grub_linux_trampoline_start,
grub_memcpy ((char *) prot_mode_mem + (prot_mode_pages << 12),
grub_linux_trampoline_start,
grub_linux_trampoline_end - grub_linux_trampoline_start);
((void (*) (unsigned long, void *)) ((char *) prot_mode_mem
((void (*) (unsigned long, void *)) ((char *) prot_mode_mem
+ (prot_mode_pages << 12)))
(params->code32_start, real_mode_mem);
@ -395,7 +395,7 @@ grub_linux_boot (void)
/* Hardware interrupts are not safe any longer. */
asm volatile ("cli" : : );
/* Load the IDT and the GDT for the bootstrap. */
asm volatile ("lidt %0" : : "m" (idt_desc));
asm volatile ("lgdt %0" : : "m" (gdt_desc));
@ -408,7 +408,7 @@ grub_linux_boot (void)
/* Enter Linux. */
asm volatile ("jmp *%%ecx" : : );
#endif
/* Never reach here. */
@ -605,7 +605,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
char *dest;
grub_dl_ref (my_mod);
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
@ -650,17 +650,17 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
}
setup_sects = lh.setup_sects;
/* If SETUP_SECTS is not set, set it to the default (4). */
if (! setup_sects)
setup_sects = GRUB_LINUX_DEFAULT_SETUP_SECTS;
real_size = setup_sects << GRUB_DISK_SECTOR_BITS;
prot_size = grub_file_size (file) - real_size - GRUB_DISK_SECTOR_SIZE;
if (! allocate_pages (prot_size))
goto fail;
params = (struct linux_kernel_params *) real_mode_mem;
grub_memset (params, 0, GRUB_LINUX_CL_END_OFFSET);
grub_memcpy (&params->setup_sects, &lh.setup_sects, sizeof (lh) - 0x1F1);
@ -691,7 +691,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
space. */
params->ext_mem = ((32 * 0x100000) >> 10);
params->alt_mem = ((32 * 0x100000) >> 10);
params->video_cursor_x = grub_getxy () >> 8;
params->video_cursor_y = grub_getxy () & 0xff;
params->video_page = 0; /* ??? */
@ -778,7 +778,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
grub_memset (params->padding7, 0, sizeof (params->padding7));
grub_memset (params->padding8, 0, sizeof (params->padding8));
grub_memset (params->padding9, 0, sizeof (params->padding9));
#endif
/* The other EFI parameters are filled when booting. */
@ -797,9 +797,9 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
if (grub_memcmp (argv[i], "mem=", 4) == 0)
{
char *val = argv[i] + 4;
linux_mem_size = grub_strtoul (val, &val, 0);
if (grub_errno)
{
grub_errno = GRUB_ERR_NONE;
@ -808,7 +808,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
else
{
int shift = 0;
switch (grub_tolower (val[0]))
{
case 'g':
@ -838,7 +838,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
dest = grub_stpcpy ((char *) real_mode_mem + GRUB_LINUX_CL_OFFSET,
"BOOT_IMAGE=");
dest = grub_stpcpy (dest, argv[0]);
/* Copy kernel parameters. */
for (i = 1;
i < argc
@ -861,7 +861,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
}
fail:
if (file)
grub_file_close (file);
@ -886,13 +886,13 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
grub_efi_memory_descriptor_t *desc;
grub_efi_uintn_t desc_size;
struct linux_kernel_header *lh;
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "No module specified");
goto fail;
}
if (! loaded)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "You need to load the kernel first.");
@ -907,11 +907,11 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
initrd_pages = (page_align (size) >> 12);
lh = (struct linux_kernel_header *) real_mode_mem;
addr_max = (grub_cpu_to_le32 (lh->initrd_addr_max) << 10);
if (linux_mem_size != 0 && linux_mem_size < addr_max)
addr_max = linux_mem_size;
/* Linux 2.3.xx has a bug in the memory range check, so avoid
the last page.
Linux 2.2.xx has a bug in the memory range check, which is
@ -921,7 +921,7 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
/* Usually, the compression ratio is about 50%. */
addr_min = (grub_addr_t) prot_mode_mem + ((prot_mode_pages * 3) << 12)
+ page_align (size);
/* Find the highest address to put the initrd. */
mmap_size = find_mmap_size ();
if (grub_efi_get_memory_map (&mmap_size, mmap_buf, 0, &desc_size, 0) <= 0)
@ -936,7 +936,7 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
&& desc->num_pages >= initrd_pages)
{
grub_efi_physical_address_t physical_end;
physical_end = desc->physical_start + (desc->num_pages << 12);
if (physical_end > addr_max)
physical_end = addr_max;
@ -958,11 +958,11 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
grub_error (GRUB_ERR_OUT_OF_MEMORY, "no free pages available");
goto fail;
}
initrd_mem = grub_efi_allocate_pages (addr, initrd_pages);
if (! initrd_mem)
grub_fatal ("cannot allocate pages");
if (grub_file_read (file, initrd_mem, size) != size)
{
grub_error (GRUB_ERR_FILE_READ_ERROR, "Couldn't read file");
@ -971,11 +971,11 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
grub_printf (" [Initrd, addr=0x%x, size=0x%x]\n",
(unsigned) addr, (unsigned) size);
lh->ramdisk_image = addr;
lh->ramdisk_size = size;
lh->root_dev = 0x0100; /* XXX */
fail:
if (file)
grub_file_close (file);

94
loader/i386/linux.c
View file

@ -285,15 +285,15 @@ find_mmap_size (void)
count++;
return 0;
}
grub_mmap_iterate (hook);
mmap_size = count * sizeof (struct grub_e820_mmap);
/* Increase the size a bit for safety, because GRUB allocates more on
later. */
mmap_size += (1 << 12);
return page_align (mmap_size);
}
@ -317,15 +317,15 @@ allocate_pages (grub_size_t prot_size)
grub_dprintf ("linux", "real_size = %x, prot_size = %x, mmap_size = %x\n",
(unsigned) real_size, (unsigned) prot_size, (unsigned) mmap_size);
/* Calculate the number of pages; Combine the real mode code with
the memory map buffer for simplicity. */
real_mode_pages = ((real_size + mmap_size) >> 12);
prot_mode_pages = (prot_size >> 12);
/* Initialize the memory pointers with NULL for convenience. */
free_pages ();
/* FIXME: Should request low memory from the heap when this feature is
implemented. */
@ -451,11 +451,11 @@ grub_linux_boot (void)
modevar = grub_env_get ("gfxpayload");
/* Now all graphical modes are acceptable.
/* Now all graphical modes are acceptable.
May change in future if we have modes without framebuffer. */
if (modevar && *modevar != 0)
{
tmp = grub_malloc (grub_strlen (modevar)
tmp = grub_malloc (grub_strlen (modevar)
+ sizeof (DEFAULT_VIDEO_MODE) + 1);
if (! tmp)
return grub_errno;
@ -485,7 +485,7 @@ grub_linux_boot (void)
params->video_width = 80;
params->video_height = 25;
}
grub_dprintf ("linux", "code32_start = %x, idt_desc = %lx, gdt_desc = %lx\n",
(unsigned) params->code32_start,
(unsigned long) &(idt_desc.limit),
@ -538,18 +538,18 @@ grub_linux_boot (void)
#ifdef __x86_64__
grub_memcpy ((char *) prot_mode_mem + (prot_mode_pages << 12),
grub_linux_trampoline_start,
grub_memcpy ((char *) prot_mode_mem + (prot_mode_pages << 12),
grub_linux_trampoline_start,
grub_linux_trampoline_end - grub_linux_trampoline_start);
((void (*) (unsigned long, void *)) ((char *) prot_mode_mem
((void (*) (unsigned long, void *)) ((char *) prot_mode_mem
+ (prot_mode_pages << 12)))
(params->code32_start, real_mode_mem);
#else
/* Hardware interrupts are not safe any longer. */
asm volatile ("cli" : : );
/* Load the IDT and the GDT for the bootstrap. */
asm volatile ("lidt %0" : : "m" (idt_desc));
asm volatile ("lgdt %0" : : "m" (gdt_desc));
@ -562,7 +562,7 @@ grub_linux_boot (void)
/* Enter Linux. */
asm volatile ("jmp *%%ecx" : : );
#endif
/* Never reach here. */
@ -591,7 +591,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
char *dest;
grub_dl_ref (my_mod);
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
@ -644,17 +644,17 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
}
setup_sects = lh.setup_sects;
/* If SETUP_SECTS is not set, set it to the default (4). */
if (! setup_sects)
setup_sects = GRUB_LINUX_DEFAULT_SETUP_SECTS;
real_size = setup_sects << GRUB_DISK_SECTOR_BITS;
prot_size = grub_file_size (file) - real_size - GRUB_DISK_SECTOR_SIZE;
if (! allocate_pages (prot_size))
goto fail;
params = (struct linux_kernel_params *) real_mode_mem;
grub_memset (params, 0, GRUB_LINUX_CL_END_OFFSET);
grub_memcpy (&params->setup_sects, &lh.setup_sects, sizeof (lh) - 0x1F1);
@ -684,7 +684,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
space. */
params->ext_mem = ((32 * 0x100000) >> 10);
params->alt_mem = ((32 * 0x100000) >> 10);
params->video_page = 0; /* ??? */
params->video_mode = 0;
params->video_ega_bx = 0;
@ -734,8 +734,8 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
grub_env_set ("gfxpayload", "text");
grub_printf ("%s is deprecated. "
"Use set gfxpayload=text before "
"linux command instead.\n",
argv[i]);
"linux command instead.\n",
argv[i]);
break;
case 1:
@ -744,8 +744,8 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
grub_env_set ("gfxpayload", "text");
grub_printf ("%s is deprecated. "
"Use set gfxpayload=text before "
"linux command instead.\n",
argv[i]);
"linux command instead.\n",
argv[i]);
break;
default:
/* Ignore invalid values. */
@ -756,19 +756,19 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
grub_env_set ("gfxpayload", "text");
grub_printf ("%s is deprecated. Mode %d isn't recognized. "
"Use set gfxpayload=WIDTHxHEIGHT[xDEPTH] before "
"linux command instead.\n",
argv[i], vid_mode);
"linux command instead.\n",
argv[i], vid_mode);
break;
}
buf = grub_malloc (sizeof ("WWWWxHHHHxDD;WWWWxHHHH"));
if (! buf)
goto fail;
linux_mode
linux_mode
= &linux_vesafb_modes[vid_mode - GRUB_LINUX_VID_MODE_VESA_START];
grub_sprintf (buf, "%ux%ux%u;%ux%u",
grub_sprintf (buf, "%ux%ux%u;%ux%u",
linux_vesafb_res[linux_mode->res_index].width,
linux_vesafb_res[linux_mode->res_index].height,
linux_mode->depth,
@ -776,8 +776,8 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
linux_vesafb_res[linux_mode->res_index].height);
grub_printf ("%s is deprecated. "
"Use set gfxpayload=%s before "
"linux command instead.\n",
argv[i], buf);
"linux command instead.\n",
argv[i], buf);
err = grub_env_set ("gfxpayload", buf);
grub_free (buf);
if (err)
@ -789,9 +789,9 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
if (grub_memcmp (argv[i], "mem=", 4) == 0)
{
char *val = argv[i] + 4;
linux_mem_size = grub_strtoul (val, &val, 0);
if (grub_errno)
{
grub_errno = GRUB_ERR_NONE;
@ -800,7 +800,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
else
{
int shift = 0;
switch (grub_tolower (val[0]))
{
case 'g':
@ -820,12 +820,12 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
linux_mem_size <<= shift;
}
}
/* Specify the boot file. */
dest = grub_stpcpy ((char *) real_mode_mem + GRUB_LINUX_CL_OFFSET,
"BOOT_IMAGE=");
dest = grub_stpcpy (dest, argv[0]);
/* Copy kernel parameters. */
for (i = 1;
i < argc
@ -849,7 +849,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
}
fail:
if (file)
grub_file_close (file);
@ -871,13 +871,13 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
grub_addr_t addr_min, addr_max;
grub_addr_t addr;
struct linux_kernel_header *lh;
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "No module specified");
goto fail;
}
if (! loaded)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "You need to load the kernel first.");
@ -906,10 +906,10 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
}
else
addr_max = GRUB_LINUX_INITRD_MAX_ADDRESS;
if (linux_mem_size != 0 && linux_mem_size < addr_max)
addr_max = linux_mem_size;
/* Linux 2.3.xx has a bug in the memory range check, so avoid
the last page.
Linux 2.2.xx has a bug in the memory range check, which is
@ -919,7 +919,7 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
/* Usually, the compression ratio is about 50%. */
addr_min = (grub_addr_t) prot_mode_mem + ((prot_mode_pages * 3) << 12)
+ page_align (size);
if (addr_max > grub_os_area_addr + grub_os_area_size)
addr_max = grub_os_area_addr + grub_os_area_size;
@ -931,9 +931,9 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
grub_error (GRUB_ERR_OUT_OF_RANGE, "The initrd is too big");
goto fail;
}
initrd_mem = (void *) addr;
if (grub_file_read (file, initrd_mem, size) != size)
{
grub_error (GRUB_ERR_FILE_READ_ERROR, "Couldn't read file");
@ -942,11 +942,11 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
grub_printf (" [Initrd, addr=0x%x, size=0x%x]\n",
(unsigned) addr, (unsigned) size);
lh->ramdisk_image = addr;
lh->ramdisk_size = size;
lh->root_dev = 0x0100; /* XXX */
fail:
if (file)
grub_file_close (file);

42
loader/i386/linux_trampoline.S
View file

@ -17,7 +17,7 @@
*/
#include <grub/symbol.h>
.p2align 4 /* force 16-byte alignment */
VARIABLE(grub_linux_trampoline_start)
@ -26,23 +26,23 @@ VARIABLE(grub_linux_trampoline_start)
contains real memory start. */
mov %rsi, %rbx
call base
base:
base:
pop %rsi
#ifdef APPLE_CC
#ifdef APPLE_CC
lea (cont1 - base) (%esi, 1), %rax
mov %eax, (jump_vector - base) (%esi, 1)
lea (gdt - base) (%esi, 1), %rax
mov %rax, (gdtaddr - base) (%esi, 1)
/* Switch to compatibility mode. */
lidt (idtdesc - base) (%esi, 1)
lgdt (gdtdesc - base) (%esi, 1)
/* Update %cs. Thanks to David Miller for pointing this mistake out. */
ljmp *(jump_vector - base) (%esi, 1)
#else
@ -51,22 +51,22 @@ base:
lea (gdt - base) (%rsi, 1), %rax
mov %rax, (gdtaddr - base) (%rsi, 1)
/* Switch to compatibility mode. */
lidt (idtdesc - base) (%rsi, 1)
lgdt (gdtdesc - base) (%rsi, 1)
/* Update %cs. Thanks to David Miller for pointing this mistake out. */
ljmp *(jump_vector - base) (%rsi, 1)
#endif
cont1:
.code32
/* Update other registers. */
mov $0x18, %eax
mov %eax, %ds
mov %eax, %ds
mov %eax, %es
mov %eax, %fs
mov %eax, %gs
@ -89,41 +89,41 @@ cont1:
mov %eax, %cr4
jmp cont2
cont2:
cont2:
.code32
mov %ebx, %esi
jmp *%edi
/* GDT. */
.p2align 4
gdt:
gdt:
/* NULL. */
.byte 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
/* Reserved. */
.byte 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
/* Code segment. */
.byte 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x9A, 0xCF, 0x00
/* Data segment. */
.byte 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x92, 0xCF, 0x00
gdtdesc:
gdtdesc:
.word 31
gdtaddr:
gdtaddr:
.quad gdt
idtdesc:
idtdesc:
.word 0
idtaddr:
idtaddr:
.quad 0
.p2align 4
jump_vector:
/* Jump location. Is filled by the code */
.long 0
.long 0x10
.long 0x10
VARIABLE(grub_linux_trampoline_end)

18
loader/i386/multiboot.c
View file

@ -76,7 +76,7 @@ grub_multiboot_unload (void)
grub_free ((void *) mbi->cmdline);
grub_free (mbi);
}
mbi = 0;
grub_dl_unref (my_mod);
@ -98,9 +98,9 @@ grub_get_multiboot_mmap_len (void)
count++;
return 0;
}
grub_mmap_iterate (hook);
return count * sizeof (struct grub_multiboot_mmap_entry);
}
@ -297,11 +297,11 @@ grub_multiboot (int argc, char *argv[])
grub_file_read (file, (void *) grub_multiboot_payload_orig, load_size);
if (grub_errno)
goto fail;
if (header->bss_end_addr)
grub_memset ((void *) (grub_multiboot_payload_orig + load_size), 0,
header->bss_end_addr - header->load_addr - load_size);
grub_multiboot_payload_entry_offset = header->entry_addr - header->load_addr;
}
@ -315,7 +315,7 @@ grub_multiboot (int argc, char *argv[])
mbi_dest = mbi_addr (grub_multiboot_payload_dest);
grub_memset (mbi, 0, sizeof (struct grub_multiboot_info));
mbi->mmap_length = mmap_length;
grub_fill_multiboot_mmap (mmap_addr (grub_multiboot_payload_orig));
/* FIXME: grub_uint32_t will break for addresses above 4 GiB, but is mandated
@ -334,7 +334,7 @@ grub_multiboot (int argc, char *argv[])
&grub_multiboot_backward_relocator, RELOCATOR_SIZEOF(backward));
entry = (grub_addr_t) grub_multiboot_payload_orig + grub_multiboot_payload_size;
}
grub_dprintf ("multiboot_loader", "dest=%p, size=0x%x, entry_offset=0x%x\n",
(void *) grub_multiboot_payload_dest,
grub_multiboot_payload_size,
@ -360,8 +360,8 @@ grub_multiboot (int argc, char *argv[])
mbi->flags |= MULTIBOOT_INFO_CMDLINE;
mbi->cmdline = (grub_uint32_t) cmdline_addr (grub_multiboot_payload_dest);
grub_strcpy (boot_loader_name_addr (grub_multiboot_payload_orig), PACKAGE_STRING);
mbi->flags |= MULTIBOOT_INFO_BOOT_LOADER_NAME;
mbi->boot_loader_name = (grub_uint32_t) boot_loader_name_addr (grub_multiboot_payload_dest);

8
loader/i386/multiboot_elfxx.c
View file

@ -63,10 +63,10 @@ CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, void *buffer)
|| ehdr->e_ident[EI_DATA] != ELFDATA2LSB
|| ehdr->e_machine != E_MACHINE)
return grub_error(GRUB_ERR_UNKNOWN_OS, "no valid ELF header found");
if (ehdr->e_type != ET_EXEC && ehdr->e_type != ET_DYN)
return grub_error (GRUB_ERR_UNKNOWN_OS, "invalid ELF file type");
/* FIXME: Should we support program headers at strange locations? */
if (ehdr->e_phoff + ehdr->e_phnum * ehdr->e_phentsize > MULTIBOOT_SEARCH)
return grub_error (GRUB_ERR_BAD_OS, "program header at a too high offset");
@ -84,7 +84,7 @@ CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, void *buffer)
if (phdr(i)->p_type == PT_LOAD && phdr(i)->p_filesz != 0)
{
/* Beware that segment 0 isn't necessarily loadable */
if (lowest_segment == -1
if (lowest_segment == -1
|| phdr(i)->p_paddr < phdr(lowest_segment)->p_paddr)
lowest_segment = i;
if (highest_segment == -1
@ -132,7 +132,7 @@ CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, void *buffer)
}
for (i = 0; i < ehdr->e_phnum; i++)
if (phdr(i)->p_vaddr <= ehdr->e_entry
if (phdr(i)->p_vaddr <= ehdr->e_entry
&& phdr(i)->p_vaddr + phdr(i)->p_memsz > ehdr->e_entry)
{
grub_multiboot_payload_entry_offset = (ehdr->e_entry - phdr(i)->p_vaddr)

4
loader/i386/multiboot_helper.S
View file

@ -19,7 +19,7 @@
#include <grub/symbol.h>
#include <multiboot.h>
#include <multiboot2.h>
.p2align 2 /* force 4-byte alignment */
/*
@ -91,7 +91,7 @@ FUNCTION(grub_multiboot_real_boot)
/* Move the magic value into eax. */
movl $MULTIBOOT_MAGIC2, %eax
/* Jump to the relocator. */
popl %ebp
jmp *%ebp

16
loader/i386/pc/chainloader.c
View file

@ -62,7 +62,7 @@ grub_chainloader_cmd (const char *filename, grub_chainloader_flags_t flags)
void *part_addr = 0;
grub_dl_ref (my_mod);
file = grub_file_open (filename);
if (! file)
goto fail;
@ -93,11 +93,11 @@ grub_chainloader_cmd (const char *filename, grub_chainloader_flags_t flags)
if (dev)
{
grub_disk_t disk = dev->disk;
if (disk)
{
grub_partition_t p = disk->partition;
/* In i386-pc, the id is equal to the BIOS drive number. */
drive = (int) disk->id;
@ -112,21 +112,21 @@ grub_chainloader_cmd (const char *filename, grub_chainloader_flags_t flags)
grub_device_close (dev);
}
/* Ignore errors. Perhaps it's not fatal. */
grub_errno = GRUB_ERR_NONE;
boot_drive = drive;
boot_part_addr = part_addr;
grub_loader_set (grub_chainloader_boot, grub_chainloader_unload, 1);
return;
fail:
if (file)
grub_file_close (file);
grub_dl_unref (my_mod);
}
@ -142,7 +142,7 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
argc--;
argv++;
}
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no file specified");
else

40
loader/i386/pc/linux.c
View file

@ -60,7 +60,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
char *dest;
grub_dl_ref (my_mod);
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
@ -100,27 +100,27 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
grub_linux_is_bzimage = 0;
setup_sects = lh.setup_sects;
linux_mem_size = 0;
if (lh.header == grub_cpu_to_le32 (GRUB_LINUX_MAGIC_SIGNATURE)
&& grub_le_to_cpu16 (lh.version) >= 0x0200)
{
grub_linux_is_bzimage = (lh.loadflags & GRUB_LINUX_FLAG_BIG_KERNEL);
lh.type_of_loader = GRUB_LINUX_BOOT_LOADER_TYPE;
/* Put the real mode part at as a high location as possible. */
grub_linux_real_addr
grub_linux_real_addr
= (char *) UINT_TO_PTR (grub_mmap_get_lower ()
- GRUB_LINUX_SETUP_MOVE_SIZE);
/* But it must not exceed the traditional area. */
if (grub_linux_real_addr > (char *) GRUB_LINUX_OLD_REAL_MODE_ADDR)
grub_linux_real_addr = (char *) GRUB_LINUX_OLD_REAL_MODE_ADDR;
if (grub_le_to_cpu16 (lh.version) >= 0x0201)
{
lh.heap_end_ptr = grub_cpu_to_le16 (GRUB_LINUX_HEAP_END_OFFSET);
lh.loadflags |= GRUB_LINUX_FLAG_CAN_USE_HEAP;
}
if (grub_le_to_cpu16 (lh.version) >= 0x0202)
lh.cmd_line_ptr = grub_linux_real_addr + GRUB_LINUX_CL_OFFSET;
else
@ -135,19 +135,19 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
/* Your kernel is quite old... */
lh.cl_magic = grub_cpu_to_le16 (GRUB_LINUX_CL_MAGIC);
lh.cl_offset = grub_cpu_to_le16 (GRUB_LINUX_CL_OFFSET);
setup_sects = GRUB_LINUX_DEFAULT_SETUP_SECTS;
grub_linux_real_addr = (char *) GRUB_LINUX_OLD_REAL_MODE_ADDR;
}
/* If SETUP_SECTS is not set, set it to the default (4). */
if (! setup_sects)
setup_sects = GRUB_LINUX_DEFAULT_SETUP_SECTS;
real_size = setup_sects << GRUB_DISK_SECTOR_BITS;
prot_size = grub_file_size (file) - real_size - GRUB_DISK_SECTOR_SIZE;
grub_linux_tmp_addr = (char *) GRUB_LINUX_BZIMAGE_ADDR + prot_size;
if (! grub_linux_is_bzimage
@ -158,7 +158,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
(grub_size_t) grub_linux_real_addr);
goto fail;
}
if (grub_linux_real_addr + GRUB_LINUX_SETUP_MOVE_SIZE
> (char *) UINT_TO_PTR (grub_mmap_get_lower ()))
{
@ -196,9 +196,9 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
else if (grub_memcmp (argv[i], "mem=", 4) == 0)
{
char *val = argv[i] + 4;
linux_mem_size = grub_strtoul (val, &val, 0);
if (grub_errno)
{
grub_errno = GRUB_ERR_NONE;
@ -207,7 +207,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
else
{
int shift = 0;
switch (grub_tolower (val[0]))
{
case 'g':
@ -251,7 +251,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
dest = grub_stpcpy (grub_linux_tmp_addr + GRUB_LINUX_CL_OFFSET,
"BOOT_IMAGE=");
dest = grub_stpcpy (dest, argv[0]);
/* Copy kernel parameters. */
for (i = 1;
i < argc
@ -266,7 +266,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
len = prot_size;
if (grub_file_read (file, (char *) GRUB_LINUX_BZIMAGE_ADDR, len) != len)
grub_error (GRUB_ERR_FILE_READ_ERROR, "Couldn't read file");
if (grub_errno == GRUB_ERR_NONE)
{
grub_linux_prot_size = prot_size;
@ -275,7 +275,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
}
fail:
if (file)
grub_file_close (file);
@ -302,7 +302,7 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
grub_error (GRUB_ERR_BAD_ARGUMENT, "No module specified");
goto fail;
}
if (!loaded)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "You need to load the kernel first.");
@ -369,7 +369,7 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
lh->ramdisk_image = addr;
lh->ramdisk_size = size;
fail:
if (file)
grub_file_close (file);

4
loader/i386/pc/multiboot2.c
View file

@ -33,7 +33,7 @@ grub_mb2_arch_elf32_hook (Elf32_Phdr *phdr, UNUSED grub_addr_t *addr)
if ((paddr < grub_os_area_addr)
|| (paddr + phdr->p_memsz > grub_os_area_addr + grub_os_area_size))
return grub_error(GRUB_ERR_OUT_OF_RANGE,"Address 0x%x is out of range",
return grub_error(GRUB_ERR_OUT_OF_RANGE,"Address 0x%x is out of range",
paddr);
return GRUB_ERR_NONE;
@ -82,7 +82,7 @@ void
grub_mb2_arch_unload (struct multiboot_tag_header *tags)
{
struct multiboot_tag_header *tag;
/* Free all module memory in the tag list. */
for_each_tag (tag, tags)
{

14
loader/i386/pc/xnu.c
View file

@ -54,10 +54,10 @@ grub_xnu_set_video (struct grub_xnu_boot_params *params)
err = grub_video_set_mode (DEFAULT_VIDEO_MODE, video_hook);
else
{
tmp = grub_malloc (grub_strlen (modevar)
tmp = grub_malloc (grub_strlen (modevar)
+ sizeof (DEFAULT_VIDEO_MODE) + 1);
if (! tmp)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"couldn't allocate temporary storag");
grub_sprintf (tmp, "%s;" DEFAULT_VIDEO_MODE, modevar);
err = grub_video_set_mode (tmp, video_hook);
@ -86,9 +86,9 @@ grub_xnu_set_video (struct grub_xnu_boot_params *params)
y > 0 ? y : 0,
x < 0 ? -x : 0,
y < 0 ? -y : 0,
min (grub_xnu_bitmap->mode_info.width,
mode_info.width),
min (grub_xnu_bitmap->mode_info.height,
min (grub_xnu_bitmap->mode_info.width,
mode_info.width),
min (grub_xnu_bitmap->mode_info.height,
mode_info.height));
if (err)
{
@ -103,8 +103,8 @@ grub_xnu_set_video (struct grub_xnu_boot_params *params)
params->lfb_line_len = mode_info.pitch;
params->lfb_base = PTR_TO_UINT32 (render_target->data);
params->lfb_mode = grub_xnu_bitmap
? GRUB_XNU_VIDEO_SPLASH : GRUB_XNU_VIDEO_TEXT_IN_VIDEO;
params->lfb_mode = grub_xnu_bitmap
? GRUB_XNU_VIDEO_SPLASH : GRUB_XNU_VIDEO_TEXT_IN_VIDEO;
return GRUB_ERR_NONE;
}

106
loader/i386/xnu.c
View file

@ -44,10 +44,10 @@ struct tbl_alias table_aliases[] =
{GRUB_EFI_ACPI_TABLE_GUID, "ACPI"},
};
/* The following function is used to be able to debug xnu loader
/* The following function is used to be able to debug xnu loader
with grub-emu. */
#ifdef GRUB_UTIL
static grub_err_t
static grub_err_t
grub_xnu_launch (void)
{
grub_printf ("Fake launch %x:%p:%p", grub_xnu_entry_point, grub_xnu_arg1,
@ -78,7 +78,7 @@ readfrequency (const char *str)
while (*str)
{
unsigned long digit;
digit = grub_tolower (*str) - '0';
if (digit > 9)
break;
@ -95,7 +95,7 @@ readfrequency (const char *str)
while (*str)
{
unsigned long digit;
digit = grub_tolower (*str) - '0';
if (digit > 9)
break;
@ -125,7 +125,7 @@ guessfsb (void)
if (! grub_cpu_is_cpuid_supported ())
return sane_value;
#ifdef APPLE_CC
asm volatile ("movl $0, %%eax\n"
#ifdef __x86_64__
@ -138,18 +138,18 @@ guessfsb (void)
"pop %%rbx\n"
#else
"pop %%ebx\n"
#endif
: "=a" (max_cpuid),
#endif
: "=a" (max_cpuid),
"=d" (manufacturer[1]), "=c" (manufacturer[2]));
/* Only Intel for now is done. */
if (grub_memcmp (manufacturer + 1, "ineIntel", 12) != 0)
return sane_value;
#else
asm volatile ("movl $0, %%eax\n"
"cpuid"
: "=a" (max_cpuid), "=b" (manufacturer[0]),
: "=a" (max_cpuid), "=b" (manufacturer[0]),
"=d" (manufacturer[1]), "=c" (manufacturer[2]));
/* Only Intel for now is done. */
@ -167,7 +167,7 @@ guessfsb (void)
"push %%rbx\n"
#else
"push %%ebx\n"
#endif
#endif
"cpuid\n"
#ifdef __x86_64__
"pop %%rbx\n"
@ -175,7 +175,7 @@ guessfsb (void)
"pop %%ebx\n"
#endif
: "=c" (capabilities):
: "%rax", "%rdx");
: "%rax", "%rdx");
#else
asm volatile ("movl $1, %%eax\n"
"cpuid"
@ -201,7 +201,7 @@ guessfsb (void)
:
: "%ecx", "%eax");
return grub_divmod64 (2000 * tsc_ticks_per_ms,
return grub_divmod64 (2000 * tsc_ticks_per_ms,
((msrlow >> 7) & 0x3e) + ((msrlow >> 14) & 1), 0);
}
@ -254,7 +254,7 @@ grub_cpu_xnu_fill_devicetree (void)
curval = grub_xnu_create_value (&(efikey->first_child), "firmware-vendor");
if (! curval)
return grub_errno;
curval->datasize =
curval->datasize =
2 * (utf16_strlen (SYSTEM_TABLE_PTR (firmware_vendor)) + 1);
curval->data = grub_malloc (curval->datasize);
if (! curval->data)
@ -275,7 +275,7 @@ grub_cpu_xnu_fill_devicetree (void)
grub_memcpy (curval->data, "EFI64", curval->datasize);
/* The key "platform". */
platformkey = grub_xnu_create_key (&(efikey->first_child),
platformkey = grub_xnu_create_key (&(efikey->first_child),
"platform");
if (! platformkey)
return grub_errno;
@ -292,16 +292,16 @@ grub_cpu_xnu_fill_devicetree (void)
/* First see if user supplies the value. */
char *fsbvar = grub_env_get ("fsb");
if (! fsbvar)
*((grub_uint64_t *) curval->data) = 0;
*((grub_uint64_t *) curval->data) = 0;
else
*((grub_uint64_t *) curval->data) = readfrequency (fsbvar);
/* Try autodetect. */
if (! *((grub_uint64_t *) curval->data))
*((grub_uint64_t *) curval->data) = guessfsb ();
grub_dprintf ("xnu", "fsb autodetected as %llu\n",
*((grub_uint64_t *) curval->data) = guessfsb ();
grub_dprintf ("xnu", "fsb autodetected as %llu\n",
(unsigned long long) *((grub_uint64_t *) curval->data));
cfgtablekey = grub_xnu_create_key (&(efikey->first_child),
cfgtablekey = grub_xnu_create_key (&(efikey->first_child),
"configuration-table");
if (!cfgtablekey)
return grub_errno;
@ -317,11 +317,11 @@ grub_cpu_xnu_fill_devicetree (void)
/* Retrieve current key. */
#ifdef GRUB_MACHINE_EFI
{
ptr = (void *)
ptr = (void *)
grub_efi_system_table->configuration_table[i].vendor_table;
guid = grub_efi_system_table->configuration_table[i].vendor_guid;
}
#else
#else
if (SIZEOF_OF_UINTN == 4)
{
ptr = UINT_TO_PTR (((grub_efiemu_configuration_table32_t *)
@ -336,7 +336,7 @@ grub_cpu_xnu_fill_devicetree (void)
ptr = UINT_TO_PTR (((grub_efiemu_configuration_table64_t *)
SYSTEM_TABLE_PTR (configuration_table))[i]
.vendor_table);
guid =
guid =
((grub_efiemu_configuration_table64_t *)
SYSTEM_TABLE_PTR (configuration_table))[i].vendor_guid;
}
@ -362,7 +362,7 @@ grub_cpu_xnu_fill_devicetree (void)
curval->datasize = sizeof (guid);
curval->data = grub_malloc (curval->datasize);
if (! curval->data)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"couldn't create device tree");
grub_memcpy (curval->data, &guid, curval->datasize);
@ -373,7 +373,7 @@ grub_cpu_xnu_fill_devicetree (void)
curval->datasize = SIZEOF_OF_UINTN;
curval->data = grub_malloc (curval->datasize);
if (! curval->data)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"couldn't create device tree");
if (SIZEOF_OF_UINTN == 4)
*((grub_uint32_t *)curval->data) = PTR_TO_UINT32 (ptr);
@ -392,14 +392,14 @@ grub_cpu_xnu_fill_devicetree (void)
curval->datasize = grub_strlen (table_aliases[j].name) + 1;
curval->data = grub_malloc (curval->datasize);
if (!curval->data)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"couldn't create device tree");
grub_memcpy (curval->data, table_aliases[j].name, curval->datasize);
}
}
/* Create and fill "runtime-services" key. */
runtimesrvkey = grub_xnu_create_key (&(efikey->first_child),
runtimesrvkey = grub_xnu_create_key (&(efikey->first_child),
"runtime-services");
if (! runtimesrvkey)
return grub_errno;
@ -409,20 +409,20 @@ grub_cpu_xnu_fill_devicetree (void)
curval->datasize = SIZEOF_OF_UINTN;
curval->data = grub_malloc (curval->datasize);
if (! curval->data)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"couldn't create device tree");
if (SIZEOF_OF_UINTN == 4)
*((grub_uint32_t *) curval->data)
*((grub_uint32_t *) curval->data)
= PTR_TO_UINT32 (SYSTEM_TABLE_PTR (runtime_services));
else
*((grub_uint64_t *) curval->data)
*((grub_uint64_t *) curval->data)
= PTR_TO_UINT64 (SYSTEM_TABLE_PTR (runtime_services));
return GRUB_ERR_NONE;
}
/* Boot xnu. */
grub_err_t
grub_err_t
grub_xnu_boot (void)
{
struct grub_xnu_boot_params *bootparams_relloc;
@ -464,17 +464,17 @@ grub_xnu_boot (void)
&map_key, &descriptor_size,
&descriptor_version) <= 0)
return grub_errno;
mmap_relloc_off = (grub_uint8_t *) memory_map
mmap_relloc_off = (grub_uint8_t *) memory_map
- (grub_uint8_t *) grub_xnu_heap_start;
firstruntimeaddr = (grub_uint64_t) (-1);
firstruntimeaddr = (grub_uint64_t) (-1);
lastruntimeaddr = 0;
for (i = 0; (unsigned) i < memory_map_size / descriptor_size; i++)
{
grub_efi_memory_descriptor_t *curdesc = (grub_efi_memory_descriptor_t *)
grub_efi_memory_descriptor_t *curdesc = (grub_efi_memory_descriptor_t *)
((char *) memory_map + descriptor_size * i);
/* Some EFI implementations set physical_start to 0 which
/* Some EFI implementations set physical_start to 0 which
causes XNU crash. */
curdesc->virtual_start = curdesc->physical_start;
@ -494,7 +494,7 @@ grub_xnu_boot (void)
bootparams_relloc = grub_xnu_heap_malloc (sizeof (*bootparams_relloc));
if (! bootparams_relloc)
return grub_errno;
bootparams_relloc_off = (grub_uint8_t *) bootparams_relloc
bootparams_relloc_off = (grub_uint8_t *) bootparams_relloc
- (grub_uint8_t *) grub_xnu_heap_start;
err = grub_xnu_writetree_toheap (&devtree, &devtreelen);
if (err)
@ -502,10 +502,10 @@ grub_xnu_boot (void)
bootparams_relloc = (struct grub_xnu_boot_params *)
(bootparams_relloc_off + (grub_uint8_t *) grub_xnu_heap_start);
grub_memcpy (bootparams_relloc->cmdline, grub_xnu_cmdline,
grub_memcpy (bootparams_relloc->cmdline, grub_xnu_cmdline,
sizeof (bootparams_relloc->cmdline));
bootparams_relloc->devtree = ((char *) devtree - grub_xnu_heap_start)
bootparams_relloc->devtree = ((char *) devtree - grub_xnu_heap_start)
+ grub_xnu_heap_will_be_at;
bootparams_relloc->devtreelen = devtreelen;
@ -513,41 +513,41 @@ grub_xnu_boot (void)
bootparams_relloc->heap_size = grub_xnu_heap_size;
bootparams_relloc->efi_mmap = grub_xnu_heap_will_be_at + mmap_relloc_off;
bootparams_relloc->efi_mmap_size = memory_map_size;
bootparams_relloc->efi_mem_desc_size = descriptor_size;
bootparams_relloc->efi_mem_desc_version = descriptor_version;
bootparams_relloc->efi_mmap_size = memory_map_size;
bootparams_relloc->efi_mem_desc_size = descriptor_size;
bootparams_relloc->efi_mem_desc_version = descriptor_version;
bootparams_relloc->efi_runtime_first_page = firstruntimeaddr
bootparams_relloc->efi_runtime_first_page = firstruntimeaddr
/ GRUB_XNU_PAGESIZE;
bootparams_relloc->efi_runtime_npages
= ((lastruntimeaddr + GRUB_XNU_PAGESIZE - 1) / GRUB_XNU_PAGESIZE)
bootparams_relloc->efi_runtime_npages
= ((lastruntimeaddr + GRUB_XNU_PAGESIZE - 1) / GRUB_XNU_PAGESIZE)
- (firstruntimeaddr / GRUB_XNU_PAGESIZE);
bootparams_relloc->efi_uintnbits = SIZEOF_OF_UINTN * 8;
bootparams_relloc->efi_system_table
bootparams_relloc->efi_system_table
= PTR_TO_UINT32 (grub_autoefi_system_table);
bootparams_relloc->verminor = GRUB_XNU_BOOTARGS_VERMINOR;
bootparams_relloc->verminor = GRUB_XNU_BOOTARGS_VERMINOR;
bootparams_relloc->vermajor = GRUB_XNU_BOOTARGS_VERMAJOR;
/* Parameters for asm helper. */
grub_xnu_stack = bootparams_relloc->heap_start
grub_xnu_stack = bootparams_relloc->heap_start
+ bootparams_relloc->heap_size + GRUB_XNU_PAGESIZE;
grub_xnu_arg1 = bootparams_relloc_off + grub_xnu_heap_will_be_at;
#ifndef GRUB_UTIL
grub_xnu_launch = (void (*) (void))
grub_xnu_launch = (void (*) (void))
(grub_xnu_heap_start + grub_xnu_heap_size);
#endif
grub_dprintf ("xnu", "eip=%x\n", grub_xnu_entry_point);
grub_dprintf ("xnu", "launch=%p\n", grub_xnu_launch);
const char *debug = grub_env_get ("debug");
if (debug && (grub_strword (debug, "all") || grub_strword (debug, "xnu")))
{
grub_printf ("Press any key to launch xnu\n");
grub_getkey ();
}
/* Set video. */
err = grub_xnu_set_video (bootparams_relloc);
if (err != GRUB_ERR_NONE)
@ -564,8 +564,8 @@ grub_xnu_boot (void)
bootparams_relloc->lfb_base = 0;
}
grub_memcpy (grub_xnu_heap_start + grub_xnu_heap_size,
grub_xnu_launcher_start,
grub_memcpy (grub_xnu_heap_start + grub_xnu_heap_size,
grub_xnu_launcher_start,
grub_xnu_launcher_end - grub_xnu_launcher_start);

52
loader/i386/xnu_helper.S
View file

@ -17,27 +17,27 @@
*/
#include <grub/symbol.h>
.p2align 4 /* force 16-byte alignment */
VARIABLE(grub_xnu_launcher_start)
base:
base:
cli
#ifndef __x86_64__
/* mov imm32, %eax */
.byte 0xb8
VARIABLE(grub_xnu_heap_will_be_at)
.long 0
mov %eax, %edi
/* mov imm32, %eax */
.byte 0xb8
VARIABLE(grub_xnu_heap_start)
.long 0
mov %eax, %esi
/* mov imm32, %ecx */
.byte 0xb9
VARIABLE(grub_xnu_heap_size)
@ -57,16 +57,16 @@ VARIABLE(grub_xnu_heap_size)
mov %eax, %esi
add $(cont0-base), %eax
jmp *%eax
cont0:
cont0:
#else
xorq %rax, %rax
/* mov imm32, %eax */
.byte 0xb8
VARIABLE(grub_xnu_heap_will_be_at)
.long 0
mov %rax, %rdi
/* mov imm32, %rax */
.byte 0x48
.byte 0xb8
@ -74,7 +74,7 @@ VARIABLE(grub_xnu_heap_start)
.long 0
.long 0
mov %rax, %rsi
/* mov imm32, %rcx */
.byte 0x48
.byte 0xb9
@ -101,18 +101,18 @@ VARIABLE(grub_xnu_heap_size)
#endif
jmp *%rax
cont0:
cont0:
#ifdef APPLE_CC
lea (cont1 - base) (%esi, 1), %eax
mov %eax, (jump_vector - base) (%esi, 1)
lea (gdt - base) (%esi, 1), %eax
mov %eax, (gdt_addr - base) (%esi, 1)
/* Switch to compatibility mode. */
lgdt (gdtdesc - base) (%esi, 1)
/* Update %cs. Thanks to David Miller for pointing this mistake out. */
ljmp *(jump_vector - base) (%esi,1)
#else
@ -121,21 +121,21 @@ cont0:
lea (gdt - base) (%rsi, 1), %rax
mov %rax, (gdt_addr - base) (%rsi, 1)
/* Switch to compatibility mode. */
lgdt (gdtdesc - base) (%rsi, 1)
/* Update %cs. Thanks to David Miller for pointing this mistake out. */
ljmp *(jump_vector - base) (%rsi, 1)
#endif
cont1:
.code32
/* Update other registers. */
mov $0x18, %eax
mov %eax, %ds
mov %eax, %ds
mov %eax, %es
mov %eax, %fs
mov %eax, %gs
@ -158,10 +158,10 @@ cont1:
mov %eax, %cr4
jmp cont2
cont2:
cont2:
#endif
.code32
/* Registers on XNU boot: eip, esp and eax. */
/* mov imm32, %ecx */
.byte 0xb9
@ -183,29 +183,29 @@ VARIABLE (grub_xnu_stack)
#ifdef __x86_64__
/* GDT. Copied from loader/i386/linux.c. */
.p2align 4
gdt:
gdt:
/* NULL. */
.byte 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
/* Reserved. */
.byte 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
/* Code segment. */
.byte 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x9A, 0xCF, 0x00
/* Data segment. */
.byte 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x92, 0xCF, 0x00
gdtdesc:
gdtdesc:
.word 31
gdt_addr:
gdt_addr:
/* Filled by the code. */
.quad 0
.p2align 4
jump_vector:
/* Jump location. Is filled by the code */
.long 0
.long 0x10
.long 0x10
#endif
VARIABLE(grub_xnu_launcher_end)

64
loader/macho.c
View file

@ -51,16 +51,16 @@ grub_macho_parse32 (grub_macho_t macho)
/* Read header and check magic*/
if (grub_file_seek (macho->file, macho->offset32) == (grub_off_t) -1
|| grub_file_read (macho->file, (char *) &head, sizeof (head))
|| grub_file_read (macho->file, (char *) &head, sizeof (head))
!= sizeof(head))
{
grub_error (GRUB_ERR_READ_ERROR, "Cannot read Mach-O header.");
grub_error (GRUB_ERR_READ_ERROR, "Cannot read Mach-O header.");
macho->offset32 = -1;
return;
}
if (head.magic != GRUB_MACHO_MAGIC32)
{
grub_error (GRUB_ERR_BAD_OS, "Invalid Mach-O 32-bit header.");
grub_error (GRUB_ERR_BAD_OS, "Invalid Mach-O 32-bit header.");
macho->offset32 = -1;
return;
}
@ -74,17 +74,17 @@ grub_macho_parse32 (grub_macho_t macho)
grub_error (GRUB_ERR_OUT_OF_MEMORY, "not enough memory to read commands");
return;
}
if (grub_file_read (macho->file, (char *) macho->cmds32,
(grub_size_t) macho->cmdsize32)
if (grub_file_read (macho->file, (char *) macho->cmds32,
(grub_size_t) macho->cmdsize32)
!= (grub_ssize_t) macho->cmdsize32)
{
grub_error (GRUB_ERR_READ_ERROR, "Cannot read Mach-O header.");
grub_error (GRUB_ERR_READ_ERROR, "Cannot read Mach-O header.");
macho->offset32 = -1;
}
}
typedef int NESTED_FUNC_ATTR (*grub_macho_iter_hook_t)
(grub_macho_t , struct grub_macho_cmd *,
(grub_macho_t , struct grub_macho_cmd *,
void *);
static grub_err_t
@ -120,7 +120,7 @@ grub_macho32_readfile (grub_macho_t macho, void *dest)
{
grub_ssize_t read;
if (! grub_macho_contains_macho32 (macho))
return grub_error (GRUB_ERR_BAD_OS,
return grub_error (GRUB_ERR_BAD_OS,
"Couldn't read architecture-specific part");
if (grub_file_seek (macho->file, macho->offset32) == (grub_off_t) -1)
@ -130,12 +130,12 @@ grub_macho32_readfile (grub_macho_t macho, void *dest)
"Invalid offset in program header.");
}
read = grub_file_read (macho->file, dest,
read = grub_file_read (macho->file, dest,
macho->end32 - macho->offset32);
if (read != (grub_ssize_t) (macho->end32 - macho->offset32))
{
grub_error_push ();
return grub_error (GRUB_ERR_BAD_OS,
return grub_error (GRUB_ERR_BAD_OS,
"Couldn't read architecture-specific part");
}
return GRUB_ERR_NONE;
@ -150,9 +150,9 @@ grub_macho32_size (grub_macho_t macho, grub_addr_t *segments_start,
/* Run through the program headers to calculate the total memory size we
should claim. */
auto int NESTED_FUNC_ATTR calcsize (grub_macho_t _macho,
auto int NESTED_FUNC_ATTR calcsize (grub_macho_t _macho,
struct grub_macho_cmd *phdr, void *_arg);
int NESTED_FUNC_ATTR calcsize (grub_macho_t UNUSED _macho,
int NESTED_FUNC_ATTR calcsize (grub_macho_t UNUSED _macho,
struct grub_macho_cmd *hdr0, void UNUSED *_arg)
{
struct grub_macho_segment32 *hdr = (struct grub_macho_segment32 *) hdr0;
@ -189,24 +189,24 @@ grub_err_t
grub_macho32_load (grub_macho_t macho, char *offset, int flags)
{
grub_err_t err = 0;
auto int NESTED_FUNC_ATTR do_load(grub_macho_t _macho,
struct grub_macho_cmd *hdr0,
auto int NESTED_FUNC_ATTR do_load(grub_macho_t _macho,
struct grub_macho_cmd *hdr0,
void UNUSED *_arg);
int NESTED_FUNC_ATTR do_load(grub_macho_t _macho,
struct grub_macho_cmd *hdr0,
int NESTED_FUNC_ATTR do_load(grub_macho_t _macho,
struct grub_macho_cmd *hdr0,
void UNUSED *_arg)
{
struct grub_macho_segment32 *hdr = (struct grub_macho_segment32 *) hdr0;
if (hdr->cmd != GRUB_MACHO_CMD_SEGMENT32)
return 0;
if (! hdr->filesize && (flags & GRUB_MACHO_NOBSS))
return 0;
if (! hdr->vmsize)
return 0;
if (grub_file_seek (_macho->file, hdr->fileoff
if (grub_file_seek (_macho->file, hdr->fileoff
+ _macho->offset32) == (grub_off_t) -1)
{
grub_error_push ();
@ -214,11 +214,11 @@ grub_macho32_load (grub_macho_t macho, char *offset, int flags)
"Invalid offset in program header.");
return 1;
}
if (hdr->filesize)
{
grub_ssize_t read;
read = grub_file_read (_macho->file, offset + hdr->vmaddr,
read = grub_file_read (_macho->file, offset + hdr->vmaddr,
min (hdr->filesize, hdr->vmsize));
if (read != (grub_ssize_t) min (hdr->filesize, hdr->vmsize))
{
@ -231,7 +231,7 @@ grub_macho32_load (grub_macho_t macho, char *offset, int flags)
return 1;
}
}
if (hdr->filesize < hdr->vmsize)
grub_memset (offset + hdr->vmaddr + hdr->filesize,
0, hdr->vmsize - hdr->filesize);
@ -247,11 +247,11 @@ grub_uint32_t
grub_macho32_get_entry_point (grub_macho_t macho)
{
grub_uint32_t entry_point = 0;
auto int NESTED_FUNC_ATTR hook(grub_macho_t _macho,
struct grub_macho_cmd *hdr,
auto int NESTED_FUNC_ATTR hook(grub_macho_t _macho,
struct grub_macho_cmd *hdr,
void UNUSED *_arg);
int NESTED_FUNC_ATTR hook(grub_macho_t UNUSED _macho,
struct grub_macho_cmd *hdr,
int NESTED_FUNC_ATTR hook(grub_macho_t UNUSED _macho,
struct grub_macho_cmd *hdr,
void UNUSED *_arg)
{
if (hdr->cmd == GRUB_MACHO_CMD_THREAD)
@ -316,13 +316,13 @@ grub_macho_file (grub_file_t file)
/* Load architecture description. */
narchs = grub_be_to_cpu32 (filestart.fat.nfat_arch);
if (grub_file_seek (macho->file, sizeof (struct grub_macho_fat_header))
if (grub_file_seek (macho->file, sizeof (struct grub_macho_fat_header))
== (grub_off_t) -1)
goto fail;
archs = grub_malloc (sizeof (struct grub_macho_fat_arch) * narchs);
if (!archs)
goto fail;
if (grub_file_read (macho->file, (char *) archs,
if (grub_file_read (macho->file, (char *) archs,
sizeof (struct grub_macho_fat_arch) * narchs)
!= (grub_ssize_t)sizeof(struct grub_macho_fat_arch) * narchs)
{
@ -334,18 +334,18 @@ grub_macho_file (grub_file_t file)
for (i = 0; i < narchs; i++)
{
if (GRUB_MACHO_CPUTYPE_IS_HOST32
if (GRUB_MACHO_CPUTYPE_IS_HOST32
(grub_be_to_cpu32 (archs[i].cputype)))
{
macho->offset32 = grub_be_to_cpu32 (archs[i].offset);
macho->end32 = grub_be_to_cpu32 (archs[i].offset)
macho->end32 = grub_be_to_cpu32 (archs[i].offset)
+ grub_be_to_cpu32 (archs[i].size);
}
if (GRUB_MACHO_CPUTYPE_IS_HOST64
(grub_be_to_cpu32 (archs[i].cputype)))
{
macho->offset64 = grub_be_to_cpu32 (archs[i].offset);
macho->end64 = grub_be_to_cpu32 (archs[i].offset)
macho->end64 = grub_be_to_cpu32 (archs[i].offset)
+ grub_be_to_cpu32 (archs[i].size);
}
}
@ -369,7 +369,7 @@ grub_macho_file (grub_file_t file)
grub_macho_parse32 (macho);
/* FIXME: implement 64-bit.*/
/* grub_macho_parse64 (macho); */
return macho;
fail:

10
loader/multiboot_loader.c
View file

@ -35,11 +35,11 @@ grub_dl_t my_mod;
/* This tracks which version of multiboot to use when using
* the module command. By default use multiboot version 1.
* values:
* 1 - Multiboot version 1
* 1 - Multiboot version 1
* 2 - Multiboot version 2
*/
static unsigned int module_version_status = 1;
static unsigned int module_version_status = 1;
static int
find_multi_boot1_header (grub_file_t file)
@ -48,7 +48,7 @@ find_multi_boot1_header (grub_file_t file)
char buffer[MULTIBOOT_SEARCH];
int found_status = 0;
grub_ssize_t len;
len = grub_file_read (file, buffer, MULTIBOOT_SEARCH);
if (len < 32)
return found_status;
@ -77,7 +77,7 @@ find_multi_boot2_header (grub_file_t file)
char buffer[MULTIBOOT_SEARCH];
int found_status = 0;
grub_ssize_t len;
len = grub_file_read (file, buffer, MULTIBOOT_SEARCH);
if (len < 32)
return found_status;
@ -137,7 +137,7 @@ grub_cmd_multiboot_loader (grub_command_t cmd __attribute__ ((unused)),
/* Launch multi boot with header */
/* XXX Find a better way to identify this.
/* XXX Find a better way to identify this.
This is for i386-pc */
#if defined(GRUB_MACHINE_PCBIOS) || defined(GRUB_MACHINE_LINUXBIOS)
if (header_multi_ver_found == 1)

6
loader/powerpc/ieee1275/linux.c
View file

@ -238,7 +238,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
/* Specify the boot file. */
dest = grub_stpcpy (linux_args, "BOOT_IMAGE=");
dest = grub_stpcpy (dest, argv[0]);
for (i = 1; i < argc; i++)
{
*dest++ = ' ';
@ -297,9 +297,9 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
/* Attempt to claim at a series of addresses until successful in
the same way that grub_rescue_cmd_linux does. */
for (addr = first_addr; addr < first_addr + 200 * 0x100000; addr += 0x100000)
for (addr = first_addr; addr < first_addr + 200 * 0x100000; addr += 0x100000)
{
grub_dprintf ("loader", "Attempting to claim at 0x%x, size 0x%x.\n",
grub_dprintf ("loader", "Attempting to claim at 0x%x, size 0x%x.\n",
addr, size);
found_addr = grub_claimmap (addr, size);
if (found_addr != -1)

204
loader/xnu.c
View file

@ -1,4 +1,4 @@
/* xnu.c - load xnu kernel. Thanks to Florian Idelberger for all the
/* xnu.c - load xnu kernel. Thanks to Florian Idelberger for all the
time he spent testing this
*/
/*
@ -40,7 +40,7 @@ static int driversnum = 0;
#define GRUB_XNU_HEAP_ALLOC_BLOCK 0x2000000
static grub_err_t
grub_xnu_register_memory (char *prefix, int *suffix,
grub_xnu_register_memory (char *prefix, int *suffix,
void *addr, grub_size_t size);
void *
grub_xnu_heap_malloc (int size)
@ -48,7 +48,7 @@ grub_xnu_heap_malloc (int size)
void *val;
#if 0
/* This way booting is faster but less reliable.
/* This way booting is faster but less reliable.
Once we have advanced mm second way will be as fast as this one. */
val = grub_xnu_heap_start = (char *) 0x100000;
#else
@ -56,22 +56,22 @@ grub_xnu_heap_malloc (int size)
/* The page after the heap is used for stack. Ensure it's usable. */
if (grub_xnu_heap_size)
oldblknum = (grub_xnu_heap_size + GRUB_XNU_PAGESIZE
oldblknum = (grub_xnu_heap_size + GRUB_XNU_PAGESIZE
+ GRUB_XNU_HEAP_ALLOC_BLOCK - 1) / GRUB_XNU_HEAP_ALLOC_BLOCK;
else
oldblknum = 0;
newblknum = (grub_xnu_heap_size + size + GRUB_XNU_PAGESIZE
newblknum = (grub_xnu_heap_size + size + GRUB_XNU_PAGESIZE
+ GRUB_XNU_HEAP_ALLOC_BLOCK - 1) / GRUB_XNU_HEAP_ALLOC_BLOCK;
if (oldblknum != newblknum)
/* FIXME: instruct realloc to allocate at 1MB if possible once
/* FIXME: instruct realloc to allocate at 1MB if possible once
advanced mm is ready. */
val = grub_realloc (grub_xnu_heap_start,
val = grub_realloc (grub_xnu_heap_start,
newblknum * GRUB_XNU_HEAP_ALLOC_BLOCK);
else
val = grub_xnu_heap_start;
if (! val)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY,
grub_error (GRUB_ERR_OUT_OF_MEMORY,
"not enough space on xnu memory heap");
return 0;
}
@ -84,8 +84,8 @@ grub_xnu_heap_malloc (int size)
return (char *) val;
}
/* Make sure next block of the heap will be aligned.
Please notice: aligned are pointers AFTER relocation
/* Make sure next block of the heap will be aligned.
Please notice: aligned are pointers AFTER relocation
and not the current ones. */
grub_err_t
grub_xnu_align_heap (int align)
@ -111,9 +111,9 @@ grub_xnu_free_devtree (struct grub_xnu_devtree_key *cur)
else if (cur->data)
grub_free (cur->data);
d = cur->next;
grub_free (cur);
grub_free (cur);
cur = d;
}
}
}
/* Compute the size of device tree in xnu format. */
@ -122,20 +122,20 @@ grub_xnu_writetree_get_size (struct grub_xnu_devtree_key *start, char *name)
{
grub_size_t ret;
struct grub_xnu_devtree_key *cur;
/* Key header. */
ret = 2 * sizeof (grub_uint32_t);
/* "name" value. */
ret += 32 + sizeof (grub_uint32_t)
+ grub_strlen (name) + 4
+ grub_strlen (name) + 4
- (grub_strlen (name) % 4);
for (cur = start; cur; cur = cur->next)
if (cur->datasize != -1)
{
int align_overhead;
align_overhead = 4 - (cur->datasize % 4);
if (align_overhead == 4)
align_overhead = 0;
@ -148,7 +148,7 @@ grub_xnu_writetree_get_size (struct grub_xnu_devtree_key *start, char *name)
/* Write devtree in XNU format at curptr assuming the head is named NAME.*/
static void *
grub_xnu_writetree_toheap_real (void *curptr,
grub_xnu_writetree_toheap_real (void *curptr,
struct grub_xnu_devtree_key *start, char *name)
{
struct grub_xnu_devtree_key *cur;
@ -161,8 +161,8 @@ grub_xnu_writetree_toheap_real (void *curptr,
nvals++;
}
/* For the name. */
nvals++;
nvals++;
*((grub_uint32_t *) curptr) = nvals;
curptr = ((grub_uint32_t *) curptr) + 1;
*((grub_uint32_t *) curptr) = nkeys;
@ -184,7 +184,7 @@ grub_xnu_writetree_toheap_real (void *curptr,
if (cur->datasize != -1)
{
int align_overhead;
align_overhead = 4 - (cur->datasize % 4);
if (align_overhead == 4)
align_overhead = 0;
@ -198,12 +198,12 @@ grub_xnu_writetree_toheap_real (void *curptr,
grub_memset (curptr, 0, align_overhead);
curptr = ((grub_uint8_t *) curptr) + align_overhead;
}
/* And then the keys. Recursively use this function. */
for (cur = start; cur; cur = cur->next)
if (cur->datasize == -1)
if (!(curptr = grub_xnu_writetree_toheap_real (curptr,
cur->first_child,
cur->first_child,
cur->name)))
return 0;
return curptr;
@ -217,11 +217,11 @@ grub_xnu_writetree_toheap (void **start, grub_size_t *size)
struct grub_xnu_devtree_key *driverkey;
struct grub_xnu_extdesc *extdesc;
grub_err_t err;
err = grub_xnu_align_heap (GRUB_XNU_PAGESIZE);
if (err)
return err;
/* Device tree itself is in the memory map of device tree. */
/* Create a dummy value in memory-map. */
chosen = grub_xnu_create_key (&grub_xnu_devtree_root, "chosen");
@ -240,18 +240,18 @@ grub_xnu_writetree_toheap (void **start, grub_size_t *size)
driverkey->datasize = sizeof (*extdesc);
driverkey->next = memorymap->first_child;
memorymap->first_child = driverkey;
driverkey->data = extdesc
driverkey->data = extdesc
= (struct grub_xnu_extdesc *) grub_malloc (sizeof (*extdesc));
if (! driverkey->data)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't write device tree");
/* Allocate the space based on the size with dummy value. */
*size = grub_xnu_writetree_get_size (grub_xnu_devtree_root, "/");
*start = grub_xnu_heap_malloc (*size + GRUB_XNU_PAGESIZE
*start = grub_xnu_heap_malloc (*size + GRUB_XNU_PAGESIZE
- *size % GRUB_XNU_PAGESIZE);
/* Put real data in the dummy. */
extdesc->addr = (char *) *start - grub_xnu_heap_start
extdesc->addr = (char *) *start - grub_xnu_heap_start
+ grub_xnu_heap_will_be_at;
extdesc->size = (grub_uint32_t) *size;
@ -370,7 +370,7 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
if (! grub_macho_contains_macho32 (macho))
{
grub_macho_close (macho);
return grub_error (GRUB_ERR_BAD_OS,
return grub_error (GRUB_ERR_BAD_OS,
"Kernel doesn't contain suitable architecture");
}
@ -382,7 +382,7 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
return err;
}
grub_dprintf ("xnu", "endcode = %lx, startcode = %lx\n",
grub_dprintf ("xnu", "endcode = %lx, startcode = %lx\n",
(unsigned long) endcode, (unsigned long) startcode);
loadaddr = grub_xnu_heap_malloc (endcode - startcode);
@ -392,7 +392,7 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
{
grub_macho_close (macho);
grub_xnu_unload ();
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"not enough memory to load kernel");
}
@ -426,7 +426,7 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
ptr = grub_xnu_cmdline;
for (i = 1; i < argc; i++)
{
if (ptr + grub_strlen (args[i]) + 1
if (ptr + grub_strlen (args[i]) + 1
>= grub_xnu_cmdline + sizeof (grub_xnu_cmdline))
break;
grub_memcpy (ptr, args[i], grub_strlen (args[i]));
@ -437,22 +437,22 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
/* Replace last space by '\0'. */
if (ptr != grub_xnu_cmdline)
*(ptr - 1) = 0;
*(ptr - 1) = 0;
err = grub_cpu_xnu_fill_devicetree ();
if (err)
return err;
grub_loader_set (grub_xnu_boot, grub_xnu_unload, 0);
grub_loader_set (grub_xnu_boot, grub_xnu_unload, 0);
grub_xnu_lock ();
return 0;
}
/* Register a memory in a memory map under name PREFIXSUFFIX
/* Register a memory in a memory map under name PREFIXSUFFIX
and increment SUFFIX. */
static grub_err_t
grub_xnu_register_memory (char *prefix, int *suffix,
grub_xnu_register_memory (char *prefix, int *suffix,
void *addr, grub_size_t size)
{
struct grub_xnu_devtree_key *chosen;
@ -487,11 +487,11 @@ grub_xnu_register_memory (char *prefix, int *suffix,
driverkey->datasize = sizeof (*extdesc);
driverkey->next = memorymap->first_child;
memorymap->first_child = driverkey;
driverkey->data = extdesc
driverkey->data = extdesc
= (struct grub_xnu_extdesc *) grub_malloc (sizeof (*extdesc));
if (! driverkey->data)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't register extension");
extdesc->addr = grub_xnu_heap_will_be_at +
extdesc->addr = grub_xnu_heap_will_be_at +
((grub_uint8_t *) addr - (grub_uint8_t *) grub_xnu_heap_start);
extdesc->size = (grub_uint32_t) size;
return GRUB_ERR_NONE;
@ -511,7 +511,7 @@ grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
if (! grub_xnu_heap_size)
return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded");
/* Compute the needed space. */
if (binaryfile)
{
@ -520,7 +520,7 @@ grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
{
if (macho)
grub_macho_close (macho);
return grub_error (GRUB_ERR_BAD_OS,
return grub_error (GRUB_ERR_BAD_OS,
"Extension doesn't contain suitable architecture");
}
machosize = grub_macho32_filesize (macho);
@ -571,7 +571,7 @@ grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
/* Load the plist. */
if (infoplist)
{
exthead->infoplistaddr = (buf - grub_xnu_heap_start)
exthead->infoplistaddr = (buf - grub_xnu_heap_start)
+ grub_xnu_heap_will_be_at;
exthead->infoplistsize = infoplistsize + 1;
if (grub_file_read (infoplist, buf, infoplistsize)
@ -589,7 +589,7 @@ grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
/* Announce to kernel */
return grub_xnu_register_memory ("Driver-", &driversnum, exthead,
neededspace);
neededspace);
}
/* Load mkext. */
@ -614,14 +614,14 @@ grub_cmd_xnu_mkext (grub_command_t cmd __attribute__ ((unused)),
file = grub_gzfile_open (args[0], 1);
if (! file)
return grub_error (GRUB_ERR_FILE_NOT_FOUND,
return grub_error (GRUB_ERR_FILE_NOT_FOUND,
"Couldn't load driver package");
/* Sometimes caches are fat binary. Errgh. */
if (grub_file_read (file, (char *) &head, sizeof (head))
!= (grub_ssize_t) (sizeof (head)))
{
/* I don't know the internal structure of package but
/* I don't know the internal structure of package but
can hardly imagine a valid package shorter than 20 bytes. */
grub_file_close (file);
grub_error_push ();
@ -637,11 +637,11 @@ grub_cmd_xnu_mkext (grub_command_t cmd __attribute__ ((unused)),
{
grub_file_close (file);
grub_error_push ();
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"Couldn't read file %s", args[0]);
}
if (grub_file_read (file, (char *) archs,
if (grub_file_read (file, (char *) archs,
sizeof (struct grub_macho_fat_arch) * narchs)
!= (grub_ssize_t) sizeof(struct grub_macho_fat_arch) * narchs)
{
@ -651,7 +651,7 @@ grub_cmd_xnu_mkext (grub_command_t cmd __attribute__ ((unused)),
}
for (i = 0; i < narchs; i++)
{
if (GRUB_MACHO_CPUTYPE_IS_HOST32
if (GRUB_MACHO_CPUTYPE_IS_HOST32
(grub_be_to_cpu32 (archs[i].cputype)))
{
readoff = grub_be_to_cpu32 (archs[i].offset);
@ -700,7 +700,7 @@ grub_cmd_xnu_mkext (grub_command_t cmd __attribute__ ((unused)),
/* Pass it to kernel. */
return grub_xnu_register_memory ("DriversPackage-", &driverspackagenum,
loadto, readlen);
loadto, readlen);
}
static grub_err_t
@ -720,7 +720,7 @@ grub_cmd_xnu_ramdisk (grub_command_t cmd __attribute__ ((unused)),
file = grub_gzfile_open (args[0], 1);
if (! file)
return grub_error (GRUB_ERR_FILE_NOT_FOUND,
return grub_error (GRUB_ERR_FILE_NOT_FOUND,
"Couldn't load ramdisk");
err = grub_xnu_align_heap (GRUB_XNU_PAGESIZE);
@ -728,7 +728,7 @@ grub_cmd_xnu_ramdisk (grub_command_t cmd __attribute__ ((unused)),
return err;
size = grub_file_size (file);
loadto = grub_xnu_heap_malloc (size);
if (! loadto)
return grub_errno;
@ -739,10 +739,10 @@ grub_cmd_xnu_ramdisk (grub_command_t cmd __attribute__ ((unused)),
grub_error_push ();
return grub_error (GRUB_ERR_BAD_OS, "Couldn't read file %s", args[0]);
}
return grub_xnu_register_memory ("RAMDisk", 0, loadto, size);
return grub_xnu_register_memory ("RAMDisk", 0, loadto, size);
}
/* Parse a devtree file. It uses the following format:
/* Parse a devtree file. It uses the following format:
valuename:valuedata;
keyname{
contents
@ -766,12 +766,12 @@ grub_xnu_parse_devtree (struct grub_xnu_devtree_key **parent,
if (*ptr == '}')
return ptr + 1;
namelen = 0;
/* Parse the name. */
for (ptr2 = ptr; ptr2 < end && (grub_isspace (*ptr2)
for (ptr2 = ptr; ptr2 < end && (grub_isspace (*ptr2)
|| (*ptr2 >= '0' && *ptr2 <= '9')
|| (*ptr2 >= 'a' && *ptr2 <= 'f')
|| (*ptr2 >= 'A' && *ptr2 <= 'F'));
|| (*ptr2 >= 'A' && *ptr2 <= 'F'));
ptr2++)
if (! grub_isspace (*ptr2))
namelen++;
@ -792,7 +792,7 @@ grub_xnu_parse_devtree (struct grub_xnu_devtree_key **parent,
hex = *ptr - 'a' + 10;
if (*ptr >= 'A' && *ptr <= 'F')
hex = *ptr - 'A' + 10;
if (i % 2 == 0)
name[i / 2] = hex << 4;
else
@ -806,7 +806,7 @@ grub_xnu_parse_devtree (struct grub_xnu_devtree_key **parent,
/* If it describes a key recursively invoke the function. */
if (*ptr == '{')
{
struct grub_xnu_devtree_key *newkey
struct grub_xnu_devtree_key *newkey
= grub_xnu_create_key (parent, name);
grub_free (name);
if (! newkey)
@ -820,10 +820,10 @@ grub_xnu_parse_devtree (struct grub_xnu_devtree_key **parent,
return 0;
ptr++;
datalen = 0;
for (ptr2 = ptr; ptr2 < end && (grub_isspace (*ptr2)
for (ptr2 = ptr; ptr2 < end && (grub_isspace (*ptr2)
|| (*ptr2 >= '0' && *ptr2 <= '9')
|| (*ptr2 >= 'a' && *ptr2 <= 'f')
|| (*ptr2 >= 'A' && *ptr2 <= 'F'));
|| (*ptr2 >= 'A' && *ptr2 <= 'F'));
ptr2++)
if (! grub_isspace (*ptr2))
datalen++;
@ -844,7 +844,7 @@ grub_xnu_parse_devtree (struct grub_xnu_devtree_key **parent,
hex = *ptr - 'a' + 10;
if (*ptr >= 'A' && *ptr <= 'F')
hex = *ptr - 'A' + 10;
if (i % 2 == 0)
data[i / 2] = hex << 4;
else
@ -854,7 +854,7 @@ grub_xnu_parse_devtree (struct grub_xnu_devtree_key **parent,
while (ptr < end && grub_isspace (*ptr))
ptr++;
{
struct grub_xnu_devtree_key *newkey
struct grub_xnu_devtree_key *newkey
= grub_xnu_create_value (parent, name);
grub_free (name);
if (! newkey)
@ -871,7 +871,7 @@ grub_xnu_parse_devtree (struct grub_xnu_devtree_key **parent,
return ptr;
}
/* Returns true if the kext should be loaded according to plist
/* Returns true if the kext should be loaded according to plist
and osbundlereq. Also fill BINNAME. */
static int
grub_xnu_check_os_bundle_required (char *plistname, char *osbundlereq,
@ -890,7 +890,7 @@ grub_xnu_check_os_bundle_required (char *plistname, char *osbundlereq,
file = grub_gzfile_open (plistname, 1);
if (! file)
{
grub_file_close (file);
grub_file_close (file);
grub_error_push ();
grub_error (GRUB_ERR_BAD_OS, "Couldn't read file %s", plistname);
return 0;
@ -900,26 +900,26 @@ grub_xnu_check_os_bundle_required (char *plistname, char *osbundlereq,
buf = grub_malloc (size);
if (! buf)
{
grub_file_close (file);
grub_file_close (file);
grub_error_push ();
grub_error (GRUB_ERR_OUT_OF_MEMORY, "Couldn't read file %s", plistname);
return 0;
}
if (grub_file_read (file, buf, size) != (grub_ssize_t) (size))
{
grub_file_close (file);
grub_file_close (file);
grub_error_push ();
grub_error (GRUB_ERR_BAD_OS, "Couldn't read file %s", plistname);
return 0;
}
grub_file_close (file);
grub_file_close (file);
/* Set the return value for the case when no OSBundleRequired tag is found. */
if (osbundlereq)
ret = grub_strword (osbundlereq, "all") || grub_strword (osbundlereq, "-");
else
ret = 1;
/* Parse plist. It's quite dirty and inextensible but does its job. */
for (ptr1 = buf; ptr1 < buf + size; ptr1++)
switch (*ptr1)
@ -927,17 +927,17 @@ grub_xnu_check_os_bundle_required (char *plistname, char *osbundlereq,
case '<':
tagstart = ptr1;
*ptr1 = 0;
if (keyptr && depth == 4
if (keyptr && depth == 4
&& grub_strcmp (keyptr, "OSBundleRequired") == 0)
osbundlekeyfound = 1;
if (keyptr && depth == 4 &&
if (keyptr && depth == 4 &&
grub_strcmp (keyptr, "CFBundleExecutable") == 0)
binnamekeyfound = 1;
if (stringptr && osbundlekeyfound && osbundlereq && depth == 4)
{
for (ptr2 = stringptr; *ptr2; ptr2++)
*ptr2 = grub_tolower (*ptr2);
ret = grub_strword (osbundlereq, stringptr)
ret = grub_strword (osbundlereq, stringptr)
|| grub_strword (osbundlereq, "all");
}
if (stringptr && binnamekeyfound && binname && depth == 4)
@ -968,14 +968,14 @@ grub_xnu_check_os_bundle_required (char *plistname, char *osbundlereq,
if (depth == 3 && grub_strcmp (tagstart + 1, "key") == 0)
keyptr = ptr1 + 1;
if (depth == 3 && grub_strcmp (tagstart + 1, "string") == 0)
stringptr = ptr1 + 1;
stringptr = ptr1 + 1;
else if (grub_strcmp (tagstart + 1, "/key") != 0)
{
osbundlekeyfound = 0;
binnamekeyfound = 0;
}
*ptr1 = '>';
if (tagstart[1] == '/')
depth--;
else
@ -984,12 +984,12 @@ grub_xnu_check_os_bundle_required (char *plistname, char *osbundlereq,
}
grub_free (buf);
return ret;
return ret;
}
/* Load all loadable kexts placed under DIRNAME and matching OSBUNDLEREQUIRED */
grub_err_t
grub_xnu_scan_dir_for_kexts (char *dirname, char *osbundlerequired,
grub_xnu_scan_dir_for_kexts (char *dirname, char *osbundlerequired,
int maxrecursion)
{
grub_device_t dev;
@ -997,7 +997,7 @@ grub_xnu_scan_dir_for_kexts (char *dirname, char *osbundlerequired,
grub_fs_t fs;
const char *path;
auto int load_hook (const char *filename,
auto int load_hook (const char *filename,
const struct grub_dirhook_info *info);
int load_hook (const char *filename, const struct grub_dirhook_info *info)
{
@ -1011,7 +1011,7 @@ grub_xnu_scan_dir_for_kexts (char *dirname, char *osbundlerequired,
grub_memcmp (filename + grub_strlen (filename) - 5, ".kext", 5) != 0)
return 0;
newdirname
newdirname
= grub_malloc (grub_strlen (dirname) + grub_strlen (filename) + 2);
/* It's a .kext. Try to load it. */
@ -1021,7 +1021,7 @@ grub_xnu_scan_dir_for_kexts (char *dirname, char *osbundlerequired,
newdirname[grub_strlen (newdirname) + 1] = 0;
newdirname[grub_strlen (newdirname)] = '/';
grub_strcpy (newdirname + grub_strlen (newdirname), filename);
grub_xnu_load_kext_from_dir (newdirname, osbundlerequired,
grub_xnu_load_kext_from_dir (newdirname, osbundlerequired,
maxrecursion);
if (grub_errno == GRUB_ERR_BAD_OS)
grub_errno = GRUB_ERR_NONE;
@ -1055,7 +1055,7 @@ grub_xnu_scan_dir_for_kexts (char *dirname, char *osbundlerequired,
/* Load extension DIRNAME. (extensions are directories in xnu) */
grub_err_t
grub_xnu_load_kext_from_dir (char *dirname, char *osbundlerequired,
grub_xnu_load_kext_from_dir (char *dirname, char *osbundlerequired,
int maxrecursion)
{
grub_device_t dev;
@ -1069,16 +1069,16 @@ grub_xnu_load_kext_from_dir (char *dirname, char *osbundlerequired,
int usemacos = 0;
grub_file_t binfile;
auto int load_hook (const char *filename,
auto int load_hook (const char *filename,
const struct grub_dirhook_info *info);
int load_hook (const char *filename, const struct grub_dirhook_info *info)
{
if (grub_strlen (filename) > 15)
return 0;
grub_strcpy (newdirname + grub_strlen (dirname) + 1, filename);
grub_strcpy (newdirname + grub_strlen (dirname) + 1, filename);
/* If the kext contains directory "Contents" all real stuff is in
/* If the kext contains directory "Contents" all real stuff is in
this directory. */
if (info->dir && grub_strcasecmp (filename, "Contents") == 0)
grub_xnu_load_kext_from_dir (newdirname, osbundlerequired,
@ -1086,16 +1086,16 @@ grub_xnu_load_kext_from_dir (char *dirname, char *osbundlerequired,
/* Directory "Plugins" contains nested kexts. */
if (info->dir && grub_strcasecmp (filename, "Plugins") == 0)
grub_xnu_scan_dir_for_kexts (newdirname, osbundlerequired,
grub_xnu_scan_dir_for_kexts (newdirname, osbundlerequired,
maxrecursion - 1);
/* Directory "MacOS" contains executable, otherwise executable is
/* Directory "MacOS" contains executable, otherwise executable is
on the top. */
if (info->dir && grub_strcasecmp (filename, "MacOS") == 0)
usemacos = 1;
/* Info.plist is the file which governs our future actions. */
if (! info->dir && grub_strcasecmp (filename, "Info.plist") == 0
if (! info->dir && grub_strcasecmp (filename, "Info.plist") == 0
&& ! plistname)
plistname = grub_strdup (newdirname);
return 0;
@ -1106,7 +1106,7 @@ grub_xnu_load_kext_from_dir (char *dirname, char *osbundlerequired,
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "couldn't allocate buffer");
grub_strcpy (newdirname, dirname);
newdirname[grub_strlen (dirname)] = '/';
newdirname[grub_strlen (dirname) + 1] = 0;
newdirname[grub_strlen (dirname) + 1] = 0;
device_name = grub_file_get_device_name (dirname);
dev = grub_device_open (device_name);
if (dev)
@ -1123,19 +1123,19 @@ grub_xnu_load_kext_from_dir (char *dirname, char *osbundlerequired,
newpath = newdirname;
else
newpath++;
/* Look at the directory. */
if (fs)
(fs->dir) (dev, path, load_hook);
if (plistname && grub_xnu_check_os_bundle_required
if (plistname && grub_xnu_check_os_bundle_required
(plistname, osbundlerequired, &binsuffix))
{
if (binsuffix)
{
/* Open the binary. */
char *binname = grub_malloc (grub_strlen (dirname)
+ grub_strlen (binsuffix)
char *binname = grub_malloc (grub_strlen (dirname)
+ grub_strlen (binsuffix)
+ sizeof ("/MacOS/"));
grub_strcpy (binname, dirname);
if (usemacos)
@ -1145,10 +1145,10 @@ grub_xnu_load_kext_from_dir (char *dirname, char *osbundlerequired,
grub_strcpy (binname + grub_strlen (binname), binsuffix);
grub_dprintf ("xnu", "%s:%s\n", plistname, binname);
binfile = grub_gzfile_open (binname, 1);
if (! binfile)
if (! binfile)
grub_errno = GRUB_ERR_NONE;
/* Load the extension. */
/* Load the extension. */
grub_xnu_load_driver (plistname, binfile);
grub_free (binname);
grub_free (binsuffix);
@ -1191,12 +1191,12 @@ grub_cmd_xnu_devtree (grub_command_t cmd __attribute__ ((unused)),
if (! data)
{
grub_file_close (file);
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"Could load device tree into memory");
}
if (grub_file_read (file, data, datalen) != (grub_ssize_t) datalen)
{
grub_file_close (file);
grub_file_close (file);
grub_free (data);
grub_error_push ();
return grub_error (GRUB_ERR_BAD_OS, "Couldn't read file %s", args[0]);
@ -1237,7 +1237,7 @@ grub_cmd_xnu_kext (grub_command_t cmd __attribute__ ((unused)),
}
}
return grub_xnu_load_driver (grub_strcmp (args[0], "-") ? args[0] : 0,
binfile);
binfile);
}
/* load kext normally. */
@ -1256,7 +1256,7 @@ grub_cmd_xnu_kextdir (grub_command_t cmd __attribute__ ((unused)),
return grub_error (GRUB_ERR_BAD_ARGUMENT, "directory name required");
if (argc == 1)
return grub_xnu_scan_dir_for_kexts (args[0],
return grub_xnu_scan_dir_for_kexts (args[0],
"console,root,local-root,network-root",
10);
else
@ -1264,7 +1264,7 @@ grub_cmd_xnu_kextdir (grub_command_t cmd __attribute__ ((unused)),
char *osbundlerequired = grub_strdup (args[1]), *ptr;
grub_err_t err;
if (! osbundlerequired)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"couldn't allocate string temporary space");
for (ptr = osbundlerequired; *ptr; ptr++)
*ptr = grub_tolower (*ptr);
@ -1282,8 +1282,8 @@ grub_cmd_xnu_splash (grub_command_t cmd __attribute__ ((unused)),
{
grub_err_t err;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
err = grub_video_bitmap_load (&grub_xnu_bitmap, args[0]);
if (err)
grub_xnu_bitmap = 0;
@ -1298,7 +1298,7 @@ grub_cmd_xnu_resume (grub_command_t cmd __attribute__ ((unused)),
{
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
return grub_xnu_resume (args[0]);
}
#endif
@ -1319,7 +1319,7 @@ grub_xnu_unlock ()
locked = 0;
}
static grub_command_t cmd_kernel, cmd_mkext, cmd_kext, cmd_kextdir,
static grub_command_t cmd_kernel, cmd_mkext, cmd_kext, cmd_kextdir,
cmd_ramdisk, cmd_devtree, cmd_resume, cmd_splash;
GRUB_MOD_INIT(xnu)
@ -1330,7 +1330,7 @@ GRUB_MOD_INIT(xnu)
"Load XNU extension package.");
cmd_kext = grub_register_command ("xnu_kext", grub_cmd_xnu_kext, 0,
"Load XNU extension.");
cmd_kextdir = grub_register_command ("xnu_kextdir", grub_cmd_xnu_kextdir,
cmd_kextdir = grub_register_command ("xnu_kextdir", grub_cmd_xnu_kextdir,
"xnu_kextdir DIRECTORY [OSBundleRequired]",
"Load XNU extension directory");
cmd_ramdisk = grub_register_command ("xnu_ramdisk", grub_cmd_xnu_ramdisk, 0,
@ -1342,7 +1342,7 @@ GRUB_MOD_INIT(xnu)
"Load a splash image for XNU");
#ifndef GRUB_UTIL
cmd_resume = grub_register_command ("xnu_resume", grub_cmd_xnu_resume,
cmd_resume = grub_register_command ("xnu_resume", grub_cmd_xnu_resume,
0, "Load XNU hibernate image.");
#endif
my_mod=mod;

20
loader/xnu_resume.c
View file

@ -53,13 +53,13 @@ grub_xnu_resume (char *imagename)
file = grub_file_open (imagename);
if (! file)
return 0;
/* Read the header. */
if (grub_file_read (file, (char *) &hibhead, sizeof (hibhead))
!=sizeof (hibhead))
{
grub_file_close (file);
return grub_error (GRUB_ERR_READ_ERROR,
return grub_error (GRUB_ERR_READ_ERROR,
"cannot read the hibernate header");
}
@ -67,13 +67,13 @@ grub_xnu_resume (char *imagename)
if (hibhead.magic != GRUB_XNU_HIBERNATE_MAGIC)
{
grub_file_close (file);
return grub_error (GRUB_ERR_BAD_OS,
return grub_error (GRUB_ERR_BAD_OS,
"hibernate header has incorrect magic number");
}
if (hibhead.encoffset)
{
grub_file_close (file);
return grub_error (GRUB_ERR_BAD_OS,
return grub_error (GRUB_ERR_BAD_OS,
"encrypted images aren't supported yet");
}
@ -91,19 +91,19 @@ grub_xnu_resume (char *imagename)
if (grub_xnu_hibernate_image)
grub_free (grub_xnu_hibernate_image);
/* Try to allocate necessary space.
/* Try to allocate necessary space.
FIXME: mm isn't good enough yet to handle huge allocations.
*/
grub_xnu_hibernate_image = buf = grub_malloc (hibhead.image_size);
if (! buf)
{
grub_file_close (file);
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"not enough memory to load image");
}
/* Read image. */
if (grub_file_seek (file, 0) == (grub_off_t)-1
if (grub_file_seek (file, 0) == (grub_off_t)-1
|| grub_file_read (file, buf, hibhead.image_size)
!= (grub_ssize_t) hibhead.image_size)
{
@ -123,11 +123,11 @@ grub_xnu_resume (char *imagename)
/* Prepare asm helper. */
grub_memcpy (codetmp, ((grub_uint8_t *) buf) + total_header_size, codesize);
grub_memcpy (codetmp + codesize, grub_xnu_launcher_start,
grub_xnu_launcher_end - grub_xnu_launcher_start);
grub_memcpy (codetmp + codesize, grub_xnu_launcher_start,
grub_xnu_launcher_end - grub_xnu_launcher_start);
/* We're ready now. */
grub_loader_set ((grub_err_t (*) (void)) (codetmp + codesize),
grub_loader_set ((grub_err_t (*) (void)) (codetmp + codesize),
grub_xnu_resume_unload, 0);
/* Prevent module from unloading. */