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

2006-05-02 Yoshinori K. Okuji <okuji@enbug.org>

Browse source 
* kern/env.c (struct grub_env_context): Removed "sorted". Renamed
        "next" to "prev" for readability.
        (struct grub_env_sorted_var): New struct.
        (grub_env_context): Renamed to ...
        (initial_context): ... this.
        (grub_env_var_context): Renamed to ...
        (current_context): ... this.
        (grub_env_find): Look only at CURRENT_CONTEXT.
        (grub_env_context_open): Rewritten to copy exported variables from
        previous context.
        (grub_env_context_close): Rewritten according to the new
        scheme. Also, add an assertion to prevent the initial context from
        removed.
        (grub_env_insert): Removed the code for the sorted list.
        (grub_env_remove): Likewise.
        (grub_env_export): Simply mark the variable with
        GRUB_ENV_VAR_GLOBAL.
        (grub_env_set): A cosmetic change for naming consistency.
        (grub_env_get): Likewise.
        (grub_env_unset): Likewise.
        (grub_env_iterate): Rewritten to sort variables within this
        function.
        (grub_register_variable_hook): Fixed for naming consistency. Call
        grub_env_find again, only if NAME is not found at the first time.
        (mangle_data_slot_name): New function.
        (grub_env_set_data_slot): Likewise.
        (grub_env_get_data_slot): Likewise.
        (grub_env_unset_data_slot): Likewise.

        * include/grub/env.h (grub_env_var_type): New enum.
        (GRUB_ENV_VAR_LOCAL): New constant.
        (GRUB_ENV_VAR_GLOBAL): Likewise.
        (GRUB_ENV_VAR_DATA): Likewise.
        (struct grub_env_var): Removed "sort_next" and "sort_prevp". Added
        "type".
        (grub_env_set): Replace VAR with NAME for consistency.
        (grub_register_variable_hook): Likewise.
        (grub_env_export): Specify the name of the argument.
        (grub_env_set_data_slot): New prototype.
        (grub_env_get_data_slot): Likewise.
        (grub_env_unset_data_slot): Likewise.
This commit is contained in:
okuji 2006-05-01 23:30:51 +00:00
parent 7f362539b7
commit 385bd9c12e
3 changed files with 315 additions and 160 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

44
ChangeLog
View file

@ -1,3 +1,47 @@
2006-05-02 Yoshinori K. Okuji <okuji@enbug.org>
* kern/env.c (struct grub_env_context): Removed "sorted". Renamed
"next" to "prev" for readability.
(struct grub_env_sorted_var): New struct.
(grub_env_context): Renamed to ...
(initial_context): ... this.
(grub_env_var_context): Renamed to ...
(current_context): ... this.
(grub_env_find): Look only at CURRENT_CONTEXT.
(grub_env_context_open): Rewritten to copy exported variables from
previous context.
(grub_env_context_close): Rewritten according to the new
scheme. Also, add an assertion to prevent the initial context from
removed.
(grub_env_insert): Removed the code for the sorted list.
(grub_env_remove): Likewise.
(grub_env_export): Simply mark the variable with
GRUB_ENV_VAR_GLOBAL.
(grub_env_set): A cosmetic change for naming consistency.
(grub_env_get): Likewise.
(grub_env_unset): Likewise.
(grub_env_iterate): Rewritten to sort variables within this
function.
(grub_register_variable_hook): Fixed for naming consistency. Call
grub_env_find again, only if NAME is not found at the first time.
(mangle_data_slot_name): New function.
(grub_env_set_data_slot): Likewise.
(grub_env_get_data_slot): Likewise.
(grub_env_unset_data_slot): Likewise.
* include/grub/env.h (grub_env_var_type): New enum.
(GRUB_ENV_VAR_LOCAL): New constant.
(GRUB_ENV_VAR_GLOBAL): Likewise.
(GRUB_ENV_VAR_DATA): Likewise.
(struct grub_env_var): Removed "sort_next" and "sort_prevp". Added
"type".
(grub_env_set): Replace VAR with NAME for consistency.
(grub_register_variable_hook): Likewise.
(grub_env_export): Specify the name of the argument.
(grub_env_set_data_slot): New prototype.
(grub_env_get_data_slot): Likewise.
(grub_env_unset_data_slot): Likewise.
2006-04-30 Yoshinori K. Okuji <okuji@enbug.org> 2006-04-30 Yoshinori K. Okuji <okuji@enbug.org>
Extend the loader so that GRUB can accept a loader which comes Extend the loader so that GRUB can accept a loader which comes

28
include/grub/env.h
View file

@ -31,6 +31,18 @@ typedef char *(*grub_env_read_hook_t) (struct grub_env_var *var,
typedef char *(*grub_env_write_hook_t) (struct grub_env_var *var, typedef char *(*grub_env_write_hook_t) (struct grub_env_var *var,
const char *val); const char *val);
enum grub_env_var_type
{
/* The default variable type which is local in current context. */
GRUB_ENV_VAR_LOCAL,
/* The exported type, which is passed to new contexts. */
GRUB_ENV_VAR_GLOBAL,
/* The data slot type, which is used to store arbitrary data. */
GRUB_ENV_VAR_DATA
};
struct grub_env_var struct grub_env_var
{ {
char *name; char *name;
@ -39,19 +51,23 @@ struct grub_env_var
grub_env_write_hook_t write_hook; grub_env_write_hook_t write_hook;
struct grub_env_var *next; struct grub_env_var *next;
struct grub_env_var **prevp; struct grub_env_var **prevp;
struct grub_env_var *sort_next; enum grub_env_var_type type;
struct grub_env_var **sort_prevp;
}; };
grub_err_t EXPORT_FUNC(grub_env_set) (const char *var, const char *val); grub_err_t EXPORT_FUNC(grub_env_set) (const char *name, const char *val);
char *EXPORT_FUNC(grub_env_get) (const char *name); char *EXPORT_FUNC(grub_env_get) (const char *name);
void EXPORT_FUNC(grub_env_unset) (const char *name); void EXPORT_FUNC(grub_env_unset) (const char *name);
void EXPORT_FUNC(grub_env_iterate) (int (* func) (struct grub_env_var *var)); void EXPORT_FUNC(grub_env_iterate) (int (*func) (struct grub_env_var *var));
grub_err_t EXPORT_FUNC(grub_register_variable_hook) (const char *var, grub_err_t EXPORT_FUNC(grub_register_variable_hook) (const char *name,
grub_env_read_hook_t read_hook, grub_env_read_hook_t read_hook,
grub_env_write_hook_t write_hook); grub_env_write_hook_t write_hook);
grub_err_t EXPORT_FUNC(grub_env_context_open) (void); grub_err_t EXPORT_FUNC(grub_env_context_open) (void);
grub_err_t EXPORT_FUNC(grub_env_context_close) (void); grub_err_t EXPORT_FUNC(grub_env_context_close) (void);
grub_err_t EXPORT_FUNC(grub_env_export) (const char *); grub_err_t EXPORT_FUNC(grub_env_export) (const char *name);
grub_err_t EXPORT_FUNC(grub_env_set_data_slot) (const char *name,
const void *ptr);
void *EXPORT_FUNC(grub_env_get_data_slot) (const char *name);
void EXPORT_FUNC(grub_env_unset_data_slot) (const char *name);
#endif /* ! GRUB_ENV_HEADER */ #endif /* ! GRUB_ENV_HEADER */

399
kern/env.c
View file

@ -28,22 +28,29 @@
/* A hashtable for quick lookup of variables. */ /* A hashtable for quick lookup of variables. */
struct grub_env_context struct grub_env_context
{ {
/* A hash table for variables. */
struct grub_env_var *vars[HASHSZ]; struct grub_env_var *vars[HASHSZ];
struct grub_env_var *sorted;
/* One level deeper on the stack. */ /* One level deeper on the stack. */
struct grub_env_context *next; struct grub_env_context *prev;
}; };
/* The global context for environment variables. */ /* This is used for sorting only. */
static struct grub_env_context grub_env_context; struct grub_env_sorted_var
{
struct grub_env_var *var;
struct grub_env_sorted_var *next;
};
/* The nested contexts for regular variables. */ /* The initial context. */
static struct grub_env_context *grub_env_var_context = &grub_env_context; static struct grub_env_context initial_context;
/* The current context. */
static struct grub_env_context *current_context = &initial_context;
/* Return the hash representation of the string S. */ /* Return the hash representation of the string S. */
static unsigned int grub_env_hashval (const char *s) static unsigned int
grub_env_hashval (const char *s)
{ {
unsigned int i = 0; unsigned int i = 0;
@ -61,13 +68,8 @@ grub_env_find (const char *name)
int idx = grub_env_hashval (name); int idx = grub_env_hashval (name);
/* Look for the variable in the current context. */ /* Look for the variable in the current context. */
for (var = grub_env_var_context->vars[idx]; var; var = var->next) for (var = current_context->vars[idx]; var; var = var->next)
if (! grub_strcmp (var->name, name)) if (grub_strcmp (var->name, name) == 0)
return var;
/* Look for the variable in the environment context. */
for (var = grub_env_context.vars[idx]; var; var = var->next)
if (! grub_strcmp (var->name, name))
return var; return var;
return 0; return 0;
@ -83,12 +85,25 @@ grub_env_context_open (void)
if (! context) if (! context)
return grub_errno; return grub_errno;
for (i = 0; i < HASHSZ; i++) grub_memset (context, 0, sizeof (*context));
context->vars[i] = 0; context->prev = current_context;
context->next = grub_env_var_context; current_context = context;
context->sorted = 0;
grub_env_var_context = context; /* Copy exported variables. */
for (i = 0; i < HASHSZ; i++)
{
struct grub_env_var *var;
for (var = context->prev->vars[i]; var; var = var->next)
{
if (var->type == GRUB_ENV_VAR_GLOBAL)
if (grub_env_set (var->name, var->value) != GRUB_ERR_NONE)
{
grub_env_context_close ();
return grub_errno;
}
}
}
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
} }
@ -97,146 +112,119 @@ grub_err_t
grub_env_context_close (void) grub_env_context_close (void)
{ {
struct grub_env_context *context; struct grub_env_context *context;
struct grub_env_var *env; int i;
struct grub_env_var *prev = 0;
context = grub_env_var_context->next; if (! current_context->prev)
grub_fatal ("cannot close the initial context");
/* Free the variables associated with this context. */ /* Free the variables associated with this context. */
for (env = grub_env_var_context->sorted; env; env = env->sort_next) for (i = 0; i < HASHSZ; i++)
{ {
/* XXX: What if a hook is associated with this variable? */ struct grub_env_var *p, *q;
grub_free (prev);
prev = env; for (p = current_context->prev->vars[i]; p; p = q)
{
q = p->next;
grub_free (p);
}
} }
grub_free (prev);
/* Restore the previous context. */ /* Restore the previous context. */
grub_free (grub_env_var_context); context = current_context->prev;
grub_env_var_context = context; grub_free (current_context);
current_context = context;
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
} }
static void static void
grub_env_insert (struct grub_env_context *context, grub_env_insert (struct grub_env_context *context,
struct grub_env_var *env) struct grub_env_var *var)
{ {
struct grub_env_var **grub_env = context->vars; int idx = grub_env_hashval (var->name);
struct grub_env_var *sort;
struct grub_env_var **sortp;
int idx = grub_env_hashval (env->name);
/* Insert it in the hashtable. */ /* Insert the variable into the hashtable. */
env->prevp = &grub_env[idx]; var->prevp = &context->vars[idx];;
env->next = grub_env[idx]; var->next = context->vars[idx];
if (grub_env[idx]) if (var->next)
grub_env[idx]->prevp = &env->next; var->next->prevp = &var;
grub_env[idx] = env; context->vars[idx] = var;
/* Insert it in the sorted list. */
sortp = &context->sorted;
sort = context->sorted;
while (sort)
{
if (grub_strcmp (sort->name, env->name) > 0)
break;
sortp = &sort->sort_next;
sort = sort->sort_next;
}
env->sort_prevp = sortp;
env->sort_next = sort;
if (sort)
sort->sort_prevp = &env->sort_next;
*sortp = env;
} }
static void static void
grub_env_remove (struct grub_env_var *env) grub_env_remove (struct grub_env_var *var)
{ {
/* Remove the entry from the variable table. */ /* Remove the entry from the variable table. */
*env->prevp = env->next; *var->prevp = var->next;
if (env->next) if (var->next)
env->next->prevp = env->prevp; var->next->prevp = var->prevp;
/* And from the sorted list. */
*env->sort_prevp = env->sort_next;
if (env->sort_next)
env->sort_next->sort_prevp = env->sort_prevp;
} }
grub_err_t grub_err_t
grub_env_export (const char *var) grub_env_export (const char *name)
{ {
struct grub_env_var *env; struct grub_env_var *var;
int idx = grub_env_hashval (var);
/* Look for the variable in the current context only. */ var = grub_env_find (name);
for (env = grub_env_var_context->vars[idx]; env; env = env->next) if (var)
if (! grub_strcmp (env->name, var)) var->type = GRUB_ENV_VAR_GLOBAL;
{
/* Remove the variable from the old context and reinsert it
into the environment. */
grub_env_remove (env);
grub_env_insert (&grub_env_context, env);
return GRUB_ERR_NONE;
}
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
} }
grub_err_t grub_err_t
grub_env_set (const char *var, const char *val) grub_env_set (const char *name, const char *val)
{ {
struct grub_env_var *env; struct grub_env_var *var;
/* If the variable does already exist, just update the variable. */ /* If the variable does already exist, just update the variable. */
env = grub_env_find (var); var = grub_env_find (name);
if (env) if (var)
{ {
char *old = env->value; char *old = var->value;
if (env->write_hook) if (var->write_hook)
env->value = env->write_hook (env, val); var->value = var->write_hook (var, val);
else else
env->value = grub_strdup (val); var->value = grub_strdup (val);
if (! env->value) if (! var->value)
{ {
env->value = old; var->value = old;
return grub_errno; return grub_errno;
} }
grub_free (old); grub_free (old);
return 0; return GRUB_ERR_NONE;
} }
/* The variable does not exist, create it. */ /* The variable does not exist, so create a new one. */
env = grub_malloc (sizeof (struct grub_env_var)); var = grub_malloc (sizeof (*var));
if (! env) if (! var)
return grub_errno; return grub_errno;
grub_memset (env, 0, sizeof (struct grub_env_var)); grub_memset (var, 0, sizeof (*var));
env->name = grub_strdup (var); /* This is not necessary, because GRUB_ENV_VAR_LOCAL == 0. But leave
if (! env->name) this for readability. */
var->type = GRUB_ENV_VAR_LOCAL;
var->name = grub_strdup (name);
if (! var->name)
goto fail; goto fail;
env->value = grub_strdup (val); var->value = grub_strdup (val);
if (! env->value) if (! var->value)
goto fail; goto fail;
grub_env_insert (grub_env_var_context, env); grub_env_insert (current_context, var);
return 0; return GRUB_ERR_NONE;
fail: fail:
grub_free (env->name); grub_free (var->name);
grub_free (env->value); grub_free (var->value);
grub_free (env); grub_free (var);
return grub_errno; return grub_errno;
} }
@ -244,92 +232,199 @@ grub_env_set (const char *var, const char *val)
char * char *
grub_env_get (const char *name) grub_env_get (const char *name)
{ {
struct grub_env_var *env; struct grub_env_var *var;
env = grub_env_find (name);
if (! env) var = grub_env_find (name);
if (! var)
return 0; return 0;
if (env->read_hook) if (var->read_hook)
return env->read_hook (env, env->value); return var->read_hook (var, var->value);
return env->value; return var->value;
} }
void void
grub_env_unset (const char *name) grub_env_unset (const char *name)
{ {
struct grub_env_var *env; struct grub_env_var *var;
env = grub_env_find (name);
if (! env) var = grub_env_find (name);
if (! var)
return; return;
/* XXX: It is not possible to unset variables with a read or write /* XXX: It is not possible to unset variables with a read or write
hook. */ hook. */
if (env->read_hook || env->write_hook) if (var->read_hook || var->write_hook)
return; return;
grub_env_remove (env); grub_env_remove (var);
grub_free (env->name); grub_free (var->name);
grub_free (env->value); grub_free (var->value);
grub_free (env); grub_free (var);
return;
} }
void void
grub_env_iterate (int (* func) (struct grub_env_var *var)) grub_env_iterate (int (*func) (struct grub_env_var *var))
{ {
struct grub_env_var *env = grub_env_context.sorted; struct grub_env_sorted_var *sorted_list = 0;
struct grub_env_var *var = grub_env_var_context->sorted; struct grub_env_sorted_var *sorted_var;
int i;
/* Initially these are the same. */ /* Add variables associated with this context into a sorted list. */
if (env == var) for (i = 0; i < HASHSZ; i++)
var = 0;
while (env || var)
{ {
struct grub_env_var **cur; struct grub_env_var *var;
/* Select the first name to be printed from the head of two for (var = current_context->vars[i]; var; var = var->next)
sorted lists. */ {
if (! env) struct grub_env_sorted_var *p, **q;
cur = &var;
else if (! var)
cur = &env;
else if (grub_strcmp (env->name, var->name) > 0)
cur = &var;
else
cur = &env;
if (func (*cur)) /* Ignore data slots. */
return; if (var->type == GRUB_ENV_VAR_DATA)
*cur = (*cur)->sort_next; continue;
sorted_var = grub_malloc (sizeof (*sorted_var));
if (! sorted_var)
goto fail;
sorted_var->var = var;
for (q = &sorted_list, p = *q; p; q = &((*q)->next), p = *q)
{
if (grub_strcmp (p->var->name, var->name) > 0)
break;
}
sorted_var->next = *q;
*q = sorted_var;
}
}
/* Iterate FUNC on the sorted list. */
for (sorted_var = sorted_list; sorted_var; sorted_var = sorted_var->next)
if (func (sorted_var->var))
break;
fail:
/* Free the sorted list. */
for (sorted_var = sorted_list; sorted_var; )
{
struct grub_env_sorted_var *tmp = sorted_var->next;
grub_free (sorted_var);
sorted_var = tmp;
} }
} }
grub_err_t grub_err_t
grub_register_variable_hook (const char *var, grub_register_variable_hook (const char *name,
grub_env_read_hook_t read_hook, grub_env_read_hook_t read_hook,
grub_env_write_hook_t write_hook) grub_env_write_hook_t write_hook)
{ {
struct grub_env_var *env = grub_env_find (var); struct grub_env_var *var = grub_env_find (name);
if (! env) if (! var)
{ {
char *val = grub_strdup (""); char *val = grub_strdup ("");
if (! val) if (! val)
return grub_errno; return grub_errno;
if (grub_env_set (var, val) != GRUB_ERR_NONE) if (grub_env_set (name, val) != GRUB_ERR_NONE)
return grub_errno; return grub_errno;
var = grub_env_find (name);
/* XXX Insert an assertion? */
} }
env = grub_env_find (var); var->read_hook = read_hook;
/* XXX Insert an assertion? */ var->write_hook = write_hook;
env->read_hook = read_hook;
env->write_hook = write_hook;
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
} }
static char *
mangle_data_slot_name (const char *name)
{
char *mangled_name;
mangled_name = grub_malloc (grub_strlen (name) + 2);
if (! mangled_name)
return 0;
grub_sprintf (mangled_name, "\e%s", name);
return mangled_name;
}
grub_err_t
grub_env_set_data_slot (const char *name, const void *ptr)
{
char *mangled_name;
struct grub_env_var *var;
mangled_name = mangle_data_slot_name (name);
if (! mangled_name)
goto fail;
/* If the variable does already exist, just update the variable. */
var = grub_env_find (mangled_name);
if (var)
{
var->value = (char *) ptr;
return GRUB_ERR_NONE;
}
/* The variable does not exist, so create a new one. */
var = grub_malloc (sizeof (*var));
if (! var)
goto fail;
grub_memset (var, 0, sizeof (*var));
var->type = GRUB_ENV_VAR_DATA;
var->name = mangled_name;
var->value = (char *) ptr;
grub_env_insert (current_context, var);
return GRUB_ERR_NONE;
fail:
grub_free (mangled_name);
return grub_errno;
}
void *
grub_env_get_data_slot (const char *name)
{
char *mangled_name;
void *ptr = 0;
mangled_name = mangle_data_slot_name (name);
if (! mangled_name)
goto fail;
ptr = grub_env_get (mangled_name);
grub_free (mangled_name);
fail:
return ptr;
}
void
grub_env_unset_data_slot (const char *name)
{
char *mangled_name;
mangled_name = mangle_data_slot_name (name);
if (! mangled_name)
return;
grub_env_unset (mangled_name);
grub_free (mangled_name);
}