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

Improve gettext support. Stylistic fixes and error handling fixes while

Browse source 
on it.
This commit is contained in:
Vladimir 'phcoder' Serbinenko 2012-02-08 19:26:01 +01:00
parent 215c90cb82
commit 9c4b5c13e6
184 changed files with 1175 additions and 959 deletions
Download patch file Download diff file Expand all files Collapse all files

2
grub-core/loader/efi/appleloader.c
View file

@ -220,7 +220,7 @@ static grub_command_t cmd;
GRUB_MOD_INIT(appleloader)
{
cmd = grub_register_command ("appleloader", grub_cmd_appleloader,
N_("[OPTS]"), N_("Boot legacy system."));
N_("[OPTS]"), N_("Boot BIOS-based system."));
my_mod = mod;
}

9
grub-core/loader/efi/chainloader.c
View file

@ -88,9 +88,9 @@ grub_chainloader_boot (void)
grub_error (GRUB_ERR_BAD_OS, buf);
grub_free (buf);
}
else
grub_error (GRUB_ERR_BAD_OS, "unknown error");
}
else
grub_error (GRUB_ERR_BAD_OS, "unknown error");
}
if (exit_data)
@ -197,7 +197,7 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
char *filename;
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no file specified");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
filename = argv[0];
grub_dl_ref (my_mod);
@ -258,7 +258,8 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
if (grub_file_read (file, (void *) ((grub_addr_t) address), size) != size)
{
if (grub_errno == GRUB_ERR_NONE)
grub_error (GRUB_ERR_BAD_OS, "too small");
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
goto fail;
}

59
grub-core/loader/i386/bsd.c
View file

@ -107,7 +107,7 @@ static const struct grub_arg_option freebsd_opts[] =
{"nointr", 'n', 0, "", 0, 0},
{"pause", 'p', 0, N_("Wait for keypress after every line of output."), 0, 0},
{"quiet", 'q', 0, "", 0, 0},
{"dfltroot", 'r', 0, N_("Use compiled-in rootdev."), 0, 0},
{"dfltroot", 'r', 0, N_("Use compiled-in root device."), 0, 0},
{"single", 's', 0, N_("Boot into single mode."), 0, 0},
{"verbose", 'v', 0, N_("Boot with verbose messages."), 0, 0},
{0, 0, 0, 0, 0, 0}
@ -131,7 +131,11 @@ static const struct grub_arg_option openbsd_opts[] =
{"kdb", 'd', 0, N_("Enter in KDB on boot."), 0, 0},
{"root", 'r', 0, N_("Set root device."), "wdXY", ARG_TYPE_STRING},
{"serial", 'h', GRUB_ARG_OPTION_OPTIONAL,
N_("Use serial console."), N_("comUNIT[,SPEED]"), ARG_TYPE_STRING},
N_("Use serial console."),
/* TRANSLATORS: "com" is static and not to be translated. It refers to
serial ports e.g. com1.
*/
N_("comUNIT[,SPEED]"), ARG_TYPE_STRING},
{0, 0, 0, 0, 0, 0}
};
@ -157,10 +161,14 @@ static const struct grub_arg_option netbsd_opts[] =
{"single", 's', 0, N_("Boot into single mode."), 0, 0},
{"verbose", 'v', 0, N_("Boot with verbose messages."), 0, 0},
{"debug", 'x', 0, N_("Boot with debug messages."), 0, 0},
{"silent", 'z', 0, N_("Supress normal output (warnings remain)."), 0, 0},
{"silent", 'z', 0, N_("Suppress normal output (warnings remain)."), 0, 0},
{"root", 'r', 0, N_("Set root device."), N_("DEVICE"), ARG_TYPE_STRING},
{"serial", 'h', GRUB_ARG_OPTION_OPTIONAL,
N_("Use serial console."), N_("[ADDR|comUNIT][,SPEED]"), ARG_TYPE_STRING},
N_("Use serial console."),
/* TRANSLATORS: "com" is static and not to be translated. It refers to
serial ports e.g. com1.
*/
N_("[ADDR|comUNIT][,SPEED]"), ARG_TYPE_STRING},
{0, 0, 0, 0, 0, 0}
};
@ -1314,7 +1322,7 @@ grub_bsd_elf64_hook (Elf64_Phdr * phdr, grub_addr_t * addr, int *do_load)
}
static grub_err_t
grub_bsd_load_elf (grub_elf_t elf)
grub_bsd_load_elf (grub_elf_t elf, const char *filename)
{
grub_err_t err;
@ -1326,7 +1334,8 @@ grub_bsd_load_elf (grub_elf_t elf)
grub_relocator_chunk_t ch;
entry = elf->ehdr.ehdr32.e_entry & 0xFFFFFF;
err = grub_elf32_phdr_iterate (elf, grub_bsd_elf32_size_hook, NULL);
err = grub_elf32_phdr_iterate (elf, filename,
grub_bsd_elf32_size_hook, NULL);
if (err)
return err;
err = grub_relocator_alloc_chunk_addr (relocator, &ch,
@ -1336,12 +1345,12 @@ grub_bsd_load_elf (grub_elf_t elf)
kern_chunk_src = get_virtual_current_address (ch);
err = grub_elf32_load (elf, grub_bsd_elf32_hook, 0, 0);
err = grub_elf32_load (elf, filename, grub_bsd_elf32_hook, 0, 0);
if (err)
return err;
if (kernel_type != KERNEL_TYPE_OPENBSD)
return GRUB_ERR_NONE;
return grub_openbsd_find_ramdisk32 (elf->file, kern_start,
return grub_openbsd_find_ramdisk32 (elf->file, filename, kern_start,
kern_chunk_src, &openbsd_ramdisk);
}
else if (grub_elf_is_elf64 (elf))
@ -1363,7 +1372,8 @@ grub_bsd_load_elf (grub_elf_t elf)
entry_hi = 0;
}
err = grub_elf64_phdr_iterate (elf, grub_bsd_elf64_size_hook, NULL);
err = grub_elf64_phdr_iterate (elf, filename,
grub_bsd_elf64_size_hook, NULL);
if (err)
return err;
@ -1379,16 +1389,17 @@ grub_bsd_load_elf (grub_elf_t elf)
kern_chunk_src = get_virtual_current_address (ch);
}
err = grub_elf64_load (elf, grub_bsd_elf64_hook, 0, 0);
err = grub_elf64_load (elf, filename,
grub_bsd_elf64_hook, 0, 0);
if (err)
return err;
if (kernel_type != KERNEL_TYPE_OPENBSD)
return GRUB_ERR_NONE;
return grub_openbsd_find_ramdisk64 (elf->file, kern_start,
return grub_openbsd_find_ramdisk64 (elf->file, filename, kern_start,
kern_chunk_src, &openbsd_ramdisk);
}
else
return grub_error (GRUB_ERR_BAD_OS, "invalid ELF");
return grub_error (GRUB_ERR_BAD_OS, N_("invalid arch dependent ELF magic"));
}
static grub_err_t
@ -1405,7 +1416,7 @@ grub_bsd_load (int argc, char *argv[])
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
goto fail;
}
@ -1420,11 +1431,11 @@ grub_bsd_load (int argc, char *argv[])
goto fail;
}
elf = grub_elf_file (file);
elf = grub_elf_file (file, argv[0]);
if (elf)
{
is_elf_kernel = 1;
grub_bsd_load_elf (elf);
grub_bsd_load_elf (elf, argv[0]);
grub_elf_close (elf);
}
else
@ -1491,9 +1502,11 @@ grub_cmd_freebsd (grub_extcmd_context_t ctxt, int argc, char *argv[])
return grub_errno;
if (is_64bit)
err = grub_freebsd_load_elf_meta64 (relocator, file, &kern_end);
err = grub_freebsd_load_elf_meta64 (relocator, file, argv[0],
&kern_end);
else
err = grub_freebsd_load_elf_meta32 (relocator, file, &kern_end);
err = grub_freebsd_load_elf_meta32 (relocator, file, argv[0],
&kern_end);
if (err)
return err;
@ -1625,9 +1638,9 @@ grub_cmd_netbsd (grub_extcmd_context_t ctxt, int argc, char *argv[])
return grub_errno;
if (is_64bit)
err = grub_netbsd_load_elf_meta64 (relocator, file, &kern_end);
err = grub_netbsd_load_elf_meta64 (relocator, file, argv[0], &kern_end);
else
err = grub_netbsd_load_elf_meta32 (relocator, file, &kern_end);
err = grub_netbsd_load_elf_meta32 (relocator, file, argv[0], &kern_end);
if (err)
return err;
}
@ -1717,7 +1730,7 @@ grub_cmd_freebsd_loadenv (grub_command_t cmd __attribute__ ((unused)),
if (! grub_loader_is_loaded ())
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"you need to load the kernel first");
N_("you need to load the kernel first"));
if (kernel_type != KERNEL_TYPE_FREEBSD)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
@ -1725,7 +1738,7 @@ grub_cmd_freebsd_loadenv (grub_command_t cmd __attribute__ ((unused)),
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "no filename");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
goto fail;
}
@ -1950,7 +1963,7 @@ grub_cmd_freebsd_module_elf (grub_command_t cmd __attribute__ ((unused)),
if (! grub_loader_is_loaded ())
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"you need to load the kernel first");
N_("you need to load the kernel first"));
if (kernel_type != KERNEL_TYPE_FREEBSD)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
@ -1995,7 +2008,7 @@ grub_cmd_openbsd_ramdisk (grub_command_t cmd __attribute__ ((unused)),
grub_size_t size;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
if (kernel_type != KERNEL_TYPE_OPENBSD)
return grub_error (GRUB_ERR_BAD_OS, "no kOpenBSD loaded");

72
grub-core/loader/i386/bsdXX.c
View file

@ -4,11 +4,12 @@
#include <grub/elf.h>
#include <grub/misc.h>
#include <grub/i386/relocator.h>
#include <grub/i18n.h>
#define ALIGN_PAGE(a) ALIGN_UP (a, 4096)
static inline grub_err_t
load (grub_file_t file, void *where, grub_off_t off, grub_size_t size)
load (grub_file_t file, const char *filename, void *where, grub_off_t off, grub_size_t size)
{
if (grub_file_seek (file, off) == (grub_off_t) -1)
return grub_errno;
@ -16,14 +17,14 @@ load (grub_file_t file, void *where, grub_off_t off, grub_size_t size)
{
if (grub_errno)
return grub_errno;
else
return grub_error (GRUB_ERR_BAD_OS, "file is truncated");
return grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
}
return GRUB_ERR_NONE;
}
static inline grub_err_t
read_headers (grub_file_t file, Elf_Ehdr *e, char **shdr)
read_headers (grub_file_t file, const char *filename, Elf_Ehdr *e, char **shdr)
{
if (grub_file_seek (file, 0) == (grub_off_t) -1)
return grub_errno;
@ -32,8 +33,8 @@ read_headers (grub_file_t file, Elf_Ehdr *e, char **shdr)
{
if (grub_errno)
return grub_errno;
else
return grub_error (GRUB_ERR_BAD_OS, "file is too short");
return grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
}
if (e->e_ident[EI_MAG0] != ELFMAG0
@ -42,10 +43,10 @@ read_headers (grub_file_t file, Elf_Ehdr *e, char **shdr)
|| e->e_ident[EI_MAG3] != ELFMAG3
|| e->e_ident[EI_VERSION] != EV_CURRENT
|| e->e_version != EV_CURRENT)
return grub_error (GRUB_ERR_BAD_OS, "invalid arch independent ELF magic");
return grub_error (GRUB_ERR_BAD_OS, N_("invalid arch independent ELF magic"));
if (e->e_ident[EI_CLASS] != SUFFIX (ELFCLASS))
return grub_error (GRUB_ERR_BAD_OS, "invalid arch dependent ELF magic");
return grub_error (GRUB_ERR_BAD_OS, N_("invalid arch dependent ELF magic"));
*shdr = grub_malloc (e->e_shnum * e->e_shentsize);
if (! *shdr)
@ -59,8 +60,8 @@ read_headers (grub_file_t file, Elf_Ehdr *e, char **shdr)
{
if (grub_errno)
return grub_errno;
else
return grub_error (GRUB_ERR_BAD_OS, "file is truncated");
return grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
}
return GRUB_ERR_NONE;
@ -83,7 +84,7 @@ SUFFIX (grub_freebsd_load_elfmodule_obj) (struct grub_relocator *relocator,
grub_size_t chunk_size = 0;
void *chunk_src;
err = read_headers (file, &e, &shdr);
err = read_headers (file, argv[0], &e, &shdr);
if (err)
return err;
@ -131,7 +132,7 @@ SUFFIX (grub_freebsd_load_elfmodule_obj) (struct grub_relocator *relocator,
{
default:
case SHT_PROGBITS:
err = load (file, (grub_uint8_t *) chunk_src + curload - *kern_end,
err = load (file, argv[0], (grub_uint8_t *) chunk_src + curload - *kern_end,
s->sh_offset, s->sh_size);
if (err)
return err;
@ -176,7 +177,7 @@ SUFFIX (grub_freebsd_load_elfmodule) (struct grub_relocator *relocator,
grub_size_t chunk_size = 0;
void *chunk_src;
err = read_headers (file, &e, &shdr);
err = read_headers (file, argv[0], &e, &shdr);
if (err)
return err;
@ -229,7 +230,8 @@ SUFFIX (grub_freebsd_load_elfmodule) (struct grub_relocator *relocator,
{
default:
case SHT_PROGBITS:
err = load (file, (grub_uint8_t *) chunk_src + module
err = load (file, argv[0],
(grub_uint8_t *) chunk_src + module
+ s->sh_addr - *kern_end,
s->sh_offset, s->sh_size);
if (err)
@ -244,16 +246,16 @@ SUFFIX (grub_freebsd_load_elfmodule) (struct grub_relocator *relocator,
curload = module + s->sh_addr + s->sh_size;
}
load (file, (grub_uint8_t *) chunk_src + module - *kern_end, 0, sizeof (e));
load (file, argv[0], (grub_uint8_t *) chunk_src + module - *kern_end, 0, sizeof (e));
if (curload < module + sizeof (e))
curload = module + sizeof (e);
load (file, (grub_uint8_t *) chunk_src + curload - *kern_end, e.e_shoff,
load (file, argv[0], (grub_uint8_t *) chunk_src + curload - *kern_end, e.e_shoff,
e.e_shnum * e.e_shentsize);
e.e_shoff = curload - module;
curload += e.e_shnum * e.e_shentsize;
load (file, (grub_uint8_t *) chunk_src + curload - *kern_end, e.e_phoff,
load (file, argv[0], (grub_uint8_t *) chunk_src + curload - *kern_end, e.e_phoff,
e.e_phnum * e.e_phentsize);
e.e_phoff = curload - module;
curload += e.e_phnum * e.e_phentsize;
@ -263,14 +265,16 @@ SUFFIX (grub_freebsd_load_elfmodule) (struct grub_relocator *relocator,
grub_freebsd_add_meta_module (argv[0], FREEBSD_MODTYPE_ELF_MODULE,
argc - 1, argv + 1, module,
curload - module);
return SUFFIX (grub_freebsd_load_elf_meta) (relocator, file, kern_end);
return SUFFIX (grub_freebsd_load_elf_meta) (relocator, file, argv[0], kern_end);
}
#endif
grub_err_t
SUFFIX (grub_freebsd_load_elf_meta) (struct grub_relocator *relocator,
grub_file_t file, grub_addr_t *kern_end)
grub_file_t file,
const char *filename,
grub_addr_t *kern_end)
{
grub_err_t err;
Elf_Ehdr e;
@ -286,7 +290,7 @@ SUFFIX (grub_freebsd_load_elf_meta) (struct grub_relocator *relocator,
unsigned i;
grub_size_t chunk_size;
err = read_headers (file, &e, &shdr);
err = read_headers (file, filename, &e, &shdr);
if (err)
return err;
@ -303,7 +307,7 @@ SUFFIX (grub_freebsd_load_elf_meta) (struct grub_relocator *relocator,
break;
if (s >= (Elf_Shdr *) ((char *) shdr
+ e.e_shnum * e.e_shentsize))
return grub_error (GRUB_ERR_BAD_OS, "no symbol table");
return grub_error (GRUB_ERR_BAD_OS, N_("no symbol table"));
symoff = s->sh_offset;
symsize = s->sh_size;
symentsize = s->sh_entsize;
@ -338,7 +342,8 @@ SUFFIX (grub_freebsd_load_elf_meta) (struct grub_relocator *relocator,
if (grub_file_read (file, curload, symsize) != (grub_ssize_t) symsize)
{
if (! grub_errno)
return grub_error (GRUB_ERR_BAD_OS, "invalid ELF");
return grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
return grub_errno;
}
curload += symsize;
@ -351,7 +356,8 @@ SUFFIX (grub_freebsd_load_elf_meta) (struct grub_relocator *relocator,
if (grub_file_read (file, curload, strsize) != (grub_ssize_t) strsize)
{
if (! grub_errno)
return grub_error (GRUB_ERR_BAD_OS, "invalid ELF");
return grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
return grub_errno;
}
@ -394,7 +400,8 @@ SUFFIX (grub_freebsd_load_elf_meta) (struct grub_relocator *relocator,
grub_err_t
SUFFIX (grub_netbsd_load_elf_meta) (struct grub_relocator *relocator,
grub_file_t file, grub_addr_t *kern_end)
grub_file_t file, const char *filename,
grub_addr_t *kern_end)
{
grub_err_t err;
Elf_Ehdr e;
@ -408,7 +415,7 @@ SUFFIX (grub_netbsd_load_elf_meta) (struct grub_relocator *relocator,
struct grub_netbsd_btinfo_symtab symtab;
grub_addr_t symtarget;
err = read_headers (file, &e, &shdr);
err = read_headers (file, filename, &e, &shdr);
if (err)
return err;
@ -479,7 +486,8 @@ SUFFIX (grub_netbsd_load_elf_meta) (struct grub_relocator *relocator,
if (grub_file_read (file, curload, symsize) != (grub_ssize_t) symsize)
{
if (! grub_errno)
return grub_error (GRUB_ERR_BAD_OS, "invalid ELF");
return grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
return grub_errno;
}
curload += ALIGN_UP (symsize, sizeof (grub_freebsd_addr_t));
@ -489,7 +497,8 @@ SUFFIX (grub_netbsd_load_elf_meta) (struct grub_relocator *relocator,
if (grub_file_read (file, curload, strsize) != (grub_ssize_t) strsize)
{
if (! grub_errno)
return grub_error (GRUB_ERR_BAD_OS, "invalid ELF");
return grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
return grub_errno;
}
@ -506,6 +515,7 @@ SUFFIX (grub_netbsd_load_elf_meta) (struct grub_relocator *relocator,
grub_err_t
SUFFIX(grub_openbsd_find_ramdisk) (grub_file_t file,
const char *filename,
grub_addr_t kern_start,
void *kern_chunk_src,
struct grub_openbsd_ramdisk_descriptor *desc)
@ -518,7 +528,7 @@ SUFFIX(grub_openbsd_find_ramdisk) (grub_file_t file,
Elf_Shdr *s;
char *shdr = NULL;
err = read_headers (file, &e, &shdr);
err = read_headers (file, filename, &e, &shdr);
if (err)
return err;
@ -560,7 +570,8 @@ SUFFIX(grub_openbsd_find_ramdisk) (grub_file_t file,
{
grub_free (syms);
if (! grub_errno)
return grub_error (GRUB_ERR_BAD_OS, "invalid ELF");
return grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
return grub_errno;
}
@ -578,7 +589,8 @@ SUFFIX(grub_openbsd_find_ramdisk) (grub_file_t file,
grub_free (syms);
grub_free (strs);
if (! grub_errno)
return grub_error (GRUB_ERR_BAD_OS, "invalid ELF");
return grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
return grub_errno;
}

13
grub-core/loader/i386/coreboot/chainloader.c
View file

@ -88,7 +88,7 @@ grub_cmd_chain (grub_command_t cmd __attribute__ ((unused)),
grub_elf_t elf;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "filename expected");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
grub_loader_unset ();
@ -103,7 +103,7 @@ grub_cmd_chain (grub_command_t cmd __attribute__ ((unused)),
return grub_errno;
}
elf = grub_elf_file (file);
elf = grub_elf_file (file, argv[0]);
if (!elf)
{
grub_relocator_unload (relocator);
@ -120,7 +120,7 @@ grub_cmd_chain (grub_command_t cmd __attribute__ ((unused)),
entry = elf->ehdr.ehdr32.e_entry & 0xFFFFFF;
err = grub_elf32_load (elf, grub_chain_elf32_hook, 0, 0);
err = grub_elf32_load (elf, argv[0], grub_chain_elf32_hook, 0, 0);
grub_elf_close (elf);
if (err)
@ -135,7 +135,12 @@ static grub_command_t cmd_chain;
GRUB_MOD_INIT (chain)
{
cmd_chain = grub_register_command ("chainloader", grub_cmd_chain,
N_("FILE"), N_("Load another payload"));
N_("FILE"),
/* TRANSLATORS: "payload" is a term used
by coreboot and must be translated in
sync with coreboot. If unsure,
let it untranslated. */
N_("Load another coreboot payload"));
}
GRUB_MOD_FINI (chain)

12
grub-core/loader/i386/linux.c
View file

@ -639,7 +639,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
goto fail;
}
@ -650,7 +650,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
if (grub_file_read (file, &lh, sizeof (lh)) != sizeof (lh))
{
if (!grub_errno)
grub_error (GRUB_ERR_READ_ERROR, N_("premature end of file %s"),
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
argv[0]);
goto fail;
}
@ -720,7 +720,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
if (grub_file_read (file, (char *) real_mode_mem + sizeof (lh), len) != len)
{
if (!grub_errno)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
argv[0]);
goto fail;
}
@ -913,7 +913,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
len = prot_size;
if (grub_file_read (file, prot_mode_mem, len) != len && !grub_errno)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
argv[0]);
if (grub_errno == GRUB_ERR_NONE)
@ -953,13 +953,13 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "no module specified");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
goto fail;
}
if (! loaded)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "you need to load the kernel first");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("you need to load the kernel first"));
goto fail;
}

10
grub-core/loader/i386/multiboot_mbi.c
View file

@ -34,6 +34,7 @@
#include <grub/video.h>
#include <grub/file.h>
#include <grub/net.h>
#include <grub/i18n.h>
/* The bits in the required part of flags field we don't support. */
#define UNSUPPORTED_FLAGS 0x0000fff8
@ -60,7 +61,7 @@ static void *elf_sections;
grub_err_t
grub_multiboot_load (grub_file_t file)
grub_multiboot_load (grub_file_t file, const char *filename)
{
char *buffer;
grub_ssize_t len;
@ -75,7 +76,10 @@ grub_multiboot_load (grub_file_t file)
if (len < 32)
{
grub_free (buffer);
return grub_error (GRUB_ERR_BAD_OS, "file too small");
if (!grub_errno)
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
return grub_errno;
}
/* Look for the multiboot header in the buffer. The header should
@ -149,7 +153,7 @@ grub_multiboot_load (grub_file_t file)
}
else
{
err = grub_multiboot_load_elf (file, buffer);
err = grub_multiboot_load_elf (file, filename, buffer);
if (err)
{
grub_free (buffer);

11
grub-core/loader/i386/pc/chainloader.c
View file

@ -182,8 +182,9 @@ grub_chainloader_cmd (const char *filename, grub_chainloader_flags_t flags)
if (grub_file_read (file, bs, GRUB_DISK_SECTOR_SIZE)
!= GRUB_DISK_SECTOR_SIZE)
{
if (grub_errno == GRUB_ERR_NONE)
grub_error (GRUB_ERR_BAD_OS, "too small");
if (!grub_errno)
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
goto fail;
}
@ -270,9 +271,9 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
}
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no file specified");
else
grub_chainloader_cmd (argv[0], flags);
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
grub_chainloader_cmd (argv[0], flags);
return grub_errno;
}

2
grub-core/loader/i386/pc/freedos.c
View file

@ -83,7 +83,7 @@ grub_cmd_freedos (grub_command_t cmd __attribute__ ((unused)),
grub_size_t kernelsyssize;
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no file specified");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
grub_dl_ref (my_mod);

12
grub-core/loader/i386/pc/linux.c
View file

@ -98,7 +98,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
goto fail;
}
@ -109,7 +109,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
if (grub_file_read (file, &lh, sizeof (lh)) != sizeof (lh))
{
if (!grub_errno)
grub_error (GRUB_ERR_READ_ERROR, N_("premature end of file %s"),
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
argv[0]);
goto fail;
}
@ -286,7 +286,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
if (grub_file_read (file, grub_linux_real_chunk + sizeof (lh), len) != len)
{
if (!grub_errno)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
argv[0]);
goto fail;
}
@ -326,7 +326,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
len = grub_linux16_prot_size;
if (grub_file_read (file, grub_linux_prot_chunk, grub_linux16_prot_size)
!= (grub_ssize_t) grub_linux16_prot_size && !grub_errno)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
argv[0]);
if (grub_errno == GRUB_ERR_NONE)
@ -366,13 +366,13 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "no module specified");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
goto fail;
}
if (!loaded)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "you need to load the kernel first");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("you need to load the kernel first"));
goto fail;
}

2
grub-core/loader/i386/pc/ntldr.c
View file

@ -82,7 +82,7 @@ grub_cmd_ntldr (grub_command_t cmd __attribute__ ((unused)),
grub_device_t dev;
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no file specified");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
grub_dl_ref (my_mod);

23
grub-core/loader/i386/pc/plan9.c
View file

@ -340,7 +340,7 @@ grub_cmd_plan9 (grub_extcmd_context_t ctxt, int argc, char *argv[])
}
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no file specified");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
grub_dl_ref (my_mod);
@ -384,7 +384,12 @@ grub_cmd_plan9 (grub_extcmd_context_t ctxt, int argc, char *argv[])
goto fail;
if (grub_file_read (file, &hdr, sizeof (hdr)) != (grub_ssize_t) sizeof (hdr))
goto fail;
{
if (!grub_errno)
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
argv[0]);
goto fail;
}
if (grub_be_to_cpu32 (hdr.magic) != GRUB_PLAN9_MAGIC
|| hdr.zero)
@ -462,7 +467,12 @@ grub_cmd_plan9 (grub_extcmd_context_t ctxt, int argc, char *argv[])
if (grub_file_read (file, ptr, grub_be_to_cpu32 (hdr.text_size))
!= (grub_ssize_t) grub_be_to_cpu32 (hdr.text_size))
goto fail;
{
if (!grub_errno)
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
argv[0]);
goto fail;
}
ptr += grub_be_to_cpu32 (hdr.text_size);
padsize = ALIGN_UP (grub_be_to_cpu32 (hdr.text_size) + sizeof (hdr),
GRUB_PLAN9_ALIGN) - grub_be_to_cpu32 (hdr.text_size)
@ -473,7 +483,12 @@ grub_cmd_plan9 (grub_extcmd_context_t ctxt, int argc, char *argv[])
if (grub_file_read (file, ptr, grub_be_to_cpu32 (hdr.data_size))
!= (grub_ssize_t) grub_be_to_cpu32 (hdr.data_size))
goto fail;
{
if (!grub_errno)
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
argv[0]);
goto fail;
}
ptr += grub_be_to_cpu32 (hdr.data_size);
padsize = ALIGN_UP (grub_be_to_cpu32 (hdr.data_size), GRUB_PLAN9_ALIGN)
- grub_be_to_cpu32 (hdr.data_size);

2
grub-core/loader/i386/pc/pxechainloader.c
View file

@ -91,7 +91,7 @@ grub_cmd_pxechain (grub_command_t cmd __attribute__ ((unused)),
char *fname;
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no file specified");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
grub_dl_ref (my_mod);

23
grub-core/loader/i386/xnu.c
View file

@ -534,12 +534,11 @@ grub_cmd_devprop_load (grub_command_t cmd __attribute__ ((unused)),
unsigned i, j;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
file = grub_file_open (args[0]);
if (! file)
return grub_error (GRUB_ERR_FILE_NOT_FOUND,
"couldn't load device-properties dump");
return grub_errno;
size = grub_file_size (file);
buf = grub_malloc (size);
if (!buf)
@ -849,7 +848,6 @@ static grub_err_t
grub_xnu_set_video (struct grub_xnu_boot_params *params)
{
struct grub_video_mode_info mode_info;
int ret;
char *tmp;
const char *modevar;
void *framebuffer;
@ -878,9 +876,9 @@ grub_xnu_set_video (struct grub_xnu_boot_params *params)
if (err)
return err;
ret = grub_video_get_info (&mode_info);
if (ret)
return grub_error (GRUB_ERR_IO, "couldn't retrieve video parameters");
err = grub_video_get_info (&mode_info);
if (err)
return err;
if (grub_xnu_bitmap)
{
@ -932,9 +930,9 @@ grub_xnu_set_video (struct grub_xnu_boot_params *params)
bitmap = 0;
}
ret = grub_video_get_info_and_fini (&mode_info, &framebuffer);
if (ret)
return grub_error (GRUB_ERR_IO, "couldn't retrieve video parameters");
err = grub_video_get_info_and_fini (&mode_info, &framebuffer);
if (err)
return err;
params->lfb_width = mode_info.width;
params->lfb_height = mode_info.height;
@ -1129,7 +1127,10 @@ grub_cpu_xnu_init (void)
{
cmd_devprop_load = grub_register_command ("xnu_devprop_load",
grub_cmd_devprop_load,
0, N_("Load device-properties dump."));
/* TRANSLATORS: `device-properties'
is a variable name,
not a program. */
0, N_("Load `device-properties' dump."));
}
void

26
grub-core/loader/ia64/efi/linux.c
View file

@ -134,18 +134,19 @@ query_fpswa (void)
bs = grub_efi_system_table->boot_services;
status = bs->locate_handle (GRUB_EFI_BY_PROTOCOL,
(void *)&fpswa_protocol,
(void *) &fpswa_protocol,
NULL, &size, &fpswa_image);
if (status != GRUB_EFI_SUCCESS)
{
grub_printf (_("Could not locate FPSWA driver\n"));
grub_printf ("%s\n", _("Could not locate FPSWA driver"));
return;
}
status = bs->handle_protocol (fpswa_image,
(void *)&fpswa_protocol, (void *)&fpswa);
(void *) &fpswa_protocol, (void *) &fpswa);
if (status != GRUB_EFI_SUCCESS)
{
grub_printf (_("Fpswa protocol not able find the interface\n"));
grub_printf ("%s\n",
_("FPSWA protocol wasn't able to find the interface"));
return;
}
}
@ -481,8 +482,7 @@ grub_load_elf64 (grub_file_t file, void *buffer, const char *filename)
phdr->p_memsz, phdr->p_offset, phdr->p_flags);
if (grub_file_seek (file, phdr->p_offset) == (grub_off_t)-1)
return grub_error (GRUB_ERR_BAD_OS,
"invalid offset in program header");
return grub_errno;
if (grub_file_read (file, (void *) (phdr->p_paddr + reloc_offset),
phdr->p_filesz)
@ -525,7 +525,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "No kernel specified");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
goto fail;
}
@ -536,7 +536,9 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
len = grub_file_read (file, buffer, sizeof (buffer));
if (len < (grub_ssize_t) sizeof (Elf64_Ehdr))
{
grub_error (GRUB_ERR_BAD_OS, "File too small");
if (!grub_errno)
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
argv[0]);
goto fail;
}
@ -601,13 +603,13 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "No filename specified");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
goto fail;
}
if (! loaded)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "You need to load the kernel first.");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("you need to load the kernel first"));
goto fail;
}
@ -671,14 +673,14 @@ grub_cmd_payload (grub_command_t cmd __attribute__ ((unused)),
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "No module specified");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
goto fail;
}
if (!boot_param)
{
grub_error (GRUB_ERR_BAD_ARGUMENT,
"You need to load the kernel first");
N_("you need to load the kernel first"));
goto fail;
}

21
grub-core/loader/macho.c
View file

@ -28,6 +28,7 @@
#include <grub/file.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/i18n.h>
grub_err_t
grub_macho_close (grub_macho_t macho)
@ -46,7 +47,7 @@ grub_macho_close (grub_macho_t macho)
}
grub_macho_t
grub_macho_file (grub_file_t file)
grub_macho_file (grub_file_t file, const char *filename)
{
grub_macho_t macho;
union grub_macho_filestart filestart;
@ -69,8 +70,9 @@ grub_macho_file (grub_file_t file)
if (grub_file_read (macho->file, &filestart, sizeof (filestart))
!= sizeof (filestart))
{
grub_error_push ();
grub_error (GRUB_ERR_READ_ERROR, "cannot read Mach-O header");
if (!grub_errno)
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
goto fail;
}
@ -90,11 +92,12 @@ grub_macho_file (grub_file_t file)
goto fail;
if (grub_file_read (macho->file, archs,
sizeof (struct grub_macho_fat_arch) * narchs)
!= (grub_ssize_t)sizeof(struct grub_macho_fat_arch) * narchs)
!= (grub_ssize_t) sizeof(struct grub_macho_fat_arch) * narchs)
{
grub_free (archs);
grub_error_push ();
grub_error (GRUB_ERR_READ_ERROR, "cannot read Mach-O header");
if (!grub_errno)
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
goto fail;
}
@ -132,8 +135,8 @@ grub_macho_file (grub_file_t file)
macho->end64 = grub_file_size (file);
}
grub_macho_parse32 (macho);
grub_macho_parse64 (macho);
grub_macho_parse32 (macho, filename);
grub_macho_parse64 (macho, filename);
return macho;
@ -152,7 +155,7 @@ grub_macho_open (const char *name)
if (! file)
return 0;
macho = grub_macho_file (file);
macho = grub_macho_file (file, name);
if (! macho)
grub_file_close (file);

55
grub-core/loader/machoXX.c
View file

@ -2,6 +2,7 @@
#include <grub/file.h>
#include <grub/mm.h>
#include <grub/misc.h>
#include <grub/i18n.h>
#define min(a,b) (((a) < (b)) ? (a) : (b))
@ -12,7 +13,7 @@ SUFFIX (grub_macho_contains_macho) (grub_macho_t macho)
}
void
SUFFIX (grub_macho_parse) (grub_macho_t macho)
SUFFIX (grub_macho_parse) (grub_macho_t macho, const char *filename)
{
grub_macho_header_t head;
@ -25,7 +26,9 @@ SUFFIX (grub_macho_parse) (grub_macho_t macho)
|| grub_file_read (macho->file, &head, sizeof (head))
!= sizeof(head))
{
grub_error (GRUB_ERR_READ_ERROR, "cannot read Mach-O header");
if (!grub_errno)
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
macho->offsetXX = -1;
return;
}
@ -41,15 +44,14 @@ SUFFIX (grub_macho_parse) (grub_macho_t macho)
macho->cmdsizeXX = head.sizeofcmds;
macho->cmdsXX = grub_malloc(macho->cmdsizeXX);
if (! macho->cmdsXX)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY, "not enough memory to read commands");
return;
}
return;
if (grub_file_read (macho->file, macho->cmdsXX,
(grub_size_t) macho->cmdsizeXX)
!= (grub_ssize_t) macho->cmdsizeXX)
{
grub_error (GRUB_ERR_READ_ERROR, "cannot read Mach-O header");
if (!grub_errno)
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
macho->offsetXX = -1;
}
}
@ -87,7 +89,9 @@ SUFFIX (grub_macho_filesize) (grub_macho_t macho)
}
grub_err_t
SUFFIX (grub_macho_readfile) (grub_macho_t macho, void *dest)
SUFFIX (grub_macho_readfile) (grub_macho_t macho,
const char *filename,
void *dest)
{
grub_ssize_t read;
if (! SUFFIX (grub_macho_contains_macho) (macho))
@ -95,19 +99,16 @@ SUFFIX (grub_macho_readfile) (grub_macho_t macho, void *dest)
"couldn't read architecture-specific part");
if (grub_file_seek (macho->file, macho->offsetXX) == (grub_off_t) -1)
{
grub_error_push ();
return grub_error (GRUB_ERR_BAD_OS,
"invalid offset in program header");
}
return grub_errno;
read = grub_file_read (macho->file, dest,
macho->endXX - macho->offsetXX);
if (read != (grub_ssize_t) (macho->endXX - macho->offsetXX))
{
grub_error_push ();
return grub_error (GRUB_ERR_BAD_OS,
"couldn't read architecture-specific part");
if (!grub_errno)
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
return grub_errno;
}
return GRUB_ERR_NONE;
}
@ -162,9 +163,9 @@ SUFFIX (grub_macho_size) (grub_macho_t macho, grub_macho_addr_t *segments_start,
/* Load every loadable segment into memory specified by `_load_hook'. */
grub_err_t
SUFFIX (grub_macho_load) (grub_macho_t macho, char *offset, int flags)
SUFFIX (grub_macho_load) (grub_macho_t macho, const char *filename,
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,
void *_arg __attribute__ ((unused)));
@ -184,12 +185,7 @@ SUFFIX (grub_macho_load) (grub_macho_t macho, char *offset, int flags)
if (grub_file_seek (_macho->file, hdr->fileoff
+ _macho->offsetXX) == (grub_off_t) -1)
{
grub_error_push ();
grub_error (GRUB_ERR_BAD_OS,
"invalid offset in program header");
return 1;
}
return 1;
if (hdr->filesize)
{
@ -199,11 +195,10 @@ SUFFIX (grub_macho_load) (grub_macho_t macho, char *offset, int flags)
if (read != (grub_ssize_t) min (hdr->filesize, hdr->vmsize))
{
/* XXX How can we free memory from `load_hook'? */
grub_error_push ();
err=grub_error (GRUB_ERR_BAD_OS,
"couldn't read segment from file: "
"wanted 0x%lx bytes; read 0x%lx bytes",
hdr->filesize, read);
if (!grub_errno)
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename);
return 1;
}
}
@ -216,7 +211,7 @@ SUFFIX (grub_macho_load) (grub_macho_t macho, char *offset, int flags)
grub_macho_cmds_iterate (macho, do_load, 0);
return err;
return grub_errno;
}
grub_macho_addr_t

28
grub-core/loader/mips/linux.c
View file

@ -132,7 +132,8 @@ grub_linux_unload (void)
}
static grub_err_t
grub_linux_load32 (grub_elf_t elf, void **extra_mem, grub_size_t extra_size)
grub_linux_load32 (grub_elf_t elf, const char *filename,
void **extra_mem, grub_size_t extra_size)
{
Elf32_Addr base;
int extraoff;
@ -141,7 +142,7 @@ grub_linux_load32 (grub_elf_t elf, void **extra_mem, grub_size_t extra_size)
/* Linux's entry point incorrectly contains a virtual address. */
entry_addr = elf->ehdr.ehdr32.e_entry;
linux_size = grub_elf32_size (elf, &base, 0);
linux_size = grub_elf32_size (elf, filename, &base, 0);
if (linux_size == 0)
return grub_errno;
target_addr = base;
@ -183,11 +184,12 @@ grub_linux_load32 (grub_elf_t elf, void **extra_mem, grub_size_t extra_size)
*addr = (grub_addr_t) (phdr->p_paddr - base + playground);
return 0;
}
return grub_elf32_load (elf, offset_phdr, 0, 0);
return grub_elf32_load (elf, filename, offset_phdr, 0, 0);
}
static grub_err_t
grub_linux_load64 (grub_elf_t elf, void **extra_mem, grub_size_t extra_size)
grub_linux_load64 (grub_elf_t elf, const char *filename,
void **extra_mem, grub_size_t extra_size)
{
Elf64_Addr base;
int extraoff;
@ -196,7 +198,7 @@ grub_linux_load64 (grub_elf_t elf, void **extra_mem, grub_size_t extra_size)
/* Linux's entry point incorrectly contains a virtual address. */
entry_addr = elf->ehdr.ehdr64.e_entry;
linux_size = grub_elf64_size (elf, &base, 0);
linux_size = grub_elf64_size (elf, filename, &base, 0);
if (linux_size == 0)
return grub_errno;
target_addr = base;
@ -237,7 +239,7 @@ grub_linux_load64 (grub_elf_t elf, void **extra_mem, grub_size_t extra_size)
*addr = (grub_addr_t) (phdr->p_paddr - base + playground);
return 0;
}
return grub_elf64_load (elf, offset_phdr, 0, 0);
return grub_elf64_load (elf, filename, offset_phdr, 0, 0);
}
static grub_err_t
@ -259,7 +261,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
#endif
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
elf = grub_elf_open (argv[0]);
if (! elf)
@ -269,7 +271,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
{
grub_elf_close (elf);
return grub_error (GRUB_ERR_UNKNOWN_OS,
"this ELF file is not of the right type\n");
N_("this ELF file is not of the right type"));
}
/* Release the previously used memory. */
@ -314,12 +316,12 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
#endif
if (grub_elf_is_elf32 (elf))
err = grub_linux_load32 (elf, &extra, size);
err = grub_linux_load32 (elf, argv[0], &extra, size);
else
if (grub_elf_is_elf64 (elf))
err = grub_linux_load64 (elf, &extra, size);
err = grub_linux_load64 (elf, argv[0], &extra, size);
else
err = grub_error (GRUB_ERR_BAD_FILE_TYPE, "unknown ELF class");
err = grub_error (GRUB_ERR_BAD_OS, N_("invalid arch dependent ELF magic"));
grub_elf_close (elf);
@ -445,10 +447,10 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
grub_uint8_t *ptr;
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no initrd specified");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
if (!loaded)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "you need to load Linux first.");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("you need to load the kernel first"));
if (initrd_loaded)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "only one initrd command can be issued.");

19
grub-core/loader/multiboot.c
View file

@ -159,14 +159,15 @@ grub_multiboot_unload (void)
/* Load ELF32 or ELF64. */
grub_err_t
grub_multiboot_load_elf (grub_file_t file, void *buffer)
grub_multiboot_load_elf (grub_file_t file, const char *filename,
void *buffer)
{
if (grub_multiboot_is_elf32 (buffer))
return grub_multiboot_load_elf32 (file, buffer);
return grub_multiboot_load_elf32 (file, filename, buffer);
else if (grub_multiboot_is_elf64 (buffer))
return grub_multiboot_load_elf64 (file, buffer);
return grub_multiboot_load_elf64 (file, filename, buffer);
return grub_error (GRUB_ERR_UNKNOWN_OS, "unknown ELF class");
return grub_error (GRUB_ERR_UNKNOWN_OS, N_("invalid arch dependent ELF magic"));
}
grub_err_t
@ -222,7 +223,7 @@ grub_cmd_multiboot (grub_command_t cmd __attribute__ ((unused)),
grub_loader_unset ();
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
file = grub_file_open (argv[0]);
if (! file)
@ -239,7 +240,7 @@ grub_cmd_multiboot (grub_command_t cmd __attribute__ ((unused)),
if (!grub_multiboot_relocator)
goto fail;
err = grub_multiboot_load (file);
err = grub_multiboot_load (file, argv[0]);
if (err)
goto fail;
@ -273,7 +274,7 @@ grub_cmd_module (grub_command_t cmd __attribute__ ((unused)),
int nounzip = 0;
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no module specified");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
if (grub_strcmp (argv[0], "--nounzip") == 0)
{
@ -283,11 +284,11 @@ grub_cmd_module (grub_command_t cmd __attribute__ ((unused)),
}
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no module specified");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
if (!grub_multiboot_relocator)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"you need to load the multiboot kernel first");
N_("you need to load the kernel first"));
if (nounzip)
grub_file_filter_disable_compression ();

50
grub-core/loader/multiboot_elfxx.c
View file

@ -49,26 +49,25 @@ CONCAT(grub_multiboot_is_elf, XX) (void *buffer)
}
static grub_err_t
CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, void *buffer)
CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, const char *filename, void *buffer)
{
Elf_Ehdr *ehdr = (Elf_Ehdr *) buffer;
char *phdr_base;
int i;
if (ehdr->e_ident[EI_CLASS] != ELFCLASSXX)
return grub_error (GRUB_ERR_UNKNOWN_OS, "invalid ELF class");
if (ehdr->e_ident[EI_MAG0] != ELFMAG0
|| ehdr->e_ident[EI_MAG1] != ELFMAG1
|| ehdr->e_ident[EI_MAG2] != ELFMAG2
|| ehdr->e_ident[EI_MAG3] != ELFMAG3
|| ehdr->e_version != EV_CURRENT
|| ehdr->e_ident[EI_DATA] != ELFDATA2LSB
|| ehdr->e_machine != E_MACHINE)
return grub_error(GRUB_ERR_UNKNOWN_OS, "no valid ELF header found");
|| ehdr->e_ident[EI_DATA] != ELFDATA2LSB)
return grub_error(GRUB_ERR_UNKNOWN_OS, N_("invalid arch independent ELF magic"));
if (ehdr->e_ident[EI_CLASS] != ELFCLASSXX || ehdr->e_machine != E_MACHINE
|| ehdr->e_version != EV_CURRENT)
return grub_error (GRUB_ERR_UNKNOWN_OS, N_("invalid arch dependent ELF magic"));
if (ehdr->e_type != ET_EXEC && ehdr->e_type != ET_DYN)
return grub_error (GRUB_ERR_UNKNOWN_OS, "invalid ELF file type");
return grub_error (GRUB_ERR_UNKNOWN_OS, N_("this ELF file is not of the right type"));
/* FIXME: Should we support program headers at strange locations? */
if (ehdr->e_phoff + ehdr->e_phnum * ehdr->e_phentsize > MULTIBOOT_SEARCH)
@ -115,13 +114,16 @@ CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, void *buffer)
{
if (grub_file_seek (file, (grub_off_t) phdr(i)->p_offset)
== (grub_off_t) -1)
return grub_error (GRUB_ERR_BAD_OS,
"invalid offset in program header");
return grub_errno;
if (grub_file_read (file, source, phdr(i)->p_filesz)
!= (grub_ssize_t) phdr(i)->p_filesz)
return grub_error (GRUB_ERR_BAD_OS,
"couldn't read segment from file");
{
if (!grub_errno)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
filename);
return grub_errno;
}
}
if (phdr(i)->p_filesz < phdr(i)->p_memsz)
@ -159,13 +161,16 @@ CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, void *buffer)
return grub_errno;
if (grub_file_seek (file, ehdr->e_shoff) == (grub_off_t) -1)
return grub_error (GRUB_ERR_BAD_OS,
"invalid offset to section headers");
return grub_errno;
if (grub_file_read (file, shdr, ehdr->e_shnum * ehdr->e_shentsize)
!= (grub_ssize_t) ehdr->e_shnum * ehdr->e_shentsize)
return grub_error (GRUB_ERR_BAD_OS,
"couldn't read sections headers from file");
{
if (!grub_errno)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
filename);
return grub_errno;
}
for (shdrptr = shdr, i = 0; i < ehdr->e_shnum;
shdrptr += ehdr->e_shentsize, i++)
@ -202,13 +207,16 @@ CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, void *buffer)
}
if (grub_file_seek (file, sh->sh_offset) == (grub_off_t) -1)
return grub_error (GRUB_ERR_BAD_OS,
"invalid offset in section header");
return grub_errno;
if (grub_file_read (file, src, sh->sh_size)
!= (grub_ssize_t) sh->sh_size)
return grub_error (GRUB_ERR_BAD_OS,
"couldn't read segment from file");
{
if (!grub_errno)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
filename);
return grub_errno;
}
sh->sh_addr = target;
}
grub_multiboot_add_elfsyms (ehdr->e_shnum, ehdr->e_shentsize,

4
grub-core/loader/multiboot_mbi2.c
View file

@ -76,7 +76,7 @@ grub_multiboot_add_elfsyms (grub_size_t num, grub_size_t entsize,
}
grub_err_t
grub_multiboot_load (grub_file_t file)
grub_multiboot_load (grub_file_t file, const char *filename)
{
grub_properly_aligned_t *buffer;
grub_ssize_t len;
@ -255,7 +255,7 @@ grub_multiboot_load (grub_file_t file)
}
else
{
err = grub_multiboot_load_elf (file, buffer);
err = grub_multiboot_load_elf (file, filename, buffer);
if (err)
{
grub_free (buffer);

26
grub-core/loader/powerpc/ieee1275/linux.c
View file

@ -151,7 +151,7 @@ grub_linux_unload (void)
}
static grub_err_t
grub_linux_load32 (grub_elf_t elf)
grub_linux_load32 (grub_elf_t elf, const char *filename)
{
Elf32_Addr base_addr;
grub_addr_t seg_addr;
@ -159,7 +159,7 @@ grub_linux_load32 (grub_elf_t elf)
grub_uint32_t offset;
Elf32_Addr entry;
linux_size = grub_elf32_size (elf, &base_addr, &align);
linux_size = grub_elf32_size (elf, filename, &base_addr, &align);
if (linux_size == 0)
return grub_errno;
/* Pad it; the kernel scribbles over memory beyond its load address. */
@ -195,11 +195,11 @@ grub_linux_load32 (grub_elf_t elf)
*addr = (phdr->p_paddr - base_addr) + seg_addr;
return 0;
}
return grub_elf32_load (elf, offset_phdr, 0, 0);
return grub_elf32_load (elf, filename, offset_phdr, 0, 0);
}
static grub_err_t
grub_linux_load64 (grub_elf_t elf)
grub_linux_load64 (grub_elf_t elf, const char *filename)
{
Elf64_Addr base_addr;
grub_addr_t seg_addr;
@ -207,7 +207,7 @@ grub_linux_load64 (grub_elf_t elf)
grub_uint64_t offset;
Elf64_Addr entry;
linux_size = grub_elf64_size (elf, &base_addr, &align);
linux_size = grub_elf64_size (elf, filename, &base_addr, &align);
if (linux_size == 0)
return grub_errno;
/* Pad it; the kernel scribbles over memory beyond its load address. */
@ -241,7 +241,7 @@ grub_linux_load64 (grub_elf_t elf)
*addr = (phdr->p_paddr - base_addr) + seg_addr;
return 0;
}
return grub_elf64_load (elf, offset_phdr, 0, 0);
return grub_elf64_load (elf, filename, offset_phdr, 0, 0);
}
static grub_err_t
@ -255,7 +255,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
goto out;
}
@ -266,7 +266,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
if (elf->ehdr.ehdr32.e_type != ET_EXEC && elf->ehdr.ehdr32.e_type != ET_DYN)
{
grub_error (GRUB_ERR_UNKNOWN_OS,
"this ELF file is not of the right type");
N_("this ELF file is not of the right type"));
goto out;
}
@ -274,13 +274,13 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
grub_loader_unset ();
if (grub_elf_is_elf32 (elf))
grub_linux_load32 (elf);
grub_linux_load32 (elf, argv[0]);
else
if (grub_elf_is_elf64 (elf))
grub_linux_load64 (elf);
grub_linux_load64 (elf, argv[0]);
else
{
grub_error (GRUB_ERR_BAD_FILE_TYPE, "unknown ELF class");
grub_error (GRUB_ERR_BAD_FILE_TYPE, N_("invalid arch dependent ELF magic"));
goto out;
}
@ -329,13 +329,13 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "no initrd specified");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
goto fail;
}
if (!loaded)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "you need to load the kernel first");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("you need to load the kernel first"));
goto fail;
}

20
grub-core/loader/sparc64/ieee1275/linux.c
View file

@ -242,7 +242,7 @@ alloc_phys (grub_addr_t size)
}
static grub_err_t
grub_linux_load64 (grub_elf_t elf)
grub_linux_load64 (grub_elf_t elf, const char *filename)
{
grub_addr_t off, paddr, base;
int ret;
@ -250,7 +250,7 @@ grub_linux_load64 (grub_elf_t elf)
linux_entry = elf->ehdr.ehdr64.e_entry;
linux_addr = 0x40004000;
off = 0x4000;
linux_size = grub_elf64_size (elf, 0, 0);
linux_size = grub_elf64_size (elf, filename, 0, 0);
if (linux_size == 0)
return grub_errno;
@ -289,7 +289,7 @@ grub_linux_load64 (grub_elf_t elf)
*addr = (phdr->p_paddr - base) + (linux_addr - off);
return 0;
}
return grub_elf64_load (elf, offset_phdr, 0, 0);
return grub_elf64_load (elf, filename, offset_phdr, 0, 0);
}
static grub_err_t
@ -304,7 +304,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
goto out;
}
@ -312,14 +312,14 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
if (!file)
goto out;
elf = grub_elf_file (file);
elf = grub_elf_file (file, argv[0]);
if (! elf)
goto out;
if (elf->ehdr.ehdr32.e_type != ET_EXEC)
{
grub_error (GRUB_ERR_UNKNOWN_OS,
"this ELF file is not of the right type");
N_("this ELF file is not of the right type"));
goto out;
}
@ -327,10 +327,10 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
grub_loader_unset ();
if (grub_elf_is_elf64 (elf))
grub_linux_load64 (elf);
grub_linux_load64 (elf, argv[0]);
else
{
grub_error (GRUB_ERR_BAD_FILE_TYPE, "unknown ELF class");
grub_error (GRUB_ERR_BAD_FILE_TYPE, N_("invalid arch dependent ELF magic"));
goto out;
}
@ -382,13 +382,13 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "no initrd specified");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
goto fail;
}
if (!loaded)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "you need to load the kernel first");
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("you need to load the kernel first"));
goto fail;
}

106
grub-core/loader/xnu.c
View file

@ -221,17 +221,17 @@ grub_xnu_writetree_toheap (grub_addr_t *target, grub_size_t *size)
driverkey = (struct grub_xnu_devtree_key *) grub_malloc (sizeof (*driverkey));
if (! driverkey)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't write device tree");
return grub_errno;
driverkey->name = grub_strdup ("DeviceTree");
if (! driverkey->name)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't write device tree");
return grub_errno;
driverkey->datasize = sizeof (*extdesc);
driverkey->next = memorymap->first_child;
memorymap->first_child = driverkey;
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");
return grub_errno;
/* Allocate the space based on the size with dummy value. */
*size = grub_xnu_writetree_get_size (grub_xnu_devtree_root, "/");
@ -269,15 +269,11 @@ grub_xnu_create_key (struct grub_xnu_devtree_key **parent, const char *name)
return ret;
ret = (struct grub_xnu_devtree_key *) grub_zalloc (sizeof (*ret));
if (! ret)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't create key %s", name);
return 0;
}
return 0;
ret->name = grub_strdup (name);
if (! ret->name)
{
grub_free (ret);
grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't create key %s", name);
return 0;
}
ret->datasize = -1;
@ -303,15 +299,11 @@ grub_xnu_create_value (struct grub_xnu_devtree_key **parent, const char *name)
}
ret = (struct grub_xnu_devtree_key *) grub_zalloc (sizeof (*ret));
if (! ret)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't create value %s", name);
return 0;
}
return 0;
ret->name = grub_strdup (name);
if (! ret->name)
{
grub_free (ret);
grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't create value %s", name);
return 0;
}
ret->next = *parent;
@ -351,7 +343,7 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
grub_addr_t loadaddr_target;
if (argc < 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
grub_xnu_unload ();
@ -391,7 +383,7 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
}
/* Load kernel. */
err = grub_macho_load32 (macho, (char *) loadaddr - startcode,
err = grub_macho_load32 (macho, args[0], (char *) loadaddr - startcode,
GRUB_MACHO_NOBSS);
if (err)
{
@ -461,7 +453,7 @@ grub_cmd_xnu_kernel64 (grub_command_t cmd __attribute__ ((unused)),
grub_addr_t loadaddr_target;
if (argc < 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
grub_xnu_unload ();
@ -504,7 +496,7 @@ grub_cmd_xnu_kernel64 (grub_command_t cmd __attribute__ ((unused)),
}
/* Load kernel. */
err = grub_macho_load64 (macho, (char *) loadaddr - startcode,
err = grub_macho_load64 (macho, args[0], (char *) loadaddr - startcode,
GRUB_MACHO_NOBSS);
if (err)
{
@ -573,7 +565,7 @@ grub_xnu_register_memory (const char *prefix, int *suffix,
struct grub_xnu_extdesc *extdesc;
if (! grub_xnu_heap_size)
return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded");
return grub_error (GRUB_ERR_BAD_OS, N_("you need to load the kernel first"));
chosen = grub_xnu_create_key (&grub_xnu_devtree_root, "chosen");
if (! chosen)
@ -584,24 +576,27 @@ grub_xnu_register_memory (const char *prefix, int *suffix,
driverkey = (struct grub_xnu_devtree_key *) grub_malloc (sizeof (*driverkey));
if (! driverkey)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't register memory");
return grub_errno;
if (suffix)
{
driverkey->name = grub_xasprintf ("%s%d", prefix, (*suffix)++);
if (!driverkey->name)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't register memory");
}
driverkey->name = grub_xasprintf ("%s%d", prefix, (*suffix)++);
else
driverkey->name = grub_strdup (prefix);
if (! driverkey->name)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't register extension");
if (!driverkey->name)
{
grub_free (driverkey);
return grub_errno;
}
driverkey->datasize = sizeof (*extdesc);
driverkey->next = memorymap->first_child;
memorymap->first_child = driverkey;
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");
{
grub_free (driverkey->name);
grub_free (driverkey);
return grub_errno;
}
memorymap->first_child = driverkey;
extdesc->addr = addr;
extdesc->size = (grub_uint32_t) size;
return GRUB_ERR_NONE;
@ -637,7 +632,8 @@ get_name_ptr (char *name)
/* Load .kext. */
static grub_err_t
grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile,
const char *filename)
{
grub_macho_t macho;
grub_err_t err;
@ -662,12 +658,12 @@ grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
neededspace += namelen + 1;
if (! grub_xnu_heap_size)
return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded");
return grub_error (GRUB_ERR_BAD_OS, N_("you need to load the kernel first"));
/* Compute the needed space. */
if (binaryfile)
{
macho = grub_macho_file (binaryfile);
macho = grub_macho_file (binaryfile, filename);
if (! macho || ! grub_macho_contains_macho32 (macho))
{
if (macho)
@ -716,9 +712,9 @@ grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
exthead->binaryaddr = buf_target + (buf - (grub_uint8_t *) buf0);
exthead->binarysize = machosize;
if (grub_xnu_is_64bit)
err = grub_macho_readfile64 (macho, buf);
err = grub_macho_readfile64 (macho, filename, buf);
else
err = grub_macho_readfile32 (macho, buf);
err = grub_macho_readfile32 (macho, filename, buf);
if (err)
{
grub_macho_close (macho);
@ -776,10 +772,10 @@ grub_cmd_xnu_mkext (grub_command_t cmd __attribute__ ((unused)),
int narchs, i;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
if (! grub_xnu_heap_size)
return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded");
return grub_error (GRUB_ERR_BAD_OS, N_("you need to load the kernel first"));
file = grub_file_open (args[0]);
if (! file)
@ -890,10 +886,10 @@ grub_cmd_xnu_ramdisk (grub_command_t cmd __attribute__ ((unused)),
grub_size_t size;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
if (! grub_xnu_heap_size)
return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded");
return grub_error (GRUB_ERR_BAD_OS, N_("you need to load the kernel first"));
file = grub_file_open (args[0]);
if (! file)
@ -1072,7 +1068,7 @@ grub_xnu_scan_dir_for_kexts (char *dirname, const char *osbundlerequired,
}
if (! grub_xnu_heap_size)
return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded");
return grub_error (GRUB_ERR_BAD_OS, N_("you need to load the kernel first"));
device_name = grub_file_get_device_name (dirname);
dev = grub_device_open (device_name);
@ -1190,14 +1186,15 @@ grub_xnu_load_kext_from_dir (char *dirname, const char *osbundlerequired,
grub_errno = GRUB_ERR_NONE;
/* Load the extension. */
grub_xnu_load_driver (plistname, binfile);
grub_xnu_load_driver (plistname, binfile,
binname);
grub_free (binname);
grub_free (binsuffix);
}
else
{
grub_dprintf ("xnu", "%s:0\n", plistname);
grub_xnu_load_driver (plistname, 0);
grub_xnu_load_driver (plistname, 0, 0);
}
}
grub_free (plistname);
@ -1220,7 +1217,7 @@ grub_cmd_xnu_kext (grub_command_t cmd __attribute__ ((unused)),
grub_file_t binfile = 0;
if (! grub_xnu_heap_size)
return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded");
return grub_error (GRUB_ERR_BAD_OS, N_("you need to load the kernel first"));
if (argc == 2)
{
@ -1229,20 +1226,17 @@ grub_cmd_xnu_kext (grub_command_t cmd __attribute__ ((unused)),
{
binfile = grub_file_open (args[1]);
if (! binfile)
{
grub_error (GRUB_ERR_BAD_OS, "can't open file");
return GRUB_ERR_NONE;
}
return grub_errno;
}
return grub_xnu_load_driver (grub_strcmp (args[0], "-") ? args[0] : 0,
binfile);
binfile, args[1]);
}
/* load kext normally. */
if (argc == 1)
return grub_xnu_load_kext_from_dir (args[0], 0, 10);
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
}
/* Load a directory containing kexts. */
@ -1254,7 +1248,7 @@ grub_cmd_xnu_kextdir (grub_command_t cmd __attribute__ ((unused)),
return grub_error (GRUB_ERR_BAD_ARGUMENT, "directory name required");
if (! grub_xnu_heap_size)
return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded");
return grub_error (GRUB_ERR_BAD_OS, N_("you need to load the kernel first"));
if (argc == 1)
return grub_xnu_scan_dir_for_kexts (args[0],
@ -1394,10 +1388,10 @@ grub_cmd_xnu_splash (grub_extcmd_context_t ctxt,
{
grub_err_t err;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
if (! grub_xnu_heap_size)
return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded");
return grub_error (GRUB_ERR_BAD_OS, N_("you need to load the kernel first"));
if (ctxt->state[XNU_SPLASH_CMD_ARGINDEX_MODE].set &&
grub_strcmp (ctxt->state[XNU_SPLASH_CMD_ARGINDEX_MODE].arg,
@ -1420,7 +1414,7 @@ grub_cmd_xnu_resume (grub_command_t cmd __attribute__ ((unused)),
int argc, char *args[])
{
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
return grub_xnu_resume (args[0]);
}
@ -1457,11 +1451,16 @@ GRUB_MOD_INIT(xnu)
cmd_kext = grub_register_command ("xnu_kext", grub_cmd_xnu_kext, 0,
N_("Load XNU extension."));
cmd_kextdir = grub_register_command ("xnu_kextdir", grub_cmd_xnu_kextdir,
/* TRANSLATORS: OSBundleRequired is a
variable name in xnu extensions
manifests. It behaves mostly like
GNU/Linux runlevels.
*/
N_("DIRECTORY [OSBundleRequired]"),
N_("Load XNU extension directory."));
cmd_ramdisk = grub_register_command ("xnu_ramdisk", grub_cmd_xnu_ramdisk, 0,
N_("Load XNU ramdisk. "
"It will be seen as md0."));
"It will be available in OS as md0."));
cmd_splash = grub_register_extcmd ("xnu_splash",
grub_cmd_xnu_splash, 0, 0,
N_("Load a splash image for XNU."),
@ -1469,7 +1468,8 @@ GRUB_MOD_INIT(xnu)
#ifndef GRUB_MACHINE_EMU
cmd_resume = grub_register_command ("xnu_resume", grub_cmd_xnu_resume,
0, N_("Load XNU hibernate image."));
0, N_("Load an image of hibernated"
" XNU image."));
#endif
grub_cpu_xnu_init ();