← Back to branch summary

~hamo/ubuntu/precise/grub2/grub2.hi_res

« back to all changes in this revision

Viewing changes to grub-core/efiemu/main.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson, Colin Watson, Evan Broder, Mario Limonciello
  • Date: 2010-11-24 13:59:55 UTC
  • mfrom: (1.17.6 upstream) (17.6.15 experimental)
  • Revision ID: james.westby@ubuntu.com-20101124135955-r6ii5sepayr7jt53
Tags: 1.99~20101124-1ubuntu1
https://launchpad.net/bugs/677758
[ Colin Watson ]
* Resynchronise with Debian experimental.  Remaining changes:
  - Adjust for default Ubuntu boot options ("quiet splash").
  - Default to hiding the menu; holding down Shift at boot will show it.
  - Set a monochromatic theme for Ubuntu.
  - Apply Ubuntu GRUB Legacy changes to legacy update-grub script: title,
    recovery mode, quiet option, tweak how memtest86+ is displayed, and
    use UUIDs where appropriate.
  - Fix backslash-escaping in merge_debconf_into_conf.
  - Remove "GNU/Linux" from default distributor string.
  - Add crashkernel= options if kdump and makedumpfile are available.
  - If other operating systems are installed, then automatically unhide
    the menu.  Otherwise, if GRUB_HIDDEN_TIMEOUT is 0, then use keystatus
    if available to check whether Shift is pressed.  If it is, show the
    menu, otherwise boot immediately.  If keystatus is not available, then
    fall back to a short delay interruptible with Escape.
  - Allow Shift to interrupt 'sleep --interruptible'.
  - Don't display introductory message about line editing unless we're
    actually offering a shell prompt.  Don't clear the screen just before
    booting if we never drew the menu in the first place.
  - Remove some verbose messages printed before reading the configuration
    file.
  - Suppress progress messages as the kernel and initrd load for
    non-recovery kernel menu entries.
  - Change prepare_grub_to_access_device to handle filesystems
    loop-mounted on file images.
  - Ignore devices loop-mounted from files in 10_linux.
  - Show the boot menu if the previous boot failed, that is if it failed
    to get to the end of one of the normal runlevels.
  - Don't generate /boot/grub/device.map during grub-install or
    grub-mkconfig by default.
  - Adjust upgrade version checks for Ubuntu.
  - Don't display "GRUB loading" unless Shift is held down.
  - Adjust versions of grub-doc and grub-legacy-doc conflicts to tolerate
    our backport of the grub-doc split.
  - Fix LVM/RAID probing in the absence of /boot/grub/device.map.
  - Look for .mo files in /usr/share/locale-langpack as well, in
    preference.
  - Make sure GRUB_TIMEOUT isn't quoted unnecessarily.
  - Probe all devices in 'grub-probe --target=drive' if
    /boot/grub/device.map is missing.
  - Build-depend on qemu-kvm rather than qemu-system for grub-pc tests.
  - Use qemu rather than qemu-system-i386.
  - Program vesafb on BIOS systems rather than efifb.
  - Add a grub-rescue-efi-amd64 package containing a rescue CD-ROM image
    for EFI-AMD64.
  - On Wubi, don't ask for an install device, but just update wubildr
    using the diverted grub-install.
  - When embedding the core image in a post-MBR gap, check for and avoid
    sectors matching any of a list of known signatures.
  - Disable video_bochs and video_cirrus on PC BIOS systems, as probing
    PCI space seems to break on some systems.
* Downgrade "ACPI shutdown failed" error to a debug message, since it can
  cause spurious test failures.

[ Evan Broder ]
* Enable lua from grub-extras.
* Incorporate the bitop library into lua.
* Add enum_pci function to grub module in lua.
* Switch back to gfxpayload=keep by default, unless the video hardware
  is known to not support it.

[ Mario Limonciello ]
* Built part_msdos and vfat into bootx64.efi (LP: #677758)

Show diffs side-by-side

added added

removed removed

Lines of Context:
grub-core/efiemu/main.c
 
1
/*
 
2
 *  GRUB  --  GRand Unified Bootloader
 
3
 *  Copyright (C) 2009  Free Software Foundation, Inc.
 
4
 *
 
5
 *  GRUB is free software: you can redistribute it and/or modify
 
6
 *  it under the terms of the GNU General Public License as published by
 
7
 *  the Free Software Foundation, either version 3 of the License, or
 
8
 *  (at your option) any later version.
 
9
 *
 
10
 *  GRUB is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
 
17
 */
 
18
 
 
19
/* This is an emulation of EFI runtime services.
 
20
   This allows a more uniform boot on i386 machines.
 
21
   As it emulates only runtime service it isn't able
 
22
   to chainload EFI bootloader on non-EFI system. */
 
23
 
 
24
 
 
25
#include <grub/file.h>
 
26
#include <grub/err.h>
 
27
#include <grub/normal.h>
 
28
#include <grub/mm.h>
 
29
#include <grub/dl.h>
 
30
#include <grub/misc.h>
 
31
#include <grub/efiemu/efiemu.h>
 
32
#include <grub/command.h>
 
33
#include <grub/i18n.h>
 
34
 
 
35
/* System table. Two version depending on mode */
 
36
grub_efi_system_table32_t *grub_efiemu_system_table32 = 0;
 
37
grub_efi_system_table64_t *grub_efiemu_system_table64 = 0;
 
38
/* Modules may need to execute some actions after memory allocation happens */
 
39
static struct grub_efiemu_prepare_hook *efiemu_prepare_hooks = 0;
 
40
/* Linked list of configuration tables */
 
41
static struct grub_efiemu_configuration_table *efiemu_config_tables = 0;
 
42
static int prepared = 0;
 
43
 
 
44
/* Free all allocated space */
 
45
grub_err_t
 
46
grub_efiemu_unload (void)
 
47
{
 
48
  struct grub_efiemu_configuration_table *cur, *d;
 
49
  struct grub_efiemu_prepare_hook *curhook, *d2;
 
50
  grub_efiemu_loadcore_unload ();
 
51
 
 
52
  grub_efiemu_mm_unload ();
 
53
 
 
54
  for (cur = efiemu_config_tables; cur;)
 
55
    {
 
56
      d = cur->next;
 
57
      if (cur->unload)
 
58
        cur->unload (cur->data);
 
59
      grub_free (cur);
 
60
      cur = d;
 
61
    }
 
62
  efiemu_config_tables = 0;
 
63
 
 
64
  for (curhook = efiemu_prepare_hooks; curhook;)
 
65
    {
 
66
      d2 = curhook->next;
 
67
      if (curhook->unload)
 
68
        curhook->unload (curhook->data);
 
69
      grub_free (curhook);
 
70
      curhook = d2;
 
71
    }
 
72
  efiemu_prepare_hooks = 0;
 
73
 
 
74
  prepared = 0;
 
75
 
 
76
  return GRUB_ERR_NONE;
 
77
}
 
78
 
 
79
/* Remove previously registered table from the list */
 
80
grub_err_t
 
81
grub_efiemu_unregister_configuration_table (grub_efi_guid_t guid)
 
82
{
 
83
  struct grub_efiemu_configuration_table *cur, *prev;
 
84
 
 
85
  /* Special treating if head is to remove */
 
86
  while (efiemu_config_tables
 
87
         && !grub_memcmp (&(efiemu_config_tables->guid), &guid, sizeof (guid)))
 
88
    {
 
89
      if (efiemu_config_tables->unload)
 
90
          efiemu_config_tables->unload (efiemu_config_tables->data);
 
91
        cur = efiemu_config_tables->next;
 
92
        grub_free (efiemu_config_tables);
 
93
        efiemu_config_tables = cur;
 
94
    }
 
95
  if (!efiemu_config_tables)
 
96
    return GRUB_ERR_NONE;
 
97
 
 
98
  /* Remove from chain */
 
99
  for (prev = efiemu_config_tables, cur = prev->next; cur;)
 
100
    if (grub_memcmp (&(cur->guid), &guid, sizeof (guid)) == 0)
 
101
      {
 
102
        if (cur->unload)
 
103
          cur->unload (cur->data);
 
104
        prev->next = cur->next;
 
105
        grub_free (cur);
 
106
        cur = prev->next;
 
107
      }
 
108
    else
 
109
      {
 
110
        prev = cur;
 
111
        cur = cur->next;
 
112
      }
 
113
  return GRUB_ERR_NONE;
 
114
}
 
115
 
 
116
grub_err_t
 
117
grub_efiemu_register_prepare_hook (grub_err_t (*hook) (void *data),
 
118
                                   void (*unload) (void *data),
 
119
                                   void *data)
 
120
{
 
121
  struct grub_efiemu_prepare_hook *nhook;
 
122
  if (! hook)
 
123
    return grub_error (GRUB_ERR_BAD_ARGUMENT, "you must supply the hook");
 
124
  nhook = (struct grub_efiemu_prepare_hook *) grub_malloc (sizeof (*nhook));
 
125
  if (! nhook)
 
126
    return grub_error (GRUB_ERR_OUT_OF_MEMORY, "couldn't prepare hook");
 
127
  nhook->hook = hook;
 
128
  nhook->unload = unload;
 
129
  nhook->data = data;
 
130
  nhook->next = efiemu_prepare_hooks;
 
131
  efiemu_prepare_hooks = nhook;
 
132
  return GRUB_ERR_NONE;
 
133
}
 
134
 
 
135
/* Register a configuration table either supplying the address directly
 
136
   or with a hook
 
137
*/
 
138
grub_err_t
 
139
grub_efiemu_register_configuration_table (grub_efi_guid_t guid,
 
140
                                          void * (*get_table) (void *data),
 
141
                                          void (*unload) (void *data),
 
142
                                          void *data)
 
143
{
 
144
  struct grub_efiemu_configuration_table *tbl;
 
145
  grub_err_t err;
 
146
 
 
147
 if (! get_table && ! data)
 
148
    return grub_error (GRUB_ERR_BAD_ARGUMENT,
 
149
                       "you must set at least get_table or data");
 
150
  if ((err = grub_efiemu_unregister_configuration_table (guid)))
 
151
    return err;
 
152
 
 
153
  tbl = (struct grub_efiemu_configuration_table *) grub_malloc (sizeof (*tbl));
 
154
  if (! tbl)
 
155
    return grub_error (GRUB_ERR_OUT_OF_MEMORY, "couldn't register table");
 
156
 
 
157
  tbl->guid = guid;
 
158
  tbl->get_table = get_table;
 
159
  tbl->unload = unload;
 
160
  tbl->data = data;
 
161
  tbl->next = efiemu_config_tables;
 
162
  efiemu_config_tables = tbl;
 
163
 
 
164
  return GRUB_ERR_NONE;
 
165
}
 
166
 
 
167
static grub_err_t
 
168
grub_cmd_efiemu_unload (grub_command_t cmd __attribute__ ((unused)),
 
169
                        int argc __attribute__ ((unused)),
 
170
                        char *args[] __attribute__ ((unused)))
 
171
{
 
172
  return grub_efiemu_unload ();
 
173
}
 
174
 
 
175
static grub_err_t
 
176
grub_cmd_efiemu_prepare (grub_command_t cmd __attribute__ ((unused)),
 
177
                         int argc __attribute__ ((unused)),
 
178
                         char *args[] __attribute__ ((unused)))
 
179
{
 
180
  return grub_efiemu_prepare ();
 
181
}
 
182
 
 
183
 
 
184
 
 
185
/* Load the runtime from the file FILENAME.  */
 
186
static grub_err_t
 
187
grub_efiemu_load_file (const char *filename)
 
188
{
 
189
  grub_file_t file;
 
190
  grub_err_t err;
 
191
 
 
192
  file = grub_file_open (filename);
 
193
  if (! file)
 
194
    return 0;
 
195
 
 
196
  err = grub_efiemu_mm_init ();
 
197
  if (err)
 
198
    {
 
199
      grub_file_close (file);
 
200
      grub_efiemu_unload ();
 
201
      return grub_error (grub_errno, "couldn't init memory management");
 
202
    }
 
203
 
 
204
  grub_dprintf ("efiemu", "mm initialized\n");
 
205
 
 
206
  err = grub_efiemu_loadcore_init (file);
 
207
  if (err)
 
208
    {
 
209
      grub_file_close (file);
 
210
      grub_efiemu_unload ();
 
211
      return err;
 
212
    }
 
213
 
 
214
  grub_file_close (file);
 
215
 
 
216
  /* For configuration tables entry in system table. */
 
217
  grub_efiemu_request_symbols (1);
 
218
 
 
219
  return GRUB_ERR_NONE;
 
220
}
 
221
 
 
222
grub_err_t
 
223
grub_efiemu_autocore (void)
 
224
{
 
225
  const char *prefix;
 
226
  char *filename;
 
227
  char *suffix;
 
228
  grub_err_t err;
 
229
 
 
230
  if (grub_efiemu_sizeof_uintn_t () != 0)
 
231
    return GRUB_ERR_NONE;
 
232
 
 
233
  prefix = grub_env_get ("prefix");
 
234
 
 
235
  if (! prefix)
 
236
    return grub_error (GRUB_ERR_FILE_NOT_FOUND,
 
237
                       "couldn't find efiemu core because prefix "
 
238
                       "isn't set");
 
239
 
 
240
  suffix = grub_efiemu_get_default_core_name ();
 
241
 
 
242
  filename = grub_xasprintf ("%s/%s", prefix, suffix);
 
243
  if (! filename)
 
244
    return grub_error (GRUB_ERR_OUT_OF_MEMORY,
 
245
                       "couldn't allocate temporary space");
 
246
 
 
247
 
 
248
  err = grub_efiemu_load_file (filename);
 
249
  grub_free (filename);
 
250
  if (err)
 
251
    return err;
 
252
#ifndef GRUB_MACHINE_EMU
 
253
  err = grub_machine_efiemu_init_tables ();
 
254
  if (err)
 
255
    return err;
 
256
#endif
 
257
 
 
258
  return GRUB_ERR_NONE;
 
259
}
 
260
 
 
261
grub_err_t
 
262
grub_efiemu_prepare (void)
 
263
{
 
264
  grub_err_t err;
 
265
 
 
266
  if (prepared)
 
267
    return GRUB_ERR_NONE;
 
268
 
 
269
  err = grub_efiemu_autocore ();
 
270
  if (err)
 
271
    return err;
 
272
 
 
273
  grub_dprintf ("efiemu", "Preparing %d-bit efiemu\n",
 
274
                8 * grub_efiemu_sizeof_uintn_t ());
 
275
 
 
276
  /* Create NVRAM. */
 
277
  grub_efiemu_pnvram ();
 
278
 
 
279
  prepared = 1;
 
280
 
 
281
  if (grub_efiemu_sizeof_uintn_t () == 4)
 
282
    return grub_efiemu_prepare32 (efiemu_prepare_hooks, efiemu_config_tables);
 
283
  else
 
284
    return grub_efiemu_prepare64 (efiemu_prepare_hooks, efiemu_config_tables);
 
285
}
 
286
 
 
287
 
 
288
static grub_err_t
 
289
grub_cmd_efiemu_load (grub_command_t cmd __attribute__ ((unused)),
 
290
                      int argc, char *args[])
 
291
{
 
292
  grub_err_t err;
 
293
 
 
294
  grub_efiemu_unload ();
 
295
 
 
296
  if (argc != 1)
 
297
    return grub_error (GRUB_ERR_BAD_ARGUMENT, "filename required");
 
298
 
 
299
  err = grub_efiemu_load_file (args[0]);
 
300
  if (err)
 
301
    return err;
 
302
#ifndef GRUB_MACHINE_EMU
 
303
  err = grub_machine_efiemu_init_tables ();
 
304
  if (err)
 
305
    return err;
 
306
#endif
 
307
  return GRUB_ERR_NONE;
 
308
}
 
309
 
 
310
static grub_command_t cmd_loadcore, cmd_prepare, cmd_unload;
 
311
 
 
312
GRUB_MOD_INIT(efiemu)
 
313
{
 
314
  cmd_loadcore = grub_register_command ("efiemu_loadcore",
 
315
                                        grub_cmd_efiemu_load,
 
316
                                        N_("FILE"),
 
317
                                        N_("Load and initialize EFI emulator."));
 
318
  cmd_prepare = grub_register_command ("efiemu_prepare",
 
319
                                       grub_cmd_efiemu_prepare,
 
320
                                       0,
 
321
                                       N_("Finalize loading of EFI emulator."));
 
322
  cmd_unload = grub_register_command ("efiemu_unload", grub_cmd_efiemu_unload,
 
323
                                      0,
 
324
                                      N_("Unload EFI emulator."));
 
325
}
 
326
 
 
327
GRUB_MOD_FINI(efiemu)
 
328
{
 
329
  grub_unregister_command (cmd_loadcore);
 
330
  grub_unregister_command (cmd_prepare);
 
331
  grub_unregister_command (cmd_unload);
 
332
}