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

merge mainline into gfxmenu

Browse source
This commit is contained in:
Vladimir 'phcoder' Serbinenko 2009-12-25 21:32:46 +01:00
commit 9f293ab0df
198 changed files with 5911 additions and 2701 deletions
Download patch file Download diff file Expand all files Collapse all files

24
commands/acpi.c
View file

@ -36,23 +36,23 @@
static const struct grub_arg_option options[] = {
{"exclude", 'x', 0,
"Don't load host tables specified by comma-separated list",
"Don't load host tables specified by comma-separated list.",
0, ARG_TYPE_STRING},
{"load-only", 'n', 0,
"Load only tables specified by comma-separated list", 0, ARG_TYPE_STRING},
{"v1", '1', 0, "Expose v1 tables", 0, ARG_TYPE_NONE},
{"v2", '2', 0, "Expose v2 and v3 tables", 0, ARG_TYPE_NONE},
{"oemid", 'o', 0, "Set OEMID of RSDP, XSDT and RSDT", 0, ARG_TYPE_STRING},
"Load only tables specified by comma-separated list.", 0, ARG_TYPE_STRING},
{"v1", '1', 0, "Expose v1 tables.", 0, ARG_TYPE_NONE},
{"v2", '2', 0, "Expose v2 and v3 tables.", 0, ARG_TYPE_NONE},
{"oemid", 'o', 0, "Set OEMID of RSDP, XSDT and RSDT.", 0, ARG_TYPE_STRING},
{"oemtable", 't', 0,
"Set OEMTABLE ID of RSDP, XSDT and RSDT", 0, ARG_TYPE_STRING},
"Set OEMTABLE ID of RSDP, XSDT and RSDT.", 0, ARG_TYPE_STRING},
{"oemtablerev", 'r', 0,
"Set OEMTABLE revision of RSDP, XSDT and RSDT", 0, ARG_TYPE_INT},
"Set OEMTABLE revision of RSDP, XSDT and RSDT.", 0, ARG_TYPE_INT},
{"oemtablecreator", 'c', 0,
"Set creator field of RSDP, XSDT and RSDT", 0, ARG_TYPE_STRING},
"Set creator field of RSDP, XSDT and RSDT.", 0, ARG_TYPE_STRING},
{"oemtablecreatorrev", 'd', 0,
"Set creator revision of RSDP, XSDT and RSDT", 0, ARG_TYPE_INT},
{"no-ebda", 'e', 0, "Don't update EBDA. May fix failures or hangs on some"
" BIOSes but makes it ineffective with OS not receiving RSDP from GRUB",
"Set creator revision of RSDP, XSDT and RSDT.", 0, ARG_TYPE_INT},
{"no-ebda", 'e', 0, "Don't update EBDA. May fix failures or hangs on some."
" BIOSes but makes it ineffective with OS not receiving RSDP from GRUB.",
0, ARG_TYPE_NONE},
{0, 0, 0, 0, 0, 0}
};
@ -763,7 +763,7 @@ GRUB_MOD_INIT(acpi)
"--load-only=table1,table2] filename1 "
" [filename2] [...]",
"Load host acpi tables and tables "
"specified by arguments",
"specified by arguments.",
options);
}

2
commands/boot.c
View file

@ -186,7 +186,7 @@ GRUB_MOD_INIT(boot)
{
cmd_boot =
grub_register_command ("boot", grub_cmd_boot,
0, "boot an operating system");
0, "Boot an operating system.");
}
GRUB_MOD_FINI(boot)

6
commands/cmp.c
View file

@ -40,7 +40,7 @@ grub_cmd_cmp (grub_command_t cmd __attribute__ ((unused)),
if (argc != 2)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "two arguments required");
grub_printf ("Compare `%s' and `%s':\n", args[0],
grub_printf ("Compare file `%s' with `%s':\n", args[0],
args[1]);
file1 = grub_gzfile_open (args[0], 1);
@ -49,7 +49,7 @@ grub_cmd_cmp (grub_command_t cmd __attribute__ ((unused)),
goto cleanup;
if (grub_file_size (file1) != grub_file_size (file2))
grub_printf ("Differ in size: %llu [%s], %llu [%s]\n",
grub_printf ("Files differ in size: %llu [%s], %llu [%s]\n",
(unsigned long long) grub_file_size (file1), args[0],
(unsigned long long) grub_file_size (file2), args[1]);
else
@ -76,7 +76,7 @@ grub_cmd_cmp (grub_command_t cmd __attribute__ ((unused)),
{
if (buf1[i] != buf2[i])
{
grub_printf ("Differ at the offset %llu: 0x%x [%s], 0x%x [%s]\n",
grub_printf ("Files differ at the offset %llu: 0x%x [%s], 0x%x [%s]\n",
(unsigned long long) (i + pos), buf1[i], args[0],
buf2[i], args[1]);
goto cleanup;

4
commands/echo.c
View file

@ -23,8 +23,8 @@
static const struct grub_arg_option options[] =
{
{0, 'n', 0, "do not output the trailing newline", 0, 0},
{0, 'e', 0, "enable interpretation of backslash escapes", 0, 0},
{0, 'n', 0, "Do not output the trailing newline.", 0, 0},
{0, 'e', 0, "Enable interpretation of backslash escapes.", 0, 0},
{0, 0, 0, 0, 0, 0}
};

4
commands/efi/fixvideo.c
View file

@ -38,11 +38,11 @@ static struct grub_video_patch
};
static int NESTED_FUNC_ATTR
scan_card (int bus, int dev, int func, grub_pci_id_t pciid)
scan_card (grub_pci_device_t dev, grub_pci_id_t pciid)
{
grub_pci_address_t addr;
addr = grub_pci_make_address (bus, dev, func, 2);
addr = grub_pci_make_address (dev, 2);
if (grub_pci_read_byte (addr + 3) == 0x3)
{
struct grub_video_patch *p = video_patches;

12
commands/efi/loadbios.c
View file

@ -41,15 +41,16 @@ enable_rom_area (void)
{
grub_pci_address_t addr;
grub_uint32_t *rom_ptr;
grub_pci_device_t dev = { .bus = 0, .device = 0, .function = 0};
rom_ptr = (grub_uint32_t *) VBIOS_ADDR;
if (*rom_ptr != BLANK_MEM)
{
grub_printf ("ROM image present.\n");
grub_printf ("ROM image is present.\n");
return 0;
}
addr = grub_pci_make_address (0, 0, 0, 36);
addr = grub_pci_make_address (dev, 36);
grub_pci_write_byte (addr++, 0x30);
grub_pci_write_byte (addr++, 0x33);
grub_pci_write_byte (addr++, 0x33);
@ -62,7 +63,7 @@ enable_rom_area (void)
*rom_ptr = 0;
if (*rom_ptr != 0)
{
grub_printf ("Can\'t enable rom area.\n");
grub_printf ("Can\'t enable ROM area.\n");
return 0;
}
@ -73,8 +74,9 @@ static void
lock_rom_area (void)
{
grub_pci_address_t addr;
grub_pci_device_t dev = { .bus = 0, .device = 0, .function = 0};
addr = grub_pci_make_address (0, 0, 0, 36);
addr = grub_pci_make_address (dev, 36);
grub_pci_write_byte (addr++, 0x10);
grub_pci_write_byte (addr++, 0x11);
grub_pci_write_byte (addr++, 0x11);
@ -199,7 +201,7 @@ static grub_command_t cmd_fakebios, cmd_loadbios;
GRUB_MOD_INIT(loadbios)
{
cmd_fakebios = grub_register_command ("fakebios", grub_cmd_fakebios,
0, "fake bios.");
0, "Fake bios.");
cmd_loadbios = grub_register_command ("loadbios", grub_cmd_loadbios,
"loadbios BIOS_DUMP [INT10_DUMP]",

2
commands/gptsync.c
View file

@ -246,7 +246,7 @@ GRUB_MOD_INIT(gptsync)
"of hybrid mbr. Up to 3 partitions are "
"allowed. TYPE is an MBR type. "
"+ means that partition is active. "
"Only one partition can be active");
"Only one partition can be active.");
}
GRUB_MOD_FINI(gptsync)

14
commands/halt.c
View file

@ -19,15 +19,7 @@
#include <grub/dl.h>
#include <grub/command.h>
#if defined(GRUB_MACHINE_IEEE1275)
#include <grub/machine/kernel.h>
#elif defined(GRUB_MACHINE_EFI)
#include <grub/efi/efi.h>
#else
/* Platforms shipping standalone halt, such as coreboot. */
#include <grub/cpu/halt.h>
#endif
#include <grub/misc.h>
static grub_err_t
grub_cmd_halt (grub_command_t cmd __attribute__ ((unused)),
@ -43,8 +35,8 @@ static grub_command_t cmd;
GRUB_MOD_INIT(halt)
{
cmd = grub_register_command ("halt", grub_cmd_halt,
0, "halts the computer. This command does not"
" work on all firmware.");
0, "Halts the computer. This command does not"
" work on all firmware implementations.");
}
GRUB_MOD_FINI(halt)

6
commands/handler.c
View file

@ -96,15 +96,15 @@ GRUB_MOD_INIT(handler)
cmd_handler =
grub_register_command ("handler", grub_cmd_handler,
"handler [class [handler]]",
"List or select a handler");
"List or select a handler.");
cmd_terminal_input =
grub_register_command ("terminal_input", grub_cmd_handler,
"terminal_input [handler]",
"List or select a handler");
"List or select an input terminal.");
cmd_terminal_output =
grub_register_command ("terminal_output", grub_cmd_handler,
"terminal_output [handler]",
"List or select a handler");
"List or select an output terminal.");
}
GRUB_MOD_FINI(handler)

30
commands/hdparm.c
View file

@ -26,27 +26,27 @@
#include <grub/extcmd.h>
static const struct grub_arg_option options[] = {
{"apm", 'B', 0, "set Advanced Power Management\n"
"(1=low, ..., 254=high, 255=off)",
{"apm", 'B', 0, "Set Advanced Power Management\n"
"(1=low, ..., 254=high, 255=off).",
0, ARG_TYPE_INT},
{"power", 'C', 0, "check power mode", 0, ARG_TYPE_NONE},
{"security-freeze", 'F', 0, "freeze ATA security settings until reset",
{"power", 'C', 0, "Check power mode.", 0, ARG_TYPE_NONE},
{"security-freeze", 'F', 0, "Freeze ATA security settings until reset.",
0, ARG_TYPE_NONE},
{"health", 'H', 0, "check SMART health status", 0, ARG_TYPE_NONE},
{"aam", 'M', 0, "set Automatic Acoustic Management\n"
"(0=off, 128=quiet, ..., 254=fast)",
{"health", 'H', 0, "Check SMART health status.", 0, ARG_TYPE_NONE},
{"aam", 'M', 0, "Set Automatic Acoustic Management\n"
"(0=off, 128=quiet, ..., 254=fast).",
0, ARG_TYPE_INT},
{"standby-timeout", 'S', 0, "set standby timeout\n"
"(0=off, 1=5s, 2=10s, ..., 240=20m, 241=30m, ...)",
{"standby-timeout", 'S', 0, "Set standby timeout\n"
"(0=off, 1=5s, 2=10s, ..., 240=20m, 241=30m, ...).",
0, ARG_TYPE_INT},
{"standby", 'y', 0, "set drive to standby mode", 0, ARG_TYPE_NONE},
{"sleep", 'Y', 0, "set drive to sleep mode", 0, ARG_TYPE_NONE},
{"identify", 'i', 0, "print drive identity and settings",
{"standby", 'y', 0, "Set drive to standby mode.", 0, ARG_TYPE_NONE},
{"sleep", 'Y', 0, "Set drive to sleep mode.", 0, ARG_TYPE_NONE},
{"identify", 'i', 0, "Print drive identity and settings.",
0, ARG_TYPE_NONE},
{"dumpid", 'I', 0, "dump contents of ATA IDENTIFY sector",
{"dumpid", 'I', 0, "Dump contents of ATA IDENTIFY sector.",
0, ARG_TYPE_NONE},
{"smart", -1, 0, "disable/enable SMART (0/1)", 0, ARG_TYPE_INT},
{"quiet", 'q', 0, "do not print messages", 0, ARG_TYPE_NONE},
{"smart", -1, 0, "Disable/enable SMART (0/1).", 0, ARG_TYPE_INT},
{"quiet", 'q', 0, "Do not print messages.", 0, ARG_TYPE_NONE},
{0, 0, 0, 0, 0, 0}
};

10
commands/hexdump.c
View file

@ -26,9 +26,9 @@
#include <grub/extcmd.h>
static const struct grub_arg_option options[] = {
{"skip", 's', 0, "skip offset bytes from the beginning of file.", 0,
{"skip", 's', 0, "Skip offset bytes from the beginning of file.", 0,
ARG_TYPE_INT},
{"length", 'n', 0, "read only length bytes", 0, ARG_TYPE_INT},
{"length", 'n', 0, "Read only LENGTH bytes.", 0, ARG_TYPE_INT},
{0, 0, 0, 0, 0, 0}
};
@ -38,18 +38,18 @@ grub_cmd_hexdump (grub_extcmd_t cmd, int argc, char **args)
struct grub_arg_list *state = cmd->state;
char buf[GRUB_DISK_SECTOR_SIZE * 4];
grub_ssize_t size, length;
grub_addr_t skip;
grub_disk_addr_t skip;
int namelen;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
namelen = grub_strlen (args[0]);
skip = (state[0].set) ? grub_strtoul (state[0].arg, 0, 0) : 0;
skip = (state[0].set) ? grub_strtoull (state[0].arg, 0, 0) : 0;
length = (state[1].set) ? grub_strtoul (state[1].arg, 0, 0) : 256;
if (!grub_strcmp (args[0], "(mem)"))
hexdump (skip, (char *) skip, length);
hexdump (skip, (char *) (grub_addr_t) skip, length);
else if ((args[0][0] == '(') && (args[0][namelen - 1] == ')'))
{
grub_disk_t disk;

4
commands/i386/cpuid.c
View file

@ -33,7 +33,7 @@
static const struct grub_arg_option options[] =
{
{"long-mode", 'l', 0, "check for long mode flag (default)", 0, 0},
{"long-mode", 'l', 0, "Check for long mode flag (default).", 0, 0},
{0, 0, 0, 0, 0, 0}
};
@ -88,7 +88,7 @@ done:
#endif
cmd = grub_register_extcmd ("cpuid", grub_cmd_cpuid, GRUB_COMMAND_FLAG_BOTH,
"cpuid [-l]", "Check for CPU features", options);
"cpuid [-l]", "Check for CPU features.", options);
}
GRUB_MOD_FINI(cpuid)

10
commands/i386/pc/drivemap.c
View file

@ -33,9 +33,9 @@ static grub_uint32_t *const int13slot = UINT_TO_PTR (4 * 0x13);
/* Remember to update enum opt_idxs accordingly. */
static const struct grub_arg_option options[] = {
{"list", 'l', 0, "show the current mappings", 0, 0},
{"reset", 'r', 0, "reset all mappings to the default values", 0, 0},
{"swap", 's', 0, "perform both direct and reverse mappings", 0, 0},
{"list", 'l', 0, "Show the current mappings.", 0, 0},
{"reset", 'r', 0, "Reset all mappings to the default values.", 0, 0},
{"swap", 's', 0, "Perform both direct and reverse mappings.", 0, 0},
{0, 0, 0, 0, 0, 0}
};
@ -370,7 +370,7 @@ grub_get_root_biosnumber_drivemap (void)
return grub_strtoul (biosnum, 0, 0);
dev = grub_device_open (0);
if (dev && dev->disk && dev->disk->dev
if (dev && dev->disk && dev->disk->dev
&& dev->disk->dev->id == GRUB_DISK_DEVICE_BIOSDISK_ID)
{
drivemap_node_t *curnode = map_head;
@ -404,7 +404,7 @@ GRUB_MOD_INIT (drivemap)
GRUB_COMMAND_FLAG_BOTH,
"drivemap"
" -l | -r | [-s] grubdev osdisk",
"Manage the BIOS drive mappings",
"Manage the BIOS drive mappings.",
options);
drivemap_hook =
grub_loader_register_preboot_hook (&install_int13_handler,

6
commands/i386/pc/halt.c
View file

@ -18,12 +18,12 @@
*/
#include <grub/dl.h>
#include <grub/machine/init.h>
#include <grub/misc.h>
#include <grub/extcmd.h>
static const struct grub_arg_option options[] =
{
{"no-apm", 'n', 0, "do not use APM to halt the computer", 0, 0},
{"no-apm", 'n', 0, "Do not use APM to halt the computer.", 0, 0},
{0, 0, 0, 0, 0, 0}
};
@ -47,7 +47,7 @@ GRUB_MOD_INIT(halt)
{
cmd = grub_register_extcmd ("halt", grub_cmd_halt, GRUB_COMMAND_FLAG_BOTH,
"halt [-n]",
"Halt the system, if possible using APM",
"Halt the system, if possible using APM.",
options);
}

2
commands/i386/pc/play.c
View file

@ -207,7 +207,7 @@ static grub_command_t cmd;
GRUB_MOD_INIT(play)
{
cmd = grub_register_command ("play", grub_cmd_play,
"play FILE", "Play a tune");
"play FILE", "Play a tune.");
}
GRUB_MOD_FINI(play)

6
commands/i386/pc/pxecmd.c
View file

@ -25,9 +25,9 @@
static const struct grub_arg_option options[] =
{
{"info", 'i', 0, "show PXE information.", 0, 0},
{"bsize", 'b', 0, "set PXE block size", 0, ARG_TYPE_INT},
{"unload", 'u', 0, "unload PXE stack.", 0, 0},
{"info", 'i', 0, "Show PXE information.", 0, 0},
{"bsize", 'b', 0, "Set PXE block size.", 0, ARG_TYPE_INT},
{"unload", 'u', 0, "Unload PXE stack.", 0, 0},
{0, 0, 0, 0, 0, 0}
};

2
commands/i386/pc/vbetest.c
View file

@ -168,7 +168,7 @@ static grub_command_t cmd;
GRUB_MOD_INIT(vbetest)
{
cmd = grub_register_command ("vbetest", grub_cmd_vbetest,
0, "Test VESA BIOS Extension 2.0+ support");
0, "Test VESA BIOS Extension 2.0+ support.");
}
GRUB_MOD_FINI(vbetest)

2
commands/ieee1275/suspend.c
View file

@ -39,7 +39,7 @@ static grub_command_t cmd;
GRUB_MOD_INIT(ieee1275_suspend)
{
cmd = grub_register_command ("suspend", grub_cmd_suspend,
0, "Return to Open Firmware prompt");
0, "Return to Open Firmware prompt.");
}
GRUB_MOD_FINI(ieee1275_suspend)

8
commands/keystatus.c
View file

@ -24,9 +24,9 @@
static const struct grub_arg_option options[] =
{
{"shift", 's', 0, "check Shift key", 0, 0},
{"ctrl", 'c', 0, "check Control key", 0, 0},
{"alt", 'a', 0, "check Alt key", 0, 0},
{"shift", 's', 0, "Check Shift key.", 0, 0},
{"ctrl", 'c', 0, "Check Control key.", 0, 0},
{"alt", 'a', 0, "Check Alt key.", 0, 0},
{0, 0, 0, 0, 0, 0}
};
@ -71,7 +71,7 @@ GRUB_MOD_INIT(keystatus)
cmd = grub_register_extcmd ("keystatus", grub_cmd_keystatus,
GRUB_COMMAND_FLAG_BOTH,
"keystatus [--shift] [--ctrl] [--alt]",
"Check key modifier status",
"Check key modifier status.",
options);
}

2
commands/loadenv.c
View file

@ -29,7 +29,7 @@
static const struct grub_arg_option options[] =
{
{"file", 'f', 0, "specify filename", 0, ARG_TYPE_PATHNAME},
{"file", 'f', 0, "Specify filename.", 0, ARG_TYPE_PATHNAME},
{0, 0, 0, 0, 0, 0}
};

6
commands/ls.c
View file

@ -33,9 +33,9 @@
static const struct grub_arg_option options[] =
{
{"long", 'l', 0, "show a long list with more detailed information", 0, 0},
{"human-readable", 'h', 0, "print sizes in a human readable format", 0, 0},
{"all", 'a', 0, "list all files", 0, 0},
{"long", 'l', 0, "Show a long list with more detailed information.", 0, 0},
{"human-readable", 'h', 0, "Print sizes in a human readable format.", 0, 0},
{"all", 'a', 0, "List all files.", 0, 0},
{0, 0, 0, 0, 0, 0}
};

83
commands/lspci.c
View file

@ -20,7 +20,7 @@
#include <grub/pci.h>
#include <grub/dl.h>
#include <grub/misc.h>
#include <grub/command.h>
#include <grub/extcmd.h>
struct grub_pci_classname
{
@ -84,6 +84,7 @@ static const struct grub_pci_classname grub_pci_classes[] =
{ 11, 0x30, "MIPS Processor" },
{ 11, 0x40, "Co-Processor" },
{ 11, 0x80, "Unknown Processor" },
{ 12, 3, "USB Controller" },
{ 12, 0x80, "Serial Bus Controller" },
{ 13, 0x80, "Wireless Controller" },
{ 14, 0, "I2O" },
@ -114,16 +115,26 @@ grub_pci_get_class (int class, int subclass)
return 0;
}
static const struct grub_arg_option options[] =
{
{"iospace", 'i', 0, "show I/O spaces", 0, 0},
{0, 0, 0, 0, 0, 0}
};
static int iospace;
static int NESTED_FUNC_ATTR
grub_lspci_iter (int bus, int dev, int func, grub_pci_id_t pciid)
grub_lspci_iter (grub_pci_device_t dev, grub_pci_id_t pciid)
{
grub_uint32_t class;
const char *sclass;
grub_pci_address_t addr;
int reg;
grub_printf ("%02x:%02x.%x %04x:%04x", bus, dev, func, pciid & 0xFFFF,
pciid >> 16);
addr = grub_pci_make_address (bus, dev, func, 2);
grub_printf ("%02x:%02x.%x %04x:%04x", grub_pci_get_bus (dev),
grub_pci_get_device (dev), grub_pci_get_function (dev),
pciid & 0xFFFF, pciid >> 16);
addr = grub_pci_make_address (dev, 2);
class = grub_pci_read (addr);
/* Lookup the class name, if there isn't a specific one,
@ -142,27 +153,75 @@ grub_lspci_iter (int bus, int dev, int func, grub_pci_id_t pciid)
grub_printf ("\n");
if (iospace)
{
reg = 4;
while (reg < 10)
{
grub_uint64_t space;
addr = grub_pci_make_address (dev, reg);
space = grub_pci_read (addr);
reg++;
if (space == 0)
continue;
switch (space & GRUB_PCI_ADDR_SPACE_MASK)
{
case GRUB_PCI_ADDR_SPACE_IO:
grub_printf ("\tIO space %d at 0x%llx\n", (reg - 1) - 4,
(unsigned long long)
(space & GRUB_PCI_ADDR_IO_MASK));
break;
case GRUB_PCI_ADDR_SPACE_MEMORY:
if ((space & GRUB_PCI_ADDR_MEM_TYPE_MASK)
== GRUB_PCI_ADDR_MEM_TYPE_64)
{
addr = grub_pci_make_address (dev, reg);
space |= ((grub_uint64_t) grub_pci_read (addr)) << 32;
reg++;
grub_printf ("\t64-bit memory space %d at 0x%016llx [%s]\n",
(reg - 2) - 4, (unsigned long long)
(space & GRUB_PCI_ADDR_MEM_MASK),
space & GRUB_PCI_ADDR_MEM_PREFETCH
? "prefetchable" : "non-prefetchable");
}
else
grub_printf ("\t32-bit memory space %d at 0x%016llx [%s]\n",
(reg - 1) - 4, (unsigned long long)
(space & GRUB_PCI_ADDR_MEM_MASK),
space & GRUB_PCI_ADDR_MEM_PREFETCH
? "prefetchable" : "non-prefetchable");
break;
}
}
}
return 0;
}
static grub_err_t
grub_cmd_lspci (grub_command_t cmd __attribute__ ((unused)),
grub_cmd_lspci (grub_extcmd_t cmd,
int argc __attribute__ ((unused)),
char **args __attribute__ ((unused)))
{
iospace = cmd->state[0].set;
grub_pci_iterate (grub_lspci_iter);
return GRUB_ERR_NONE;
}
static grub_command_t cmd;
static grub_extcmd_t cmd;
GRUB_MOD_INIT(pci)
GRUB_MOD_INIT(lspci)
{
cmd = grub_register_command ("lspci", grub_cmd_lspci,
0, "List PCI devices");
cmd = grub_register_extcmd ("lspci", grub_cmd_lspci, GRUB_COMMAND_FLAG_BOTH,
"lspci [-i]", "List PCI devices.", options);
}
GRUB_MOD_FINI(pci)
GRUB_MOD_FINI(lspci)
{
grub_unregister_command (cmd);
grub_unregister_extcmd (cmd);
}

108
commands/memrw.c
View file

@ -19,29 +19,53 @@
#include <grub/dl.h>
#include <grub/misc.h>
#include <grub/command.h>
#include <grub/extcmd.h>
#include <grub/env.h>
static grub_command_t cmd_read_byte, cmd_read_word, cmd_read_dword;
static grub_extcmd_t cmd_read_byte, cmd_read_word, cmd_read_dword;
static grub_command_t cmd_write_byte, cmd_write_word, cmd_write_dword;
static const struct grub_arg_option options[] =
{
{0, 'v', 0, "Save read value into variable VARNAME.",
"VARNAME", ARG_TYPE_STRING},
{0, 0, 0, 0, 0, 0}
};
static grub_err_t
grub_cmd_read (grub_command_t cmd, int argc, char **argv)
grub_cmd_read (grub_extcmd_t cmd, int argc, char **argv)
{
grub_target_addr_t addr;
grub_uint32_t value;
grub_uint32_t value = 0;
char buf[sizeof ("XXXXXXXX")];
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid number of arguments");
addr = grub_strtoul (argv[0], 0, 0);
if (cmd->name[5] == 'd')
value = *((grub_uint32_t *) addr);
else if (cmd->name[5] == 'w')
value = *((grub_uint16_t *) addr);
else
value = *((grub_uint8_t *) addr);
switch (cmd->cmd->name[sizeof ("read_") - 1])
{
case 'd':
value = *((volatile grub_uint32_t *) addr);
break;
grub_printf ("0x%x\n", value);
case 'w':
value = *((volatile grub_uint16_t *) addr);
break;
case 'b':
value = *((volatile grub_uint8_t *) addr);
break;
}
if (cmd->state[0].set)
{
grub_sprintf (buf, "%x", value);
grub_env_set (cmd->state[0].arg, buf);
}
else
grub_printf ("0x%x\n", value);
return 0;
}
@ -51,18 +75,42 @@ grub_cmd_write (grub_command_t cmd, int argc, char **argv)
{
grub_target_addr_t addr;
grub_uint32_t value;
grub_uint32_t mask = 0xffffffff;
if (argc != 2)
if (argc != 2 && argc != 3)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid number of arguments");
addr = grub_strtoul (argv[0], 0, 0);
value = grub_strtoul (argv[1], 0, 0);
if (cmd->name[6] == 'd')
*((grub_uint32_t *) addr) = value;
else if (cmd->name[6] == 'w')
*((grub_uint16_t *) addr) = (grub_uint16_t) value;
else
*((grub_uint8_t *) addr) = (grub_uint8_t) value;
if (argc == 3)
mask = grub_strtoul (argv[2], 0, 0);
value &= mask;
switch (cmd->name[sizeof ("write_") - 1])
{
case 'd':
if (mask != 0xffffffff)
*((volatile grub_uint32_t *) addr)
= (*((volatile grub_uint32_t *) addr) & ~mask) | value;
else
*((volatile grub_uint32_t *) addr) = value;
break;
case 'w':
if ((mask & 0xffff) != 0xffff)
*((volatile grub_uint16_t *) addr)
= (*((volatile grub_uint16_t *) addr) & ~mask) | value;
else
*((volatile grub_uint16_t *) addr) = value;
break;
case 'b':
if ((mask & 0xff) != 0xff)
*((volatile grub_uint8_t *) addr)
= (*((volatile grub_uint8_t *) addr) & ~mask) | value;
else
*((volatile grub_uint8_t *) addr) = value;
break;
}
return 0;
}
@ -70,30 +118,30 @@ grub_cmd_write (grub_command_t cmd, int argc, char **argv)
GRUB_MOD_INIT(memrw)
{
cmd_read_byte =
grub_register_command ("read_byte", grub_cmd_read,
"read_byte ADDR", "read byte.");
grub_register_extcmd ("read_byte", grub_cmd_read, GRUB_COMMAND_FLAG_BOTH,
"read_byte ADDR", "Read byte from ADDR.", options);
cmd_read_word =
grub_register_command ("read_word", grub_cmd_read,
"read_word ADDR", "read word.");
grub_register_extcmd ("read_word", grub_cmd_read, GRUB_COMMAND_FLAG_BOTH,
"read_word ADDR", "Read word from ADDR.", options);
cmd_read_dword =
grub_register_command ("read_dword", grub_cmd_read,
"read_dword ADDR", "read dword.");
grub_register_extcmd ("read_dword", grub_cmd_read, GRUB_COMMAND_FLAG_BOTH,
"read_dword ADDR", "Read dword from ADDR.", options);
cmd_write_byte =
grub_register_command ("write_byte", grub_cmd_write,
"write_byte ADDR VALUE", "write byte.");
"write_byte ADDR VALUE [MASK]", "Write byte VALUE to ADDR.");
cmd_write_word =
grub_register_command ("write_word", grub_cmd_write,
"write_word ADDR VALUE", "write word.");
"write_word ADDR VALUE [MASK]", "Write word VALUE to ADDR.");
cmd_write_dword =
grub_register_command ("write_dword", grub_cmd_write,
"write_dword ADDR VALUE", "write dword.");
"write_dword ADDR VALUE [MASK]", "Write dword VALUE to ADDR.");
}
GRUB_MOD_FINI(memrw)
{
grub_unregister_command (cmd_read_byte);
grub_unregister_command (cmd_read_word);
grub_unregister_command (cmd_read_dword);
grub_unregister_extcmd (cmd_read_byte);
grub_unregister_extcmd (cmd_read_word);
grub_unregister_extcmd (cmd_read_dword);
grub_unregister_command (cmd_write_byte);
grub_unregister_command (cmd_write_word);
grub_unregister_command (cmd_write_dword);

16
commands/minicmd.c
View file

@ -353,28 +353,28 @@ GRUB_MOD_INIT(minicmd)
{
cmd_cat =
grub_register_command ("cat", grub_mini_cmd_cat,
"cat FILE", "show the contents of a file");
"cat FILE", "Show the contents of a file.");
cmd_help =
grub_register_command ("help", grub_mini_cmd_help,
0, "show this message");
0, "Show this message.");
cmd_root =
grub_register_command ("root", grub_mini_cmd_root,
"root [DEVICE]", "set the root device");
"root [DEVICE]", "Set the root device.");
cmd_dump =
grub_register_command ("dump", grub_mini_cmd_dump,
"dump ADDR", "dump memory");
"dump ADDR", "Dump memory.");
cmd_rmmod =
grub_register_command ("rmmod", grub_mini_cmd_rmmod,
"rmmod MODULE", "remove a module");
"rmmod MODULE", "Remove a module.");
cmd_lsmod =
grub_register_command ("lsmod", grub_mini_cmd_lsmod,
0, "show loaded modules");
0, "Show loaded modules.");
cmd_exit =
grub_register_command ("exit", grub_mini_cmd_exit,
0, "exit from GRUB");
0, "Exit from GRUB.");
cmd_clear =
grub_register_command ("clear", grub_mini_cmd_clear,
0, "clear the screen");
0, "Clear the screen.");
}
GRUB_MOD_FINI(minicmd)

4
commands/parttool.c
View file

@ -34,9 +34,9 @@ static struct grub_parttool *parts = 0;
static int curhandle = 0;
static grub_dl_t mymod;
static char helpmsg[] =
"perform COMMANDS on partition.\n"
"Perform COMMANDS on partition.\n"
"Use \"parttool PARTITION help\" for the list "
"of available commands";
"of available commands.";
int
grub_parttool_register(const char *part_name,

14
commands/probe.c
View file

@ -31,15 +31,15 @@
#include <grub/env.h>
#include <grub/extcmd.h>
static const struct grub_arg_option options[] =
static const struct grub_arg_option options[] =
{
{"set", 's', GRUB_ARG_OPTION_OPTIONAL,
"set a variable to return value", "VAR", ARG_TYPE_STRING},
{"driver", 'd', 0, "determine driver", 0, 0},
{"partmap", 'p', 0, "determine partition map type", 0, 0},
{"fs", 'f', 0, "determine filesystem type", 0, 0},
{"fs-uuid", 'u', 0, "determine filesystem UUID", 0, 0},
{"label", 'l', 0, "determine filesystem label", 0, 0},
"Set a variable to return value.", "VAR", ARG_TYPE_STRING},
{"driver", 'd', 0, "Determine driver.", 0, 0},
{"partmap", 'p', 0, "Determine partition map type.", 0, 0},
{"fs", 'f', 0, "Determine filesystem type.", 0, 0},
{"fs-uuid", 'u', 0, "Determine filesystem UUID.", 0, 0},
{"label", 'l', 0, "Determine filesystem label.", 0, 0},
{0, 0, 0, 0, 0, 0}
};

4
commands/read.c
View file

@ -62,7 +62,7 @@ grub_getline (void)
}
static grub_err_t
grub_cmd_read (grub_command_t cmd UNUSED, int argc, char **args)
grub_cmd_read (grub_command_t cmd __attribute__ ((unused)), int argc, char **args)
{
char *line = grub_getline ();
if (! line)
@ -80,7 +80,7 @@ GRUB_MOD_INIT(read)
{
cmd = grub_register_command ("read", grub_cmd_read,
"read [ENVVAR]",
"Set variable with user input");
"Set variable with user input.");
}
GRUB_MOD_FINI(read)

15
commands/reboot.c
View file

@ -19,18 +19,7 @@
#include <grub/dl.h>
#include <grub/command.h>
#if defined(GRUB_MACHINE_IEEE1275)
#include <grub/machine/kernel.h>
#elif defined(GRUB_MACHINE_EFI)
#include <grub/efi/efi.h>
#elif defined(GRUB_MACHINE_PCBIOS)
#include <grub/machine/init.h>
#else
/* Platforms shipping standalone reboot, such as coreboot. */
#include <grub/cpu/reboot.h>
#endif
#include <grub/misc.h>
static grub_err_t
grub_cmd_reboot (grub_command_t cmd __attribute__ ((unused)),
@ -46,7 +35,7 @@ static grub_command_t cmd;
GRUB_MOD_INIT(reboot)
{
cmd = grub_register_command ("reboot", grub_cmd_reboot,
0, "Reboot the computer");
0, "Reboot the computer.");
}
GRUB_MOD_FINI(reboot)

10
commands/search.c
View file

@ -29,11 +29,11 @@
static const struct grub_arg_option options[] =
{
{"file", 'f', 0, "search devices by a file", 0, 0},
{"label", 'l', 0, "search devices by a filesystem label", 0, 0},
{"fs-uuid", 'u', 0, "search devices by a filesystem UUID", 0, 0},
{"set", 's', GRUB_ARG_OPTION_OPTIONAL, "set a variable to the first device found", "VAR", ARG_TYPE_STRING},
{"no-floppy", 'n', 0, "do not probe any floppy drive", 0, 0},
{"file", 'f', 0, "Search devices by a file.", 0, 0},
{"label", 'l', 0, "Search devices by a filesystem label.", 0, 0},
{"fs-uuid", 'u', 0, "Search devices by a filesystem UUID.", 0, 0},
{"set", 's', GRUB_ARG_OPTION_OPTIONAL, "Set a variable to the first device found.", "VAR", ARG_TYPE_STRING},
{"no-floppy", 'n', 0, "Do not probe any floppy drive.", 0, 0},
{0, 0, 0, 0, 0, 0}
};

6
commands/sleep.c
View file

@ -27,8 +27,8 @@
static const struct grub_arg_option options[] =
{
{"verbose", 'v', 0, "verbose countdown", 0, 0},
{"interruptible", 'i', 0, "interruptible with ESC", 0, 0},
{"verbose", 'v', 0, "Verbose countdown.", 0, 0},
{"interruptible", 'i', 0, "Interruptible with ESC.", 0, 0},
{0, 0, 0, 0, 0, 0}
};
@ -106,7 +106,7 @@ GRUB_MOD_INIT(sleep)
{
cmd = grub_register_extcmd ("sleep", grub_cmd_sleep, GRUB_COMMAND_FLAG_BOTH,
"sleep NUMBER_OF_SECONDS",
"Wait for a specified number of seconds",
"Wait for a specified number of seconds.",
options);
}

4
commands/test.c
View file

@ -420,9 +420,9 @@ static grub_command_t cmd_1, cmd_2;
GRUB_MOD_INIT(test)
{
cmd_1 = grub_register_command ("[", grub_cmd_test,
"[ EXPRESSION ]", "Evaluate an expression");
"[ EXPRESSION ]", "Evaluate an expression.");
cmd_2 = grub_register_command ("test", grub_cmd_test,
"test EXPRESSION", "Evaluate an expression");
"test EXPRESSION", "Evaluate an expression.");
}
GRUB_MOD_FINI(test)

4
commands/true.c
View file

@ -43,10 +43,10 @@ GRUB_MOD_INIT(true)
{
cmd_true =
grub_register_command ("true", grub_cmd_true,
0, "do nothing, successfully");
0, "Do nothing, successfully.");
cmd_false =
grub_register_command ("false", grub_cmd_false,
0, "do nothing, unsuccessfully");
0, "Do nothing, unsuccessfully.");
}
GRUB_MOD_FINI(true)

51
commands/usbtest.c
View file

@ -19,6 +19,7 @@
#include <grub/types.h>
#include <grub/misc.h>
#include <grub/charset.h>
#include <grub/mm.h>
#include <grub/err.h>
#include <grub/dl.h>
@ -59,18 +60,60 @@ static const char *usb_devspeed[] =
"High"
};
static grub_usb_err_t
grub_usb_get_string (grub_usb_device_t dev, grub_uint8_t index, int langid,
char **string)
{
struct grub_usb_desc_str descstr;
struct grub_usb_desc_str *descstrp;
grub_usb_err_t err;
/* Only get the length. */
err = grub_usb_control_msg (dev, 1 << 7,
0x06, (3 << 8) | index,
langid, 1, (char *) &descstr);
if (err)
return err;
descstrp = grub_malloc (descstr.length);
if (! descstrp)
return GRUB_USB_ERR_INTERNAL;
err = grub_usb_control_msg (dev, 1 << 7,
0x06, (3 << 8) | index,
langid, descstr.length, (char *) descstrp);
*string = grub_malloc (descstr.length / 2);
if (! *string)
{
grub_free (descstrp);
return GRUB_USB_ERR_INTERNAL;
}
grub_utf16_to_utf8 ((grub_uint8_t *) *string, descstrp->str, descstrp->length / 2 - 1);
(*string)[descstr.length / 2 - 1] = '\0';
grub_free (descstrp);
return GRUB_USB_ERR_NONE;
}
static void
usb_print_str (const char *description, grub_usb_device_t dev, int idx)
{
char *name;
grub_usb_err_t err;
/* XXX: LANGID */
if (! idx)
return;
grub_usb_get_string (dev, idx, 0x0409, &name);
grub_printf ("%s: `%s'\n", description, name);
grub_free (name);
err = grub_usb_get_string (dev, idx, 0x0409, &name);
if (err)
grub_printf ("Error %d retrieving %s\n", err, description);
else
{
grub_printf ("%s: `%s'\n", description, name);
grub_free (name);
}
}
static int
@ -152,7 +195,7 @@ static grub_command_t cmd;
GRUB_MOD_INIT(usbtest)
{
cmd = grub_register_command ("usb", grub_cmd_usbtest,
0, "Test USB support");
0, "Test USB support.");
}
GRUB_MOD_FINI(usbtest)

2
commands/videotest.c
View file

@ -181,7 +181,7 @@ static grub_command_t cmd;
GRUB_MOD_INIT(videotest)
{
cmd = grub_register_command ("videotest", grub_cmd_videotest,
0, "Test video subsystem");
0, "Test video subsystem.");
}
GRUB_MOD_FINI(videotest)

10
commands/xnu_uuid.c
View file

@ -1,4 +1,4 @@
/* xnu_uuid.c - transform 64-bit serial number
/* xnu_uuid.c - transform 64-bit serial number
to 128-bit uuid suitable for xnu. */
/*
* GRUB -- GRand Unified Bootloader
@ -38,10 +38,10 @@ struct tohash
grub_uint64_t serial;
} __attribute__ ((packed));
/* This prefix is used by xnu and boot-132 to hash
/* This prefix is used by xnu and boot-132 to hash
together with volume serial. */
static grub_uint8_t hash_prefix[16]
= {0xB3, 0xE2, 0x0F, 0x39, 0xF2, 0x92, 0x11, 0xD6,
static grub_uint8_t hash_prefix[16]
= {0xB3, 0xE2, 0x0F, 0x39, 0xF2, 0x92, 0x11, 0xD6,
0x97, 0xA4, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC};
#define rol(x,n) ( ((x) << (n)) | ((x) >> (32-(n))) )
@ -237,7 +237,7 @@ md5_write( void *context, const void *inbuf_arg , grub_size_t inlen)
}
// _gcry_burn_stack (80+6*sizeof(void*));
while( inlen >= 64 )
while( inlen >= 64 )
{
transform( hd, inbuf );
hd->count = 0;