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

6
grub-core/efiemu/i386/loadcore32.c
View file

@ -23,6 +23,7 @@
#include <grub/efiemu/efiemu.h>
#include <grub/cpu/efiemu.h>
#include <grub/elf.h>
#include <grub/i18n.h>
/* Check if EHDR is a valid ELF header. */
int
@ -101,8 +102,9 @@ grub_arch_efiemu_relocate_symbols32 (grub_efiemu_segment_t segs,
return err;
break;
default:
return grub_error (GRUB_ERR_BAD_OS,
"unrecognised relocation");
return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
N_("relocation 0x%x is not implemented yet"),
ELF_R_TYPE (rel->r_info));
}
}
}

6
grub-core/efiemu/i386/loadcore64.c
View file

@ -23,6 +23,7 @@
#include <grub/efiemu/efiemu.h>
#include <grub/cpu/efiemu.h>
#include <grub/elf.h>
#include <grub/i18n.h>
/* Check if EHDR is a valid ELF header. */
int
@ -109,8 +110,9 @@ grub_arch_efiemu_relocate_symbols64 (grub_efiemu_segment_t segs,
return err;
break;
default:
return grub_error (GRUB_ERR_BAD_OS,
"unrecognised relocation");
return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
N_("relocation 0x%x is not implemented yet"),
ELF_R_TYPE (rel->r_info));
}
}
}

7
grub-core/efiemu/loadcore.c
View file

@ -23,6 +23,7 @@
#include <grub/efiemu/efiemu.h>
#include <grub/cpu/efiemu.h>
#include <grub/elf.h>
#include <grub/i18n.h>
/* ELF symbols and their values */
static struct grub_efiemu_elf_sym *grub_efiemu_elfsyms = 0;
@ -193,7 +194,7 @@ grub_efiemu_count_symbols (const Elf_Ehdr *e)
break;
if (i == e->e_shnum)
return grub_error (GRUB_ERR_BAD_OS, "no symbol table");
return grub_error (GRUB_ERR_BAD_OS, N_("no symbol table"));
grub_efiemu_nelfsyms = (unsigned) s->sh_size / (unsigned) s->sh_entsize;
grub_efiemu_elfsyms = (struct grub_efiemu_elf_sym *)
@ -230,7 +231,7 @@ grub_efiemu_resolve_symbols (grub_efiemu_segment_t segs, Elf_Ehdr *e)
break;
if (i == e->e_shnum)
return grub_error (GRUB_ERR_BAD_OS, "no symbol table");
return grub_error (GRUB_ERR_BAD_OS, N_("no symbol table"));
sym = (Elf_Sym *) ((char *) e + s->sh_offset);
size = s->sh_size;
@ -328,7 +329,7 @@ SUFFIX (grub_efiemu_loadcore_init) (void *core, grub_size_t core_size,
grub_err_t err;
if (e->e_type != ET_REL)
return grub_error (GRUB_ERR_BAD_MODULE, "invalid ELF file type");
return grub_error (GRUB_ERR_BAD_MODULE, N_("this ELF file is not of the right type"));
/* Make sure that every section is within the core. */
if ((grub_size_t) core_size < e->e_shoff + e->e_shentsize * e->e_shnum)

14
grub-core/efiemu/loadcore_common.c
View file

@ -140,8 +140,9 @@ grub_efiemu_loadcore_init (grub_file_t file)
switch (grub_efiemu_mode)
{
case GRUB_EFIEMU32:
if ((err = grub_efiemu_loadcore_init32 (efiemu_core, efiemu_core_size,
&efiemu_segments)))
err = grub_efiemu_loadcore_init32 (efiemu_core, efiemu_core_size,
&efiemu_segments);
if (err)
{
grub_free (efiemu_core);
efiemu_core = 0;
@ -151,8 +152,9 @@ grub_efiemu_loadcore_init (grub_file_t file)
break;
case GRUB_EFIEMU64:
if ((err = grub_efiemu_loadcore_init64 (efiemu_core, efiemu_core_size,
&efiemu_segments)))
err = grub_efiemu_loadcore_init64 (efiemu_core, efiemu_core_size,
&efiemu_segments);
if (err)
{
grub_free (efiemu_core);
efiemu_core = 0;
@ -162,7 +164,7 @@ grub_efiemu_loadcore_init (grub_file_t file)
break;
default:
return grub_error (GRUB_ERR_BAD_OS, "unknown EFI runtime");
return grub_error (GRUB_ERR_BUG, "unknown EFI runtime");
}
return GRUB_ERR_NONE;
}
@ -184,6 +186,6 @@ grub_efiemu_loadcore_load (void)
grub_efiemu_loadcore_unload ();
return err;
default:
return grub_error (GRUB_ERR_BAD_OS, "unknown EFI runtime");
return grub_error (GRUB_ERR_BUG, "unknown EFI runtime");
}
}

19
grub-core/efiemu/main.c
View file

@ -121,11 +121,9 @@ grub_efiemu_register_prepare_hook (grub_err_t (*hook) (void *data),
void *data)
{
struct grub_efiemu_prepare_hook *nhook;
if (! hook)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "you must supply the hook");
nhook = (struct grub_efiemu_prepare_hook *) grub_malloc (sizeof (*nhook));
if (! nhook)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "couldn't prepare hook");
return grub_errno;
nhook->hook = hook;
nhook->unload = unload;
nhook->data = data;
@ -146,16 +144,13 @@ grub_efiemu_register_configuration_table (grub_efi_guid_t guid,
struct grub_efiemu_configuration_table *tbl;
grub_err_t err;
if (! get_table && ! data)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"you must set at least get_table or data");
err = grub_efiemu_unregister_configuration_table (guid);
if (err)
return err;
tbl = (struct grub_efiemu_configuration_table *) grub_malloc (sizeof (*tbl));
if (! tbl)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "couldn't register table");
return grub_errno;
tbl->guid = guid;
tbl->get_table = get_table;
@ -201,7 +196,7 @@ grub_efiemu_load_file (const char *filename)
{
grub_file_close (file);
grub_efiemu_unload ();
return grub_error (grub_errno, "couldn't init memory management");
return grub_errno;
}
grub_dprintf ("efiemu", "mm initialized\n");
@ -237,16 +232,14 @@ grub_efiemu_autocore (void)
if (! prefix)
return grub_error (GRUB_ERR_FILE_NOT_FOUND,
"couldn't find efiemu core because prefix "
"isn't set");
N_("variable `%s' isn't set"), "prefix");
suffix = grub_efiemu_get_default_core_name ();
filename = grub_xasprintf ("%s/" GRUB_TARGET_CPU "-" GRUB_PLATFORM "/%s",
prefix, suffix);
if (! filename)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"couldn't allocate temporary space");
return grub_errno;
err = grub_efiemu_load_file (filename);
grub_free (filename);
@ -297,7 +290,7 @@ grub_cmd_efiemu_load (grub_command_t cmd __attribute__ ((unused)),
grub_efiemu_unload ();
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "filename required");
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
err = grub_efiemu_load_file (args[0]);
if (err)

25
grub-core/efiemu/mm.c
View file

@ -62,12 +62,17 @@ grub_efiemu_add_to_mmap (grub_uint64_t start, grub_uint64_t size,
/* Extend map if necessary*/
if (mmap_num >= mmap_reserved_size)
{
void *old;
mmap_reserved_size = 2 * (mmap_reserved_size + 1);
old = efiemu_mmap;
efiemu_mmap = (grub_efi_memory_descriptor_t *)
grub_realloc (efiemu_mmap, (++mmap_reserved_size)
grub_realloc (efiemu_mmap, mmap_reserved_size
* sizeof (grub_efi_memory_descriptor_t));
if (!efiemu_mmap)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"not enough space for memory map");
{
grub_free (old);
return grub_errno;
}
}
/* Fill slot*/
@ -176,8 +181,7 @@ efiemu_alloc_requests (void)
/* Allocate the whole memory in one block */
resident_memory = grub_memalign (GRUB_EFIEMU_PAGESIZE, total_alloc);
if (!resident_memory)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"couldn't allocate resident memory");
return grub_errno;
/* Split the memory into blocks by type */
curptr = resident_memory;
@ -540,8 +544,7 @@ grub_efiemu_mmap_sort_and_uniq (void)
{
grub_free (result);
grub_free (scanline_events);
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"couldn't allocate space for new memory map");
return grub_errno;
}
/* Register scanline events */
@ -642,12 +645,14 @@ grub_efiemu_mm_do_alloc (void)
if (!efiemu_mmap)
{
grub_efiemu_unload ();
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "couldn't initialize mmap");
return grub_errno;
}
if ((err = efiemu_alloc_requests ()))
err = efiemu_alloc_requests ();
if (err)
return err;
if ((err = grub_efiemu_mmap_fill ()))
err = grub_efiemu_mmap_fill ();
if (err)
return err;
return grub_efiemu_mmap_sort_and_uniq ();
}

6
grub-core/efiemu/pnvram.c
View file

@ -171,12 +171,6 @@ nvram_set (void * data __attribute__ ((unused)))
(nvramsize - (nvramptr - nvram)) / 2,
(grub_uint8_t *) varname, len, NULL);
if (len < 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "broken UTF-8 in variable name");
return 1;
}
nvramptr += 2 * len;
*((grub_uint16_t *) nvramptr) = 0;
nvramptr += 2;

11
grub-core/efiemu/symbols.c
View file

@ -22,6 +22,7 @@
#include <grub/misc.h>
#include <grub/efiemu/efiemu.h>
#include <grub/efiemu/runtime.h>
#include <grub/i18n.h>
static int ptv_written = 0;
static int ptv_alloc = 0;
@ -69,7 +70,7 @@ grub_efiemu_request_symbols (int num)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"symbols have already been allocated");
if (num < 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
return grub_error (GRUB_ERR_BUG,
"can't request negative symbols");
ptv_requested += num;
return GRUB_ERR_NONE;
@ -88,7 +89,7 @@ grub_efiemu_resolve_symbol (const char *name, int *handle, grub_off_t *off)
return GRUB_ERR_NONE;
}
grub_dprintf ("efiemu", "%s not found\n", name);
return grub_error (GRUB_ERR_BAD_OS, "symbol %s isn't found", name);
return grub_error (GRUB_ERR_BAD_OS, N_("symbol `%s' not found"), name);
}
/* Register symbol named NAME in memory handle HANDLE at offset OFF */
@ -99,7 +100,7 @@ grub_efiemu_register_symbol (const char *name, int handle, grub_off_t off)
cur = (struct grub_efiemu_sym *) grub_malloc (sizeof (*cur));
grub_dprintf ("efiemu", "registering symbol '%s'\n", name);
if (!cur)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "couldn't register symbol");
return grub_errno;
cur->name = grub_strdup (name);
cur->next = efiemu_syms;
cur->handle = handle;
@ -153,7 +154,7 @@ grub_efiemu_write_value (void *addr, grub_uint32_t value, int plus_handle,
= grub_efiemu_mm_obtain_request (ptv_handle);
if (ptv_needed && ptv_written >= ptv_alloc)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
return grub_error (GRUB_ERR_BUG,
"your module didn't declare efiemu "
" relocators correctly");
@ -200,7 +201,7 @@ grub_efiemu_write_value (void *addr, grub_uint32_t value, int plus_handle,
*((grub_uint8_t *) addr) = value;
break;
default:
return grub_error (GRUB_ERR_BAD_ARGUMENT, "wrong symbol size");
return grub_error (GRUB_ERR_BUG, "wrong symbol size");
}
return GRUB_ERR_NONE;