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

2009-03-29 Yoshinori K. Okuji <okuji@enbug.org>

Browse source 
Make the format of Environment Block plain text. The boot loader
    part is not tested well yet.
    
    * util/grub-editenv.c (DEFAULT_ENVBLK_SIZE): New macro.
    (buffer): Removed.
    (envblk): Likewise.
    (usage): Remove "info" and "clear". Add "unset". Update the
    description of "set", as this does not delete variables any
    longer.
    (create_envblk_file): Complete rewrite.
    (open_envblk_file): Likewise.
    (cmd_info): Removed.
    (cmd_list): Likewise.
    (cmd_set): Likewise.
    (cmd_clear): Likewise.
    (list_variables): New function.
    (write_envblk): Likewise.
    (set_variables): Likewise.
    (unset_variables): Likewise.
    (main): Complete rewrite.

    * commands/loadenv.c (buffer): Removed.
    (envblk): Likewise.
    (open_envblk_file): New function.
    (read_envblk_file): Complete rewrite.
    (grub_cmd_load_env): Likewise.
    (grub_cmd_list_env): Likewise.
    (struct blocklist): New struct.
    (free_blocklists): New function.
    (check_blocklists): Likewise.
    (write_blocklists): Likewise.
    (grub_cmd_save_env): Complete rewrite.

    * include/grub/lib/envblk.h (GRUB_ENVBLK_SIGNATURE): Replaced with
    a plain text signature.
    (GRUB_ENVBLK_MAXLEN): Removed.
    (struct grub_envblk): Complete rewrite.
    (grub_envblk_find): Removed.
    (grub_envblk_insert): Likewise.
    (grub_envblk_open): New prototype.
    (grub_envblk_set): Likewise.
    (grub_envblk_delete): Put const to VALUE.
    (grub_envblk_iterate): Put const to NAME and VALUE.
    (grub_envblk_close): New prototype.
    (grub_envblk_buffer): New inline function.
    (grub_envblk_size): Likewise.

    * lib/envblk.c: Include grub/mm.h.
    (grub_env_find): Removed.
    (grub_envblk_open): New function.
    (grub_envblk_close): Likewise.
    (escaped_value_len): Likewise.
    (find_next_line): Likewise.
    (grub_envblk_insert): Removed.
    (grub_envblk_set): New function.
    (grub_envblk_delete): Complete rewrite.
    (grub_envblk_iterate): Likewise.
This commit is contained in:
okuji 2009-03-28 19:58:15 +00:00
parent a9368fd30c
commit 5709cfc4d1
7 changed files with 3685 additions and 2644 deletions
Download patch file Download diff file Expand all files Collapse all files

339
commands/loadenv.c
View file

@ -1,7 +1,7 @@
/* loadenv.c - command to load/save environment variable. */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2008 Free Software Foundation, Inc.
* Copyright (C) 2008,2009 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -33,13 +33,9 @@ static const struct grub_arg_option options[] =
{0, 0, 0, 0, 0, 0}
};
char buffer[GRUB_ENVBLK_MAXLEN];
grub_envblk_t envblk;
static grub_file_t
read_envblk_file (char *filename, void NESTED_FUNC_ATTR read_hook (grub_disk_addr_t sector, unsigned offset, unsigned length))
open_envblk_file (char *filename)
{
char *buf = 0;
grub_file_t file;
if (! filename)
@ -52,11 +48,16 @@ read_envblk_file (char *filename, void NESTED_FUNC_ATTR read_hook (grub_disk_add
int len;
len = grub_strlen (prefix);
buf = grub_malloc (len + 1 + sizeof (GRUB_ENVBLK_DEFCFG));
grub_strcpy (buf, prefix);
buf[len] = '/';
grub_strcpy (buf + len + 1, GRUB_ENVBLK_DEFCFG);
filename = buf;
filename = grub_malloc (len + 1 + sizeof (GRUB_ENVBLK_DEFCFG));
if (! filename)
return 0;
grub_strcpy (filename, prefix);
filename[len] = '/';
grub_strcpy (filename + len + 1, GRUB_ENVBLK_DEFCFG);
file = grub_file_open (filename);
grub_free (filename);
return file;
}
else
{
@ -65,66 +66,78 @@ read_envblk_file (char *filename, void NESTED_FUNC_ATTR read_hook (grub_disk_add
}
}
file = grub_file_open (filename);
grub_free (buf);
if (! file)
return 0;
return grub_file_open (filename);
}
if (read_hook)
static grub_envblk_t
read_envblk_file (grub_file_t file)
{
grub_off_t offset = 0;
char *buf;
grub_size_t size = grub_file_size (file);
grub_envblk_t envblk;
buf = grub_malloc (size);
if (! buf)
return 0;
while (size > 0)
{
if (! file->device->disk)
grub_ssize_t ret;
ret = grub_file_read (file, buf + offset, size);
if (ret <= 0)
{
grub_file_close (file);
grub_error (GRUB_ERR_BAD_DEVICE,
"this command is available only for disk devices.");
if (grub_errno == GRUB_ERR_NONE)
grub_error (GRUB_ERR_FILE_READ_ERROR, "cannot read");
grub_free (buf);
return 0;
}
file->read_hook = read_hook;
size -= ret;
offset += ret;
}
if (grub_file_read (file, buffer, GRUB_ENVBLK_MAXLEN) != GRUB_ENVBLK_MAXLEN)
{
grub_file_close (file);
grub_error (GRUB_ERR_BAD_FILE_TYPE, "file too short");
return 0;
}
envblk = grub_envblk_find (buffer);
envblk = grub_envblk_open (buf, offset);
if (! envblk)
{
grub_file_close (file);
grub_error (GRUB_ERR_BAD_FILE_TYPE, "environment block not found");
grub_free (buf);
grub_error (GRUB_ERR_BAD_FILE_TYPE, "invalid environment block");
return 0;
}
return file;
return envblk;
}
static grub_err_t
grub_cmd_load_env (grub_extcmd_t cmd,
int argc __attribute__ ((unused)),
char **args __attribute__ ((unused)))
{
struct grub_arg_list *state = cmd->state;
grub_file_t file;
grub_envblk_t envblk;
auto int hook (char *name, char *value);
int hook (char *name, char *value)
{
grub_env_set (name, value);
return 0;
}
file = read_envblk_file ((state[0].set) ? state[0].arg : 0, 0);
auto int set_var (const char *name, const char *value);
int set_var (const char *name, const char *value)
{
grub_env_set (name, value);
return 0;
}
file = open_envblk_file ((state[0].set) ? state[0].arg : 0);
if (! file)
return grub_errno;
envblk = read_envblk_file (file);
if (! envblk)
goto fail;
grub_envblk_iterate (envblk, set_var);
grub_envblk_close (envblk);
fail:
grub_file_close (file);
grub_envblk_iterate (envblk, hook);
return grub_errno;
}
@ -135,83 +148,207 @@ grub_cmd_list_env (grub_extcmd_t cmd,
{
struct grub_arg_list *state = cmd->state;
grub_file_t file;
grub_envblk_t envblk;
auto int hook (char *name, char *value);
int hook (char *name, char *value)
/* Print all variables in current context. */
auto int print_var (const char *name, const char *value);
int print_var (const char *name, const char *value)
{
grub_printf ("%s=%s\n", name, value);
return 0;
}
file = read_envblk_file ((state[0].set) ? state[0].arg : 0, 0);
file = open_envblk_file ((state[0].set) ? state[0].arg : 0);
if (! file)
return grub_errno;
envblk = read_envblk_file (file);
if (! envblk)
goto fail;
grub_envblk_iterate (envblk, print_var);
grub_envblk_close (envblk);
fail:
grub_file_close (file);
grub_envblk_iterate (envblk, hook);
return grub_errno;
}
/* Used to maintain a variable length of blocklists internally. */
struct blocklist
{
grub_disk_addr_t sector;
unsigned offset;
unsigned length;
struct blocklist *next;
};
static void
free_blocklists (struct blocklist *p)
{
struct blocklist *q;
for (; p; p = q)
{
q = p->next;
grub_free (p);
}
}
static int
check_blocklists (grub_envblk_t envblk, struct blocklist *blocklists,
grub_file_t file)
{
grub_size_t total_length;
grub_size_t index;
grub_disk_t disk;
grub_disk_addr_t part_start;
struct blocklist *p;
char *buf;
/* Sanity checks. */
total_length = 0;
for (p = blocklists; p; p = p->next)
{
struct blocklist *q;
for (q = p->next; q; q = q->next)
{
/* Check if any pair of blocks overlap. */
if (p->sector == q->sector)
{
/* This might be actually valid, but it is unbelievable that
any filesystem makes such a silly allocation. */
grub_error (GRUB_ERR_BAD_FS, "malformed file");
return 0;
}
}
total_length += p->length;
}
if (total_length != grub_file_size (file))
{
/* Maybe sparse, unallocated sectors. No way in GRUB. */
grub_error (GRUB_ERR_BAD_FILE_TYPE, "sparse file not allowed");
return 0;
}
/* One more sanity check. Re-read all sectors by blocklists, and compare
those with the data read via a file. */
disk = file->device->disk;
if (disk->partition)
part_start = grub_partition_get_start (disk->partition);
else
part_start = 0;
buf = grub_envblk_buffer (envblk);
for (p = blocklists, index = 0; p; p = p->next, index += p->length)
{
char blockbuf[GRUB_DISK_SECTOR_SIZE];
if (grub_disk_read (disk, p->sector - part_start,
p->offset, p->length, blockbuf))
return 0;
if (grub_memcmp (buf + index, blockbuf, p->length) != 0)
{
grub_error (GRUB_ERR_FILE_READ_ERROR, "invalid blocklist");
return 0;
}
}
return 1;
}
static int
write_blocklists (grub_envblk_t envblk, struct blocklist *blocklists,
grub_file_t file)
{
char *buf;
grub_disk_t disk;
grub_disk_addr_t part_start;
struct blocklist *p;
grub_size_t index;
buf = grub_envblk_buffer (envblk);
disk = file->device->disk;
if (disk->partition)
part_start = grub_partition_get_start (disk->partition);
else
part_start = 0;
index = 0;
for (p = blocklists; p; p = p->next, index += p->length)
{
if (grub_disk_write (disk, p->sector - part_start,
p->offset, p->length, buf + index))
return 0;
}
return 1;
}
static grub_err_t
grub_cmd_save_env (grub_extcmd_t cmd, int argc, char **args)
{
struct grub_arg_list *state = cmd->state;
grub_file_t file;
grub_disk_t disk;
grub_disk_addr_t addr[GRUB_ENVBLK_MAXLEN >> GRUB_DISK_SECTOR_BITS];
char buf[GRUB_DISK_SECTOR_SIZE];
grub_disk_addr_t part_start = 0;
int num = 0;
auto void NESTED_FUNC_ATTR hook (grub_disk_addr_t sector, unsigned offset,
unsigned length);
void NESTED_FUNC_ATTR hook (grub_disk_addr_t sector,
unsigned offset, unsigned length)
grub_envblk_t envblk;
struct blocklist *head = 0;
struct blocklist *tail = 0;
/* Store blocklists in a linked list. */
auto void NESTED_FUNC_ATTR read_hook (grub_disk_addr_t sector,
unsigned offset,
unsigned length);
void NESTED_FUNC_ATTR read_hook (grub_disk_addr_t sector,
unsigned offset, unsigned length)
{
if ((offset != 0) || (length != GRUB_DISK_SECTOR_SIZE))
struct blocklist *block;
if (offset + length > GRUB_DISK_SECTOR_SIZE)
/* Seemingly a bug. */
return;
block = grub_malloc (sizeof (*block));
if (! block)
return;
if (num < (GRUB_ENVBLK_MAXLEN >> GRUB_DISK_SECTOR_BITS))
addr[num++] = sector;
block->sector = sector;
block->offset = offset;
block->length = length;
/* Slightly complicated, because the list should be FIFO. */
block->next = 0;
if (tail)
tail->next = block;
tail = block;
if (! head)
head = block;
}
if (! argc)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "No variable is specified");
file = read_envblk_file ((state[0].set) ? state[0].arg : 0, hook);
file = open_envblk_file ((state[0].set) ? state[0].arg : 0);
if (! file)
return grub_errno;
if (! file->device->disk)
{
grub_file_close (file);
return grub_error (GRUB_ERR_BAD_DEVICE, "disk device required");
}
file->read_hook = read_hook;
envblk = read_envblk_file (file);
file->read_hook = 0;
if (! envblk)
goto fail;
if (num != GRUB_ENVBLK_MAXLEN >> GRUB_DISK_SECTOR_BITS)
{
grub_error (GRUB_ERR_BAD_DEVICE, "invalid blocklist");
goto quit;
}
disk = file->device->disk;
if (disk->partition)
part_start = grub_partition_get_start (disk->partition);
for (num = 0; num < (GRUB_ENVBLK_MAXLEN >> GRUB_DISK_SECTOR_BITS); num++)
{
if (grub_disk_read (disk, addr[num] - part_start, 0,
GRUB_DISK_SECTOR_SIZE, buf))
goto quit;
if (grub_memcmp (&buffer[num << GRUB_DISK_SECTOR_BITS], buf,
GRUB_DISK_SECTOR_SIZE))
{
grub_error (GRUB_ERR_BAD_DEVICE, "invalid blocklist");
goto quit;
}
}
if (! check_blocklists (envblk, head, file))
goto fail;
while (argc)
{
char *value;
@ -219,10 +356,10 @@ grub_cmd_save_env (grub_extcmd_t cmd, int argc, char **args)
value = grub_env_get (args[0]);
if (value)
{
if (grub_envblk_insert (envblk, args[0], value))
if (! grub_envblk_set (envblk, args[0], value))
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "environment block too small");
goto quit;
goto fail;
}
}
@ -230,15 +367,13 @@ grub_cmd_save_env (grub_extcmd_t cmd, int argc, char **args)
args++;
}
for (num = 0; num < (GRUB_ENVBLK_MAXLEN >> GRUB_DISK_SECTOR_BITS); num++)
if (grub_disk_write (disk, addr[num] - part_start, 0,
GRUB_DISK_SECTOR_SIZE,
&buffer[num << GRUB_DISK_SECTOR_BITS]))
goto quit;
quit:
write_blocklists (envblk, head, file);
fail:
if (envblk)
grub_envblk_close (envblk);
free_blocklists (head);
grub_file_close (file);
return grub_errno;
}