/* Return the current timeout. If the variable "timeout" is not set or
invalid, return -1. */
int
grub_menu_get_timeout (void)
{
const char *val;
int timeout;
val = grub_env_get ("timeout");
if (! val)
return -1;
grub_error_push ();
timeout = (int) grub_strtoul (val, 0, 0);
/* If the value is invalid, unset the variable. */
if (grub_errno != GRUB_ERR_NONE)
{
grub_env_unset ("timeout");
grub_errno = GRUB_ERR_NONE;
timeout = -1;
}
grub_error_pop ();
return timeout;
}
/* Opens 'filename' with compression filters disabled. Optionally disables the
PUBKEY filter (that insists upon properly signed files) as well. PUBKEY
filter is restored before the function returns. */
static grub_file_t
open_envblk_file (char *filename,
enum grub_file_type type)
{
grub_file_t file;
char *buf = 0;
if (! filename)
{
const char *prefix;
int len;
prefix = grub_env_get ("prefix");
if (! prefix)
{
grub_error (GRUB_ERR_FILE_NOT_FOUND, N_("variable `%s' isn't set"), "prefix");
return 0;
}
len = grub_strlen (prefix);
buf = grub_malloc (len + 1 + sizeof (GRUB_ENVBLK_DEFCFG));
if (! buf)
return 0;
filename = buf;
grub_strcpy (filename, prefix);
filename[len] = '/';
grub_strcpy (filename + len + 1, GRUB_ENVBLK_DEFCFG);
}
file = grub_file_open (filename, type);
grub_free (buf);
return file;
}
grub_err_t
grub_script_return (grub_command_t cmd __attribute__((unused)),
int argc, char *argv[])
{
char *p;
unsigned long n;
if (! scope || argc > 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
/* TRANSLATORS: It's about not being
inside a function. "return" can be used only
in a function and this error occurs if it's used
anywhere else. */
N_("not in function body"));
if (argc == 0)
{
const char *t;
function_return = 1;
t = grub_env_get ("?");
if (!t)
return GRUB_ERR_NONE;
return grub_strtoul (t, NULL, 10);
}
n = grub_strtoul (argv[0], &p, 10);
if (grub_errno)
return grub_errno;
if (*p != '\0')
return grub_error (GRUB_ERR_BAD_ARGUMENT,
N_("unrecognized number"));
function_return = 1;
return n ? grub_error (n, N_("false")) : GRUB_ERR_NONE;
}
grub_err_t
grub_multiboot_set_video_mode (void)
{
grub_err_t err;
const char *modevar;
#if GRUB_MACHINE_HAS_VGA_TEXT
if (accepts_video)
#endif
{
modevar = grub_env_get ("gfxpayload");
if (! modevar || *modevar == 0)
err = grub_video_set_mode (DEFAULT_VIDEO_MODE, 0, 0);
else
{
char *tmp;
tmp = grub_xasprintf ("%s;" DEFAULT_VIDEO_MODE, modevar);
if (! tmp)
return grub_errno;
err = grub_video_set_mode (tmp, 0, 0);
grub_free (tmp);
}
}
#if GRUB_MACHINE_HAS_VGA_TEXT
else
err = grub_video_set_mode ("text", 0, 0);
#endif
return err;
}
/* Get the first entry number from the value of the environment variable NAME,
which is a space-separated list of non-negative integers. The entry number
which is returned is stripped from the value of NAME. If no entry number
can be found, -1 is returned. */
static int
get_and_remove_first_entry_number (const char *name)
{
const char *val;
char *tail;
int entry;
val = grub_env_get (name);
if (! val)
return -1;
grub_error_push ();
entry = (int) grub_strtoul (val, &tail, 0);
if (grub_errno == GRUB_ERR_NONE)
{
/* Skip whitespace to find the next digit. */
while (*tail && grub_isspace (*tail))
tail++;
grub_env_set (name, tail);
}
else
{
grub_env_unset (name);
grub_errno = GRUB_ERR_NONE;
entry = -1;
}
grub_error_pop ();
return entry;
}
int putvar (const char *str, grub_size_t len)
{
const char *var;
grub_size_t i;
for (i = 0; i < nallowed_strings; i++)
if (grub_strncmp (allowed_strings[i], str, len) == 0
&& allowed_strings[i][len] == 0)
{
break;
}
if (i == nallowed_strings)
return 0;
/* Enough for any number. */
if (len == 1 && str[0] == '#')
{
grub_snprintf (ptr, 30, "%u", scope->argv.argc);
ptr += grub_strlen (ptr);
return 0;
}
var = grub_env_get (allowed_strings[i]);
if (var)
ptr = grub_stpcpy (ptr, var);
return 0;
}
void dvprintf(const char *debug_context, const char *fmt, va_list args)
{
const char *debug_env = grub_env_get("debug");
if (debug_env && grub_strword(debug_env, debug_context))
grub_vprintf(fmt, args);
}
static PyObject *bits__getenv(PyObject *self, PyObject *args)
{
const char *key, *default_value = NULL;
const char *value;
if (!PyArg_ParseTuple(args, "s|s:getenv", &key, &default_value))
return NULL;
value = grub_env_get(key);
return Py_BuildValue("s", value ? value : default_value);
}
/* Get the icon for the specified class CLASS_NAME. If an icon for
CLASS_NAME already exists in the cache, then a reference to the cached
bitmap is returned. If it is not cached, then it is loaded and cached.
If no icon could be could for CLASS_NAME, then 0 is returned. */
static struct grub_video_bitmap *
get_icon_by_class (grub_gfxmenu_icon_manager_t mgr, const char *class_name)
{
/* First check the icon cache. */
icon_entry_t entry;
for (entry = mgr->cache.next; entry; entry = entry->next)
{
if (grub_strcmp (entry->class_name, class_name) == 0)
return entry->bitmap;
}
if (! mgr->theme_path)
return 0;
/* Otherwise, we search for an icon to load. */
char *theme_dir = grub_get_dirname (mgr->theme_path);
char *icons_dir;
struct grub_video_bitmap *icon;
icon = 0;
/* First try the theme's own icons, from "grub/themes/NAME/icons/" */
icons_dir = grub_resolve_relative_path (theme_dir, "icons/");
if (icons_dir)
{
icon = try_loading_icon (mgr, icons_dir, class_name);
grub_free (icons_dir);
}
grub_free (theme_dir);
if (! icon)
{
const char *icondir;
icondir = grub_env_get ("icondir");
if (icondir)
icon = try_loading_icon (mgr, icondir, class_name);
}
/* No icon was found. */
/* This should probably be noted in the cache, so that a search is not
performed each time an icon for CLASS_NAME is requested. */
if (! icon)
return 0;
/* Insert a new cache entry for this icon. */
entry = grub_malloc (sizeof (*entry));
if (! entry)
{
grub_video_bitmap_destroy (icon);
return 0;
}
entry->class_name = grub_strdup (class_name);
entry->bitmap = icon;
entry->next = mgr->cache.next;
mgr->cache.next = entry; /* Link it into the cache. */
return entry->bitmap;
}
static void
pxe_find (grub_uitree_t node)
{
const char *mac, *ip;
mac = grub_env_get ("net_pxe_mac");
ip = grub_env_get ("net_pxe_ip");
node = node->child;
while (node)
{
if ((! grub_strcmp (node->name, "mac")) && (mac))
match_string (node, mac);
else if ((! grub_strcmp (node->name, "ip")) && (ip))
match_string (node, ip);
node = node->next;
}
}
/* Parse ARG and return the textual representation. Add strings are
concatenated and all values of the variables are filled in. */
char *
grub_script_execute_argument_to_string (struct grub_script_arg *arg)
{
int size = 0;
char *val;
char *chararg;
struct grub_script_arg *argi;
/* First determine the size of the argument. */
for (argi = arg; argi; argi = argi->next)
{
if (argi->type == 1)
{
val = grub_env_get (argi->str);
if (val)
size += grub_strlen (val);
}
else
size += grub_strlen (argi->str);
}
/* Create the argument. */
chararg = grub_malloc (size + 1);
if (! chararg)
return 0;
*chararg = '\0';
/* First determine the size of the argument. */
for (argi = arg; argi; argi = argi->next)
{
if (argi->type == 1)
{
val = grub_env_get (argi->str);
if (val)
grub_strcat (chararg, val);
}
else
grub_strcat (chararg, argi->str);
}
return chararg;
}
grub_uitree_t
grub_uitree_load_string (grub_uitree_t root, char *buf, int flags)
{
char *prefix;
prefix = grub_env_get ("prefix");
if (! prefix)
prefix = "";
return grub_uitree_load_buf (prefix, grub_strlen (prefix),
root, buf, grub_strlen (buf), flags);
}
static void
menu_init (int entry, grub_menu_t menu, int nested)
{
struct grub_term_output *term;
int gfxmenu = 0;
FOR_ACTIVE_TERM_OUTPUTS(term)
if (grub_strcmp (term->name, "gfxterm") == 0)
{
if (grub_env_get ("theme"))
{
if (!grub_gfxmenu_try_hook)
{
grub_dl_load ("gfxmenu");
grub_print_error ();
}
if (grub_gfxmenu_try_hook)
{
grub_err_t err;
err = grub_gfxmenu_try_hook (entry, menu, nested);
if(!err)
{
gfxmenu = 1;
break;
}
}
else
grub_error (GRUB_ERR_BAD_MODULE,
N_("module `%s' isn't loaded"),
"gfxmenu");
grub_print_error ();
grub_wait_after_message ();
}
grub_errno = GRUB_ERR_NONE;
grub_gfxterm_fullscreen ();
break;
}
FOR_ACTIVE_TERM_OUTPUTS(term)
{
grub_err_t err;
if (grub_strcmp (term->name, "gfxterm") == 0 && gfxmenu)
continue;
err = grub_menu_try_text (term, entry, menu, nested);
if(!err)
continue;
grub_print_error ();
grub_errno = GRUB_ERR_NONE;
}
}
static grub_err_t
grub_linux_boot (void)
{
struct linux_kernel_params *params;
struct linux_kernel_header *lh;
char *prot_code;
char *bootpath;
grub_ssize_t len;
bootpath = grub_env_get ("root");
if (bootpath)
grub_ieee1275_set_property (grub_ieee1275_chosen,
"bootpath", bootpath,
grub_strlen (bootpath) + 1,
&len);
params = (struct linux_kernel_params *) GRUB_OFW_LINUX_PARAMS_ADDR;
lh = (struct linux_kernel_header *) params;
grub_memset ((char *) params, 0, GRUB_OFW_LINUX_CL_OFFSET);
params->alt_mem = grub_mmap_get_upper () >> 10;
params->ext_mem = params->alt_mem;
lh->cmd_line_ptr = (char *)
(GRUB_OFW_LINUX_PARAMS_ADDR + GRUB_OFW_LINUX_CL_OFFSET);
params->cl_magic = GRUB_LINUX_CL_MAGIC;
params->cl_offset = GRUB_OFW_LINUX_CL_OFFSET;
{
grub_term_output_t term;
int found = 0;
FOR_ACTIVE_TERM_OUTPUTS(term)
if (grub_strcmp (term->name, "ofconsole") == 0)
{
grub_uint16_t pos = grub_term_getxy (term);
params->video_cursor_x = pos >> 8;
params->video_cursor_y = pos & 0xff;
params->video_width = grub_term_width (term);
params->video_height = grub_term_height (term);
found = 1;
break;
}
if (!found)
{
params->video_cursor_x = 0;
params->video_cursor_y = 0;
params->video_width = 80;
params->video_height = 25;
}
}
static int
is_authenticated (const char *userlist)
{
struct is_authenticated_closure c;
c.userlist = userlist;
c.superusers = grub_env_get ("superusers");
if (!c.superusers)
return 1;
return grub_list_iterate (GRUB_AS_LIST (users), is_authenticated_hook, &c);
}
static grub_err_t
grub_cmd_next (grub_extcmd_context_t ctxt, int argc, char **args)
{
struct grub_arg_list *state = ctxt->state;
char *p, *root = NULL, *part_name = NULL, *part_guid = NULL;
/* TODO: Add a uuid parser and a command line flag for providing type. */
grub_gpt_part_type_t part_type = GRUB_GPT_PARTITION_TYPE_USR_X86_64;
if (!state[NEXT_SET_DEVICE].set || !state[NEXT_SET_UUID].set)
{
grub_error (GRUB_ERR_INVALID_COMMAND, N_("-d and -u are required"));
goto done;
}
if (argc == 0)
root = grub_strdup (grub_env_get ("root"));
else if (argc == 1)
root = grub_strdup (args[0]);
else
{
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("unexpected arguments"));
goto done;
}
if (!root)
goto done;
/* To make using $root practical strip off the partition name. */
p = grub_strchr (root, ',');
if (p)
*p = '\0';
if (grub_find_next (root, &part_type, &part_name, &part_guid))
goto done;
if (grub_env_set (state[NEXT_SET_DEVICE].arg, part_name))
goto done;
if (grub_env_set (state[NEXT_SET_UUID].arg, part_guid))
goto done;
grub_errno = GRUB_ERR_NONE;
done:
grub_free (root);
grub_free (part_name);
grub_free (part_guid);
return grub_errno;
}
grub_autolist_t
grub_autolist_load (const char *name)
{
grub_autolist_t result = 0;
const char *prefix;
prefix = grub_env_get ("prefix");
if (prefix)
{
char *filename;
filename = grub_xasprintf ("%s/%s", prefix, name);
if (filename)
{
grub_file_t file;
file = grub_file_open (filename);
if (file)
{
char *buf = NULL;
for (;; grub_free (buf))
{
char *p;
buf = grub_getline (file);
if (! buf)
break;
if (! grub_isgraph (buf[0]))
continue;
p = grub_strchr (buf, ':');
if (! p)
continue;
*p = '\0';
while (*++p == ' ')
;
insert_item (&result, buf, p);
}
grub_file_close (file);
}
grub_free (filename);
}
}
return result;
}
/* Get the entry number from the variable NAME. */
static int
get_entry_number (grub_menu_t menu, const char *name)
{
const char *val;
int entry;
val = grub_env_get (name);
if (! val)
return -1;
grub_error_push ();
entry = (int) grub_strtoul (val, 0, 0);
if (grub_errno == GRUB_ERR_BAD_NUMBER)
{
/* See if the variable matches the title of a menu entry. */
grub_menu_entry_t e = menu->entry_list;
int i;
grub_errno = GRUB_ERR_NONE;
for (i = 0; e; i++)
{
if (menuentry_eq (e->title, val)
|| menuentry_eq (e->id, val))
{
entry = i;
break;
}
e = e->next;
}
if (! e)
entry = -1;
}
if (grub_errno != GRUB_ERR_NONE)
{
grub_errno = GRUB_ERR_NONE;
entry = -1;
}
grub_error_pop ();
return entry;
}
void
grub_real_dprintf (const char *file, const int line, const char *condition,
const char *fmt, ...)
{
va_list args;
const char *debug = grub_env_get ("debug");
if (! debug)
return;
if (grub_strword (debug, "all") || grub_strword (debug, condition))
{
grub_printf ("%s:%d: ", file, line);
va_start (args, fmt);
grub_vprintf (fmt, args);
va_end (args);
}
}
static void
grub_gettext_init_ext (const char *lang)
{
char *mo_file;
char *locale_dir;
locale_dir = grub_env_get ("locale_dir");
if (locale_dir == NULL)
{
grub_dprintf ("gettext", "locale_dir variable is not set up.\n");
return;
}
fd_mo = NULL;
/* mo_file e.g.: /boot/grub/locale/ca.mo */
mo_file = grub_xasprintf ("%s/%s.mo", locale_dir, lang);
if (!mo_file)
return;
fd_mo = grub_mofile_open (mo_file);
/* Will try adding .gz as well. */
if (fd_mo == NULL)
{
grub_free (mo_file);
mo_file = grub_xasprintf ("%s.gz", mo_file);
if (!mo_file)
return;
fd_mo = grub_mofile_open (mo_file);
}
if (fd_mo)
{
grub_gettext_offsetoriginal =
grub_gettext_get_info (GETTEXT_OFFSET_ORIGINAL);
grub_gettext_max = grub_gettext_get_info (GETTEXT_NUMBER_OF_STRINGS);
grub_gettext_original = grub_gettext;
grub_gettext = grub_gettext_translate;
}
}
/* Execute an if statement. */
grub_err_t
grub_script_execute_cmdif (struct grub_script_cmd *cmd)
{
struct grub_script_cmdif *cmdif = (struct grub_script_cmdif *) cmd;
char *result;
/* Check if the commands results in a true or a false. The value is
read from the env variable `?'. */
grub_script_execute_cmd (cmdif->exec_to_evaluate);
result = grub_env_get ("?");
grub_errno = GRUB_ERR_NONE;
/* Execute the `if' or the `else' part depending on the value of
`?'. */
if (result && ! grub_strcmp (result, "0"))
return grub_script_execute_cmd (cmdif->exec_on_true);
else
return grub_script_execute_cmd (cmdif->exec_on_false);
}
/* Opens 'filename' with compression filters disabled. Optionally disables the
PUBKEY filter (that insists upon properly signed files) as well. PUBKEY
filter is restored before the function returns. */
static grub_file_t
open_envblk_file (char *filename, int untrusted)
{
grub_file_t file;
char *buf = 0;
if (! filename)
{
const char *prefix;
int len;
prefix = grub_env_get ("prefix");
if (! prefix)
{
grub_error (GRUB_ERR_FILE_NOT_FOUND, N_("variable `%s' isn't set"), "prefix");
return 0;
}
len = grub_strlen (prefix);
buf = grub_malloc (len + 1 + sizeof (GRUB_ENVBLK_DEFCFG));
if (! buf)
return 0;
filename = buf;
grub_strcpy (filename, prefix);
filename[len] = '/';
grub_strcpy (filename + len + 1, GRUB_ENVBLK_DEFCFG);
}
/* The filters that are disabled will be re-enabled by the call to
grub_file_open() after this particular file is opened. */
grub_file_filter_disable_compression ();
if (untrusted)
grub_file_filter_disable_pubkey ();
file = grub_file_open (filename);
grub_free (buf);
return file;
}
static int
grub_get_root_biosnumber_default (void)
{
char *biosnum;
int ret = -1;
grub_device_t dev;
biosnum = grub_env_get ("biosnum");
if (biosnum)
return grub_strtoul (biosnum, 0, 0);
dev = grub_device_open (0);
if (dev && dev->disk && dev->disk->dev
&& dev->disk->dev->id == GRUB_DISK_DEVICE_BIOSDISK_ID)
ret = (int) dev->disk->id;
if (dev)
grub_device_close (dev);
return ret;
}
grub_device_t
grub_device_open (const char *name)
{
grub_disk_t disk = 0;
grub_device_t dev = 0;
if (! name)
{
name = grub_env_get ("root");
if (*name == '\0')
{
grub_error (GRUB_ERR_BAD_DEVICE, "no device is set");
goto fail;
}
}
dev = grub_malloc (sizeof (*dev));
if (! dev)
goto fail;
/* Try to open a disk. */
disk = grub_disk_open (name);
if (! disk)
goto fail;
dev->disk = disk;
dev->net = 0; /* FIXME */
return dev;
fail:
if (disk)
grub_disk_close (disk);
grub_free (dev);
return 0;
}
grub_device_t
grub_device_open (const char *name)
{
grub_device_t dev = 0;
if (! name)
{
name = grub_env_get ("root");
if (name == NULL || *name == '\0')
{
grub_error (GRUB_ERR_BAD_DEVICE, N_("variable `%s' isn't set"), "root");
goto fail;
}
}
dev = grub_malloc (sizeof (*dev));
if (! dev)
goto fail;
dev->net = NULL;
/* Try to open a disk. */
dev->disk = grub_disk_open (name);
if (dev->disk)
return dev;
if (grub_net_open && grub_errno == GRUB_ERR_UNKNOWN_DEVICE)
{
grub_errno = GRUB_ERR_NONE;
dev->net = grub_net_open (name);
}
if (dev->net)
return dev;
fail:
grub_free (dev);
return 0;
}
int getlen (const char *str, grub_size_t len)
{
const char *var;
grub_size_t i;
for (i = 0; i < nallowed_strings; i++)
if (grub_strncmp (allowed_strings[i], str, len) == 0
&& allowed_strings[i][len] == 0)
break;
if (i == nallowed_strings)
return 0;
/* Enough for any number. */
if (len == 1 && str[0] == '#')
{
additional_len += 30;
return 0;
}
var = grub_env_get (allowed_strings[i]);
if (var)
additional_len += grub_strlen (var);
return 0;
}
grub_err_t
grub_script_return (grub_command_t cmd __attribute__((unused)),
int argc, char *argv[])
{
char *p;
unsigned long n;
if (! scope || argc > 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "not in function scope");
if (argc == 0)
{
function_return = 1;
return grub_strtoul (grub_env_get ("?"), NULL, 10);
}
n = grub_strtoul (argv[0], &p, 10);
if (*p != '\0')
return grub_error (GRUB_ERR_BAD_ARGUMENT, "bad argument");
function_return = 1;
return n ? grub_error (GRUB_ERR_TEST_FAILURE, "false") : GRUB_ERR_NONE;
}
/* FIXME: Previously 't' changed to text menu is it necessary? */
static grub_err_t
grub_gfxmenu_try (int entry, grub_menu_t menu, int nested)
{
grub_gfxmenu_view_t view = NULL;
const char *theme_path;
struct grub_menu_viewer *instance;
grub_err_t err;
struct grub_video_mode_info mode_info;
theme_path = grub_env_get ("theme");
if (! theme_path)
return grub_error (GRUB_ERR_FILE_NOT_FOUND, N_("variable `%s' isn't set"),
"theme");
instance = grub_zalloc (sizeof (*instance));
if (!instance)
return grub_errno;
err = grub_video_get_info (&mode_info);
if (err)
return err;
if (!cached_view || grub_strcmp (cached_view->theme_path, theme_path) != 0
|| cached_view->screen.width != mode_info.width
|| cached_view->screen.height != mode_info.height)
{
grub_free (cached_view);
/* Create the view. */
cached_view = grub_gfxmenu_view_new (theme_path, mode_info.width,
mode_info.height);
}
if (! cached_view)
{
grub_free (instance);
return grub_errno;
}
view = cached_view;
view->double_repaint = (mode_info.mode_type
& GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED)
&& !(mode_info.mode_type & GRUB_VIDEO_MODE_TYPE_UPDATING_SWAP);
view->selected = entry;
view->menu = menu;
view->nested = nested;
view->first_timeout = -1;
grub_video_set_viewport (0, 0, mode_info.width, mode_info.height);
if (view->double_repaint)
{
grub_video_swap_buffers ();
grub_video_set_viewport (0, 0, mode_info.width, mode_info.height);
}
grub_gfxmenu_view_draw (view);
instance->data = view;
instance->set_chosen_entry = grub_gfxmenu_set_chosen_entry;
instance->fini = grub_gfxmenu_viewer_fini;
instance->print_timeout = grub_gfxmenu_print_timeout;
instance->clear_timeout = grub_gfxmenu_clear_timeout;
grub_menu_register_viewer (instance);
return GRUB_ERR_NONE;
}
static grub_err_t
grub_linux_boot (void)
{
grub_err_t err = 0;
const char *modevar;
char *tmp;
struct grub_relocator32_state state;
void *real_mode_mem;
struct grub_linux_boot_ctx ctx = {
.real_mode_target = 0
};
grub_size_t mmap_size;
grub_size_t cl_offset;
#ifdef GRUB_MACHINE_IEEE1275
{
const char *bootpath;
grub_ssize_t len;
bootpath = grub_env_get ("root");
if (bootpath)
grub_ieee1275_set_property (grub_ieee1275_chosen,
"bootpath", bootpath,
grub_strlen (bootpath) + 1,
&len);
linux_params.ofw_signature = GRUB_LINUX_OFW_SIGNATURE;
linux_params.ofw_num_items = 1;
linux_params.ofw_cif_handler = (grub_uint32_t) grub_ieee1275_entry_fn;
linux_params.ofw_idt = 0;
}
#endif
modevar = grub_env_get ("gfxpayload");
/* Now all graphical modes are acceptable.
May change in future if we have modes without framebuffer. */
if (modevar && *modevar != 0)
{
tmp = grub_xasprintf ("%s;" DEFAULT_VIDEO_MODE, modevar);
if (! tmp)
return grub_errno;
#if ACCEPTS_PURE_TEXT
err = grub_video_set_mode (tmp, 0, 0);
#else
err = grub_video_set_mode (tmp, GRUB_VIDEO_MODE_TYPE_PURE_TEXT, 0);
#endif
grub_free (tmp);
}
else /* We can't go back to text mode from coreboot fb. */
#ifdef GRUB_MACHINE_COREBOOT
if (grub_video_get_driver_id () == GRUB_VIDEO_DRIVER_COREBOOT)
err = GRUB_ERR_NONE;
else
#endif
{
#if ACCEPTS_PURE_TEXT
err = grub_video_set_mode (DEFAULT_VIDEO_MODE, 0, 0);
#else
err = grub_video_set_mode (DEFAULT_VIDEO_MODE,
GRUB_VIDEO_MODE_TYPE_PURE_TEXT, 0);
#endif
}
if (err)
{
grub_print_error ();
grub_puts_ (N_("Booting in blind mode"));
grub_errno = GRUB_ERR_NONE;
}
if (grub_linux_setup_video (&linux_params))
{
#if defined (GRUB_MACHINE_PCBIOS) || defined (GRUB_MACHINE_COREBOOT) || defined (GRUB_MACHINE_QEMU)
linux_params.have_vga = GRUB_VIDEO_LINUX_TYPE_TEXT;
linux_params.video_mode = 0x3;
#else
linux_params.have_vga = 0;
linux_params.video_mode = 0;
linux_params.video_width = 0;
linux_params.video_height = 0;
#endif
}
#ifndef GRUB_MACHINE_IEEE1275
if (linux_params.have_vga == GRUB_VIDEO_LINUX_TYPE_TEXT)
#endif
{
grub_term_output_t term;
int found = 0;
FOR_ACTIVE_TERM_OUTPUTS(term)
if (grub_strcmp (term->name, "vga_text") == 0
|| grub_strcmp (term->name, "console") == 0
|| grub_strcmp (term->name, "ofconsole") == 0)
{
struct grub_term_coordinate pos = grub_term_getxy (term);
linux_params.video_cursor_x = pos.x;
linux_params.video_cursor_y = pos.y;
linux_params.video_width = grub_term_width (term);
linux_params.video_height = grub_term_height (term);
found = 1;
break;
}
if (!found)
{
linux_params.video_cursor_x = 0;
linux_params.video_cursor_y = 0;
linux_params.video_width = 80;
linux_params.video_height = 25;
}
}
mmap_size = find_mmap_size ();
/* Make sure that each size is aligned to a page boundary. */
cl_offset = ALIGN_UP (mmap_size + sizeof (linux_params), 4096);
if (cl_offset < ((grub_size_t) linux_params.setup_sects << GRUB_DISK_SECTOR_BITS))
cl_offset = ALIGN_UP ((grub_size_t) (linux_params.setup_sects
<< GRUB_DISK_SECTOR_BITS), 4096);
ctx.real_size = ALIGN_UP (cl_offset + maximal_cmdline_size, 4096);
#ifdef GRUB_MACHINE_EFI
efi_mmap_size = find_efi_mmap_size ();
if (efi_mmap_size == 0)
return grub_errno;
#endif
grub_dprintf ("linux", "real_size = %x, mmap_size = %x\n",
(unsigned) ctx.real_size, (unsigned) mmap_size);
#ifdef GRUB_MACHINE_EFI
grub_efi_mmap_iterate (grub_linux_boot_mmap_find, &ctx, 1);
if (! ctx.real_mode_target)
grub_efi_mmap_iterate (grub_linux_boot_mmap_find, &ctx, 0);
#else
grub_mmap_iterate (grub_linux_boot_mmap_find, &ctx);
#endif
grub_dprintf ("linux", "real_mode_target = %lx, real_size = %x, efi_mmap_size = %x\n",
(unsigned long) ctx.real_mode_target,
(unsigned) ctx.real_size,
(unsigned) efi_mmap_size);
if (! ctx.real_mode_target)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "cannot allocate real mode pages");
{
grub_relocator_chunk_t ch;
err = grub_relocator_alloc_chunk_addr (relocator, &ch,
ctx.real_mode_target,
(ctx.real_size + efi_mmap_size));
if (err)
return err;
real_mode_mem = get_virtual_current_address (ch);
}
efi_mmap_buf = (grub_uint8_t *) real_mode_mem + ctx.real_size;
grub_dprintf ("linux", "real_mode_mem = %p\n",
real_mode_mem);
ctx.params = real_mode_mem;
*ctx.params = linux_params;
ctx.params->cmd_line_ptr = ctx.real_mode_target + cl_offset;
grub_memcpy ((char *) ctx.params + cl_offset, linux_cmdline,
maximal_cmdline_size);
grub_dprintf ("linux", "code32_start = %x\n",
(unsigned) ctx.params->code32_start);
ctx.e820_num = 0;
if (grub_mmap_iterate (grub_linux_boot_mmap_fill, &ctx))
return grub_errno;
ctx.params->mmap_size = ctx.e820_num;
#ifdef GRUB_MACHINE_EFI
{
grub_efi_uintn_t efi_desc_size;
grub_size_t efi_mmap_target;
grub_efi_uint32_t efi_desc_version;
err = grub_efi_finish_boot_services (&efi_mmap_size, efi_mmap_buf, NULL,
&efi_desc_size, &efi_desc_version);
if (err)
return err;
/* Note that no boot services are available from here. */
efi_mmap_target = ctx.real_mode_target
+ ((grub_uint8_t *) efi_mmap_buf - (grub_uint8_t *) real_mode_mem);
/* Pass EFI parameters. */
if (grub_le_to_cpu16 (ctx.params->version) >= 0x0208)
{
ctx.params->v0208.efi_mem_desc_size = efi_desc_size;
ctx.params->v0208.efi_mem_desc_version = efi_desc_version;
ctx.params->v0208.efi_mmap = efi_mmap_target;
ctx.params->v0208.efi_mmap_size = efi_mmap_size;
#ifdef __x86_64__
ctx.params->v0208.efi_mmap_hi = (efi_mmap_target >> 32);
#endif
}
else if (grub_le_to_cpu16 (ctx.params->version) >= 0x0206)
static grub_err_t
grub_linux_setup_video (struct linux_kernel_params *params)
{
struct grub_video_mode_info mode_info;
void *framebuffer;
grub_err_t err;
grub_video_driver_id_t driver_id;
const char *gfxlfbvar = grub_env_get ("gfxpayloadforcelfb");
driver_id = grub_video_get_driver_id ();
if (driver_id == GRUB_VIDEO_DRIVER_NONE)
return 1;
err = grub_video_get_info_and_fini (&mode_info, &framebuffer);
if (err)
{
grub_errno = GRUB_ERR_NONE;
return 1;
}
params->lfb_width = mode_info.width;
params->lfb_height = mode_info.height;
params->lfb_depth = mode_info.bpp;
params->lfb_line_len = mode_info.pitch;
params->lfb_base = (grub_size_t) framebuffer;
params->lfb_size = ALIGN_UP (params->lfb_line_len * params->lfb_height, 65536);
params->red_mask_size = mode_info.red_mask_size;
params->red_field_pos = mode_info.red_field_pos;
params->green_mask_size = mode_info.green_mask_size;
params->green_field_pos = mode_info.green_field_pos;
params->blue_mask_size = mode_info.blue_mask_size;
params->blue_field_pos = mode_info.blue_field_pos;
params->reserved_mask_size = mode_info.reserved_mask_size;
params->reserved_field_pos = mode_info.reserved_field_pos;
if (gfxlfbvar && (gfxlfbvar[0] == '1' || gfxlfbvar[0] == 'y'))
params->have_vga = GRUB_VIDEO_LINUX_TYPE_SIMPLE;
else
{
switch (driver_id)
{
case GRUB_VIDEO_DRIVER_VBE:
params->lfb_size >>= 16;
params->have_vga = GRUB_VIDEO_LINUX_TYPE_VESA;
break;
case GRUB_VIDEO_DRIVER_EFI_UGA:
case GRUB_VIDEO_DRIVER_EFI_GOP:
params->have_vga = GRUB_VIDEO_LINUX_TYPE_EFIFB;
break;
/* FIXME: check if better id is available. */
case GRUB_VIDEO_DRIVER_SM712:
case GRUB_VIDEO_DRIVER_SIS315PRO:
case GRUB_VIDEO_DRIVER_VGA:
case GRUB_VIDEO_DRIVER_CIRRUS:
case GRUB_VIDEO_DRIVER_BOCHS:
case GRUB_VIDEO_DRIVER_RADEON_FULOONG2E:
case GRUB_VIDEO_DRIVER_RADEON_YEELOONG3A:
case GRUB_VIDEO_DRIVER_IEEE1275:
case GRUB_VIDEO_DRIVER_COREBOOT:
/* Make gcc happy. */
case GRUB_VIDEO_DRIVER_XEN:
case GRUB_VIDEO_DRIVER_SDL:
case GRUB_VIDEO_DRIVER_NONE:
case GRUB_VIDEO_ADAPTER_CAPTURE:
params->have_vga = GRUB_VIDEO_LINUX_TYPE_SIMPLE;
break;
}
}
#ifdef GRUB_MACHINE_PCBIOS
/* VESA packed modes may come with zeroed mask sizes, which need
to be set here according to DAC Palette width. If we don't,
this results in Linux displaying a black screen. */
if (driver_id == GRUB_VIDEO_DRIVER_VBE && mode_info.bpp <= 8)
{
struct grub_vbe_info_block controller_info;
int status;
int width = 8;
status = grub_vbe_bios_get_controller_info (&controller_info);
if (status == GRUB_VBE_STATUS_OK &&
(controller_info.capabilities & GRUB_VBE_CAPABILITY_DACWIDTH))
status = grub_vbe_bios_set_dac_palette_width (&width);
if (status != GRUB_VBE_STATUS_OK)
/* 6 is default after mode reset. */
width = 6;
params->red_mask_size = params->green_mask_size
= params->blue_mask_size = width;
params->reserved_mask_size = 0;
}
#endif
return GRUB_ERR_NONE;
}
