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

Compare commits

base: vbatts:coreos-onepatch-2.04
Branches Tags
vbatts:master
vbatts:coreos-onepatch-2.04
vbatts:coreos-onepatch-2.02
vbatts:vbatts/rebase-2.04
vbatts:pfsmorigo/no-libgcc
vbatts:pfsmorigo/vlantag
vbatts:peter/devmapper
vbatts:grub-2.04
vbatts:grub-2.04-rc1
vbatts:grub-2.02
vbatts:2.02
vbatts:grub-2.02-rc2
vbatts:2.02-rc2
vbatts:grub-2.02-rc1
vbatts:2.02-rc1
vbatts:grub-2.02-beta3
vbatts:2.02-beta3
vbatts:grub-2.02-beta2
vbatts:grub-2.02-beta1
vbatts:2.00
vbatts:1.99
vbatts:1.98
vbatts:0.6.96
..
compare: vbatts:master
Branches Tags
vbatts:coreos-onepatch-2.04
vbatts:coreos-onepatch-2.02
vbatts:vbatts/rebase-2.04
vbatts:master
vbatts:pfsmorigo/no-libgcc
vbatts:pfsmorigo/vlantag
vbatts:peter/devmapper
vbatts:grub-2.04
vbatts:grub-2.04-rc1
vbatts:grub-2.02
vbatts:2.02
vbatts:grub-2.02-rc2
vbatts:2.02-rc2
vbatts:grub-2.02-rc1
vbatts:2.02-rc1
vbatts:grub-2.02-beta3
vbatts:2.02-beta3
vbatts:grub-2.02-beta2
vbatts:grub-2.02-beta1
vbatts:2.00
vbatts:1.99
vbatts:1.98
vbatts:0.6.96

165 commits
coreos-one ... master

Author SHA1 Message Date
Glenn Washburn
2df2912266 crypto: Remove GPG_ERROR_CFLAGS from gpg_err_code_t enum 
This was probably added by accident when originally creating the file.

Signed-off-by: Glenn Washburn <development@efficientek.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-18 22:31:30 +02:00
Glenn Washburn
ac301e4dd0 script: Do not allow a delimiter between function name and block start 
Currently the following is valid syntax but should be a syntax error:

  grub> function f; { echo HERE; }
  grub> f
  HERE

This fix is not backward compatible, but current syntax is not documented
either and has no functional value. So any scripts with this unintended
syntax are technically syntactically incorrect and should not be relying
on this behavior.

Signed-off-by: Glenn Washburn <development@efficientek.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-18 22:31:30 +02:00
Glenn Washburn
c30f378e00 docs: Support for loading and concatenating multiple initrds 
This has been available since January of 2012 but has not been documented.

Signed-off-by: Glenn Washburn <development@efficientek.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-18 22:31:30 +02:00
Glenn Washburn
c98a78ae81 lexer: char const * should be const char * 
Signed-off-by: Glenn Washburn <development@efficientek.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-18 22:31:30 +02:00
Glenn Washburn
84ff10b1c0 cryptodisk: Use cipher name instead of object in error message 
Signed-off-by: Glenn Washburn <development@efficientek.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-18 22:31:30 +02:00
Glenn Washburn
8471d8e254 tests: F2FS test should use MOUNTDEVICE like other tests 
LODEVICES is not an array variable and should not be accessed as such.
This allows the f2fs test to pass as it was failing because a device
name had a space prepended to the path.

Signed-off-by: Glenn Washburn <development@efficientek.com>
Acked-by: Jaegeuk Kim <jaegeuk@kernel.org>
Tested-by: Paul Menzel <pmenzel@molgen.mpg.de>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-18 22:31:30 +02:00
Florian La Roche
3ec59f14f4 grub-mkconfig: If $hints is not set reduce the output into grub.cfg to just 1 line 
Signed-off-by: Florian La Roche <Florian.LaRoche@gmail.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-18 22:31:30 +02:00
Petr Vorel
c55480daca travis: Run bootstrap to fix build 
autogen.sh isn't enough:

  $ ./autogen.sh
  Gnulib not yet bootstrapped; run ./bootstrap instead.
  The command "./autogen.sh" exited with 1.

Additionally, using bootstrap requires to install autopoint package.

Signed-off-by: Petr Vorel <pvorel@suse.cz>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-18 22:31:30 +02:00
Patrick Steinhardt
ee12785f75 luks2: Strip dashes off of the UUID 
The UUID header for LUKS2 uses a format with dashes, same as for
LUKS(1). But while we strip these dashes for the latter, we don't for
the former. This isn't wrong per se, but it's definitely inconsistent
for users as they need to use the dashed format for LUKS2 and the
non-dashed format for LUKS when e.g. calling "cryptomount -u $UUID".

Fix this inconsistency by stripping dashes off of the LUKS2 UUID.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-18 22:31:29 +02:00
Tianjia Zhang
6efd04f314 efi/tpm: Remove unused functions and structures 
Although the tpm_execute() series of functions are defined they are not
used anywhere. Several structures in the include/grub/efi/tpm.h header
file are not used too. There is even nonexistent grub_tpm_init()
declaration in this header. Delete all that unneeded stuff.

If somebody needs the functionality implemented in the dropped code then
he/she can re-add it later. Now it needlessly increases the GRUB
code/image size.

Signed-off-by: Tianjia Zhang <tianjia.zhang@linux.alibaba.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-18 22:31:29 +02:00
Tianjia Zhang
de094060ac shim_lock: Enable module for all EFI architectures 
Like the tpm the shim_lock module is only enabled for x86_64 target.
However, there's nothing specific to x86_64 in the implementation and
it can be enabled for all EFI architectures.

Signed-off-by: Tianjia Zhang <tianjia.zhang@linux.alibaba.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-18 22:26:48 +02:00
Daniel Kiper
1e81bf6d2d efi/tpm: Fix typo in grub_efi_tpm2_protocol struct 
Rename get_active_pcr_blanks() to get_active_pcr_banks().

Signed-off-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Javier Martinez Canillas <javierm@redhat.com>
 2020-09-18 21:23:21 +02:00
Daniel Kiper
c386331364 i386/efi/init: Drop bogus include 
Signed-off-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Javier Martinez Canillas <javierm@redhat.com>
 2020-09-18 21:22:32 +02:00
Daniel Kiper
30c4e3ca40 docs: Fix devicetree command description 
Specifically fix the subsection and drop bogus reference to the GNU/Linux.

Reported-by: Patrick Higgins <higgi1pt@gmail.com>
Signed-off-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Javier Martinez Canillas <javierm@redhat.com>
 2020-09-18 21:20:43 +02:00
Martin Whitaker
8451454889 grub-install: Fix inverted test for NLS enabled when copying locales 
Commit 3d8439da8 (grub-install: Locale depends on nls) attempted to avoid
copying locale files to the target directory when NLS was disabled.
However the test is inverted, and it does the opposite.

Signed-off-by: Martin Whitaker <fsf@martin-whitaker.me.uk>
Signed-off-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Javier Martinez Canillas <javierm@redhat.com>
 2020-09-18 21:17:07 +02:00
Javier Martinez Canillas
a6838bbc67 tftp: Roll-over block counter to prevent data packets timeouts 
Commit 781b3e5efc (tftp: Do not use priority queue) caused a regression
when fetching files over TFTP whose size is bigger than 65535 * block size.

  grub> linux /images/pxeboot/vmlinuz
  grub> echo $?
  0
  grub> initrd /images/pxeboot/initrd.img
  error: timeout reading '/images/pxeboot/initrd.img'.
  grub> echo $?
  28

It is caused by the block number counter being a 16-bit field, which leads
to a maximum file size of ((1 << 16) - 1) * block size. Because GRUB sets
the block size to 1024 octets (by using the TFTP Blocksize Option from RFC
2348 [0]), the maximum file size that can be transferred is 67107840 bytes.

The TFTP PROTOCOL (REVISION 2) RFC 1350 [1] does not mention what a client
should do when a file size is bigger than the maximum, but most TFTP hosts
support the block number counter to be rolled over. That is, acking a data
packet with a block number of 0 is taken as if the 65356th block was acked.

It was working before because the block counter roll-over was happening due
an overflow. But that got fixed by the mentioned commit, which led to the
regression when attempting to fetch files larger than the maximum size.

To allow TFTP file transfers of unlimited size again, re-introduce a block
counter roll-over so the data packets are acked preventing the timeouts.

[0]: https://tools.ietf.org/html/rfc2348
[1]: https://tools.ietf.org/html/rfc1350

Fixes: 781b3e5efc (tftp: Do not use priority queue)

Suggested-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-11 15:52:07 +02:00
Florian La Roche
3e9d8c4ce4 templates: Remove unnecessary trailing semicolon 
Signed-off-by: Florian La Roche <Florian.LaRoche@gmail.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-11 15:51:25 +02:00
Glenn Washburn
e1b0992a8d cryptodisk: Fix incorrect calculation of start sector 
Here dev is a grub_cryptodisk_t and dev->offset is offset in sectors of size
native to the cryptodisk device. The sector is correctly transformed into
native grub sector size, but then added to dev->offset which is not
transformed. It would be nice if the type system would help us with this.

Signed-off-by: Glenn Washburn <development@efficientek.com>
Reviewed-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-11 15:51:04 +02:00
Glenn Washburn
3b3ac0c982 cryptodisk: Unregister cryptomount command when removing module 
Signed-off-by: Glenn Washburn <development@efficientek.com>
Reviewed-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-11 15:48:50 +02:00
Patrick Steinhardt
eb77486141 luks2: Improve error reporting when decrypting/verifying key 
While we already set up error messages in both luks2_verify_key() and
luks2_decrypt_key(), we do not ever print them. This makes it really
hard to discover why a given key actually failed to decrypt a disk.

Improve this by including the error message in the user-visible output.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-11 15:48:13 +02:00
Patrick Steinhardt
1066336dc8 luks: Fix out-of-bounds copy of UUID 
When configuring a LUKS disk, we copy over the UUID from the LUKS header
into the new grub_cryptodisk_t structure via grub_memcpy(). As size
we mistakenly use the size of the grub_cryptodisk_t UUID field, which
is guaranteed to be strictly bigger than the LUKS UUID field we're
copying. As a result, the copy always goes out-of-bounds and copies some
garbage from other surrounding fields. During runtime, this isn't
noticed due to the fact that we always NUL-terminate the UUID and thus
never hit the trailing garbage.

Fix the issue by using the size of the local stripped UUID field.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-11 15:47:39 +02:00
Patrick Steinhardt
b35792dccb json: Remove invalid typedef redefinition 
The C standard does not allow for typedef redefinitions, even if they
map to the same underlying type. In order to avoid including the
jsmn.h in json.h and thus exposing jsmn's internals, we have exactly
such a forward-declaring typedef in json.h. If enforcing the GNU99 C
standard, clang may generate a warning about this non-standard
construct.

Fix the issue by using a simple "struct jsmntok" forward declaration
instead of using a typedef.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Tested-by: Chuck Tuffli <chuck@freebsd.org>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-11 15:46:55 +02:00
Cao jin
74259522d7 i386/relocator_common: Drop empty #ifdef 
Signed-off-by: Cao jin <caoj.fnst@cn.fujitsu.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-11 15:46:36 +02:00
Ave Milia
a0ba8fae61 video/bochs: Fix typo 
Signed-off-by: Ave Milia <avemilia@protonmail.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-09-11 15:45:56 +02:00
Colin Watson
e7b8856f8b linux: Fix integer overflows in initrd size handling 
These could be triggered by a crafted filesystem with very large files.

Fixes: CVE-2020-15707

Signed-off-by: Colin Watson <cjwatson@debian.org>
Reviewed-by: Jan Setje-Eilers <jan.setjeeilers@oracle.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Peter Jones
0dcbf3652b loader/linux: Avoid overflow on initrd size calculation 
Signed-off-by: Peter Jones <pjones@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Alexey Makhalov
f7bd9986f6 efi: Fix use-after-free in halt/reboot path 
commit 92bfc33db9 ("efi: Free malloc regions on exit")
introduced memory freeing in grub_efi_fini(), which is
used not only by exit path but by halt/reboot one as well.
As result of memory freeing, code and data regions used by
modules, such as halt, reboot, acpi (used by halt) also got
freed. After return to module code, CPU executes, filled
by UEFI firmware (tested with edk2), 0xAFAFAFAF pattern as
a code. Which leads to #UD exception later.

grub> halt
!!!! X64 Exception Type - 06(#UD - Invalid Opcode)  CPU Apic ID - 00000000 !!!!
RIP  - 0000000003F4EC28, CS  - 0000000000000038, RFLAGS - 0000000000200246
RAX  - 0000000000000000, RCX - 00000000061DA188, RDX - 0A74C0854DC35D41
RBX  - 0000000003E10E08, RSP - 0000000007F0F860, RBP - 0000000000000000
RSI  - 00000000064DB768, RDI - 000000000832C5C3
R8   - 0000000000000002, R9  - 0000000000000000, R10 - 00000000061E2E52
R11  - 0000000000000020, R12 - 0000000003EE5C1F, R13 - 00000000061E0FF4
R14  - 0000000003E10D80, R15 - 00000000061E2F60
DS   - 0000000000000030, ES  - 0000000000000030, FS  - 0000000000000030
GS   - 0000000000000030, SS  - 0000000000000030
CR0  - 0000000080010033, CR2 - 0000000000000000, CR3 - 0000000007C01000
CR4  - 0000000000000668, CR8 - 0000000000000000
DR0  - 0000000000000000, DR1 - 0000000000000000, DR2 - 0000000000000000
DR3  - 0000000000000000, DR6 - 00000000FFFF0FF0, DR7 - 0000000000000400
GDTR - 00000000079EEA98 0000000000000047, LDTR - 0000000000000000
IDTR - 0000000007598018 0000000000000FFF,   TR - 0000000000000000
FXSAVE_STATE - 0000000007F0F4C0

Proposal here is to continue to free allocated memory for
exit boot services path but keep it for halt/reboot path
as it won't be much security concern here.
Introduced GRUB_LOADER_FLAG_EFI_KEEP_ALLOCATED_MEMORY
loader flag to be used by efi halt/reboot path.

Signed-off-by: Alexey Makhalov <amakhalov@vmware.com>
Reviewed-by: Darren Kenny <darren.kenny@oracle.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Daniel Kiper
098058752e efi/chainloader: Propagate errors from copy_file_path() 
Without any error propagated to the caller, make_file_path()
would then try to advance the invalid device path node with
GRUB_EFI_NEXT_DEVICE_PATH(), which would fail, returning a NULL
pointer that would subsequently be dereferenced. Hence, propagate
errors from copy_file_path().

Signed-off-by: Chris Coulson <chris.coulson@canonical.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Peter Jones
d2cf823d0e efi: Fix some malformed device path arithmetic errors 
Several places we take the length of a device path and subtract 4 from
it, without ever checking that it's >= 4. There are also cases where
this kind of malformation will result in unpredictable iteration,
including treating the length from one dp node as the type in the next
node. These are all errors, no matter where the data comes from.

This patch adds a checking macro, GRUB_EFI_DEVICE_PATH_VALID(), which
can be used in several places, and makes GRUB_EFI_NEXT_DEVICE_PATH()
return NULL and GRUB_EFI_END_ENTIRE_DEVICE_PATH() evaluate as true when
the length is too small. Additionally, it makes several places in the
code check for and return errors in these cases.

Signed-off-by: Peter Jones <pjones@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Peter Jones
b73cee7f1f emu: Make grub_free(NULL) safe 
The grub_free() implementation in grub-core/kern/mm.c safely handles
NULL pointers, and code at many places depends on this. We don't know
that the same is true on all host OSes, so we need to handle the same
behavior in grub-emu's implementation.

Signed-off-by: Peter Jones <pjones@redhat.com>
Reviewed-by: Darren Kenny <darren.kenny@oracle.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Peter Jones
879c4a8342 lvm: Fix two more potential data-dependent alloc overflows 
It appears to be possible to make a (possibly invalid) lvm PV with
a metadata size field that overflows our type when adding it to the
address we've allocated. Even if it doesn't, it may be possible to do so
with the math using the outcome of that as an operand. Check them both.

Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Darren Kenny <darren.kenny@oracle.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Peter Jones
f5703eb062 hfsplus: Fix two more overflows 
Both node->size and node->namelen come from the supplied filesystem,
which may be user-supplied. We can't trust them for the math unless we
know they don't overflow. Making sure they go through grub_add() or
grub_calloc() first will give us that.

Signed-off-by: Peter Jones <pjones@redhat.com>
Reviewed-by: Darren Kenny <darren.kenny@oracle.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Alexey Makhalov
07e5b79e22 relocator: Fix grub_relocator_alloc_chunk_align() top memory allocation 
Current implementation of grub_relocator_alloc_chunk_align()
does not allow allocation of the top byte.

Assuming input args are:
  max_addr = 0xfffff000;
  size = 0x1000;

And this is valid. But following overflow protection will
unnecessarily move max_addr one byte down (to 0xffffefff):
  if (max_addr > ~size)
    max_addr = ~size;

~size + 1 will fix the situation. In addition, check size
for non zero to do not zero max_addr.

Signed-off-by: Alexey Makhalov <amakhalov@vmware.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Chris Coulson
426f57383d script: Avoid a use-after-free when redefining a function during execution 
Defining a new function with the same name as a previously defined
function causes the grub_script and associated resources for the
previous function to be freed. If the previous function is currently
executing when a function with the same name is defined, this results
in use-after-frees when processing subsequent commands in the original
function.

Instead, reject a new function definition if it has the same name as
a previously defined function, and that function is currently being
executed. Although a behavioural change, this should be backwards
compatible with existing configurations because they can't be
dependent on the current behaviour without being broken.

Fixes: CVE-2020-15706

Signed-off-by: Chris Coulson <chris.coulson@canonical.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Chris Coulson
1a8d9c9b4a script: Remove unused fields from grub_script_function struct 
Signed-off-by: Chris Coulson <chris.coulson@canonical.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Alexey Makhalov
61ff5602fe relocator: Protect grub_relocator_alloc_chunk_align() max_addr against integer underflow 
This commit introduces integer underflow mitigation in max_addr calculation
in grub_relocator_alloc_chunk_align() invocation.

It consists of 2 fixes:
  1. Introduced grub_relocator_alloc_chunk_align_safe() wrapper function to perform
     sanity check for min/max and size values, and to make safe invocation of
     grub_relocator_alloc_chunk_align() with validated max_addr value. Replace all
     invocations such as grub_relocator_alloc_chunk_align(..., min_addr, max_addr - size, size, ...)
     by grub_relocator_alloc_chunk_align_safe(..., min_addr, max_addr, size, ...).
  2. Introduced UP_TO_TOP32(s) macro for the cases where max_addr is 32-bit top
     address (0xffffffff - size + 1) or similar.

Signed-off-by: Alexey Makhalov <amakhalov@vmware.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Alexey Makhalov
caea56d1f8 relocator: Protect grub_relocator_alloc_chunk_addr() input args against integer underflow/overflow 
Use arithmetic macros from safemath.h to accomplish it. In this commit,
I didn't want to be too paranoid to check every possible math equation
for overflow/underflow. Only obvious places (with non zero chance of
overflow/underflow) were refactored.

Signed-off-by: Alexey Makhalov <amakhalov@vmware.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Alexey Makhalov
781b3e5efc tftp: Do not use priority queue 
There is not need to reassemble the order of blocks. Per RFC 1350,
server must wait for the ACK, before sending next block. Data packets
can be served immediately without putting them to priority queue.

Logic to handle incoming packet is this:
  - if packet block id equal to expected block id, then
    process the packet,
  - if packet block id is less than expected - this is retransmit
    of old packet, then ACK it and drop the packet,
  - if packet block id is more than expected - that shouldn't
    happen, just drop the packet.

It makes the tftp receive path code simpler, smaller and faster.
As a benefit, this change fixes CID# 73624 and CID# 96690, caused
by following while loop:

  while (cmp_block (grub_be_to_cpu16 (tftph->u.data.block), data->block + 1) == 0)

where tftph pointer is not moving from one iteration to another, causing
to serve same packet again. Luckily, double serving didn't happen due to
data->block++ during the first iteration.

Fixes: CID 73624, CID 96690

Signed-off-by: Alexey Makhalov <amakhalov@vmware.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Konrad Rzeszutek Wilk
f8ad7a3dd8 multiboot2: Fix memory leak if grub_create_loader_cmdline() fails 
Fixes: CID 292468

Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Konrad Rzeszutek Wilk
d17770857e udf: Fix memory leak 
Fixes: CID 73796

Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Jan Setje-Eilers <jan.setjeeilers@oracle.com>
 2020-07-29 16:55:48 +02:00
Konrad Rzeszutek Wilk
61b7ca08d1 term: Fix overflow on user inputs 
This requires a very weird input from the serial interface but can cause
an overflow in input_buf (keys) overwriting the next variable (npending)
with the user choice:

(pahole output)

struct grub_terminfo_input_state {
        int                        input_buf[6];         /*     0    24 */
        int                        npending;             /*    24     4 */ <- CORRUPT
        ...snip...

The magic string requires causing this is "ESC,O,],0,1,2,q" and we overflow
npending with "q" (aka increase npending to 161). The simplest fix is to
just to disallow overwrites input_buf, which exactly what this patch does.

Fixes: CID 292449

Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Konrad Rzeszutek Wilk
16c0dbf4bc lzma: Make sure we don't dereference past array 
The two dimensional array p->posSlotEncoder[4][64] is being dereferenced
using the GetLenToPosState() macro which checks if len is less than 5,
and if so subtracts 2 from it. If len = 0, that is 0 - 2 = 4294967294.
Obviously we don't want to dereference that far out so we check if the
position found is greater or equal kNumLenToPosStates (4) and bail out.

N.B.: Upstream LZMA 18.05 and later has this function completely rewritten
without any history.

Fixes: CID 51526

Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Chris Coulson
dc052e5ac7 json: Avoid a double-free when parsing fails. 
When grub_json_parse() succeeds, it returns the root object which
contains a pointer to the provided JSON string. Callers are
responsible for ensuring that this string outlives the root
object and for freeing its memory when it's no longer needed.

If grub_json_parse() fails to parse the provided JSON string,
it frees the string before returning an error. This results
in a double free in luks2_recover_key(), which also frees the
same string after grub_json_parse() returns an error.

This changes grub_json_parse() to never free the JSON string
passed to it, and updates the documentation for it to make it
clear that callers are responsible for ensuring that the string
outlives the root JSON object.

Fixes: CID 292465

Signed-off-by: Chris Coulson <chris.coulson@canonical.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Alexey Makhalov
6d7a59a2a1 xnu: Fix double free in grub_xnu_devprop_add_property() 
grub_xnu_devprop_add_property() should not free utf8 and utf16 as it get
allocated and freed in the caller.

Minor improvement: do prop fields initialization after memory allocations.

Fixes: CID 292442, CID 292457, CID 292460, CID 292466

Signed-off-by: Alexey Makhalov <amakhalov@vmware.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Alexey Makhalov
26a8c19307 gfxmenu: Fix double free in load_image() 
self->bitmap should be zeroed after free. Otherwise, there is a chance
to double free (USE_AFTER_FREE) it later in rescale_image().

Fixes: CID 292472

Signed-off-by: Alexey Makhalov <amakhalov@vmware.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Daniel Kiper
89f3da1a3d font: Do not load more than one NAME section 
The GRUB font file can have one NAME section only. Though if somebody
crafts a broken font file with many NAME sections and loads it then the
GRUB leaks memory. So, prevent against that by loading first NAME
section and failing in controlled way on following one.

Reported-by: Chris Coulson <chris.coulson@canonical.com>
Signed-off-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Jan Setje-Eilers <jan.setjeeilers@oracle.com>
 2020-07-29 16:55:48 +02:00
Peter Jones
2a1edcf2ed iso9660: Don't leak memory on realloc() failures 
Signed-off-by: Peter Jones <pjones@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:48 +02:00
Peter Jones
3f05d693d1 malloc: Use overflow checking primitives where we do complex allocations 
This attempts to fix the places where we do the following where
arithmetic_expr may include unvalidated data:

  X = grub_malloc(arithmetic_expr);

It accomplishes this by doing the arithmetic ahead of time using grub_add(),
grub_sub(), grub_mul() and testing for overflow before proceeding.

Among other issues, this fixes:
  - allocation of integer overflow in grub_video_bitmap_create()
    reported by Chris Coulson,
  - allocation of integer overflow in grub_png_decode_image_header()
    reported by Chris Coulson,
  - allocation of integer overflow in grub_squash_read_symlink()
    reported by Chris Coulson,
  - allocation of integer overflow in grub_ext2_read_symlink()
    reported by Chris Coulson,
  - allocation of integer overflow in read_section_as_string()
    reported by Chris Coulson.

Fixes: CVE-2020-14309, CVE-2020-14310, CVE-2020-14311

Signed-off-by: Peter Jones <pjones@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:47 +02:00
Peter Jones
f725fa7cb2 calloc: Use calloc() at most places 
This modifies most of the places we do some form of:

  X = malloc(Y * Z);

to use calloc(Y, Z) instead.

Among other issues, this fixes:
  - allocation of integer overflow in grub_png_decode_image_header()
    reported by Chris Coulson,
  - allocation of integer overflow in luks_recover_key()
    reported by Chris Coulson,
  - allocation of integer overflow in grub_lvm_detect()
    reported by Chris Coulson.

Fixes: CVE-2020-14308

Signed-off-by: Peter Jones <pjones@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:47 +02:00
Peter Jones
64e26162eb calloc: Make sure we always have an overflow-checking calloc() available 
This tries to make sure that everywhere in this source tree, we always have
an appropriate version of calloc() (i.e. grub_calloc(), xcalloc(), etc.)
available, and that they all safely check for overflow and return NULL when
it would occur.

Signed-off-by: Peter Jones <pjones@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:47 +02:00
Peter Jones
68708c4503 safemath: Add some arithmetic primitives that check for overflow 
This adds a new header, include/grub/safemath.h, that includes easy to
use wrappers for __builtin_{add,sub,mul}_overflow() declared like:

  bool OP(a, b, res)

where OP is grub_add, grub_sub or grub_mul. OP() returns true in the
case where the operation would overflow and res is not modified.
Otherwise, false is returned and the operation is executed.

These arithmetic primitives require newer compiler versions. So, bump
these requirements in the INSTALL file too.

Signed-off-by: Peter Jones <pjones@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:47 +02:00
Peter Jones
a4d3fbdff1 yylex: Make lexer fatal errors actually be fatal 
When presented with a command that can't be tokenized to anything
smaller than YYLMAX characters, the parser calls YY_FATAL_ERROR(errmsg),
expecting that will stop further processing, as such:

  #define YY_DO_BEFORE_ACTION \
        yyg->yytext_ptr = yy_bp; \
        yyleng = (int) (yy_cp - yy_bp); \
        yyg->yy_hold_char = *yy_cp; \
        *yy_cp = '\0'; \
        if ( yyleng >= YYLMAX ) \
                YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \
        yy_flex_strncpy( yytext, yyg->yytext_ptr, yyleng + 1 , yyscanner); \
        yyg->yy_c_buf_p = yy_cp;

The code flex generates expects that YY_FATAL_ERROR() will either return
for it or do some form of longjmp(), or handle the error in some way at
least, and so the strncpy() call isn't in an "else" clause, and thus if
YY_FATAL_ERROR() is *not* actually fatal, it does the call with the
questionable limit, and predictable results ensue.

Unfortunately, our implementation of YY_FATAL_ERROR() is:

   #define YY_FATAL_ERROR(msg)                     \
     do {                                          \
       grub_printf (_("fatal error: %s\n"), _(msg));     \
     } while (0)

The same pattern exists in yyless(), and similar problems exist in users
of YY_INPUT(), several places in the main parsing loop,
yy_get_next_buffer(), yy_load_buffer_state(), yyensure_buffer_stack,
yy_scan_buffer(), etc.

All of these callers expect YY_FATAL_ERROR() to actually be fatal, and
the things they do if it returns after calling it are wildly unsafe.

Fixes: CVE-2020-10713

Signed-off-by: Peter Jones <pjones@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-07-29 16:55:47 +02:00
Marc Zyngier
6a34fdb76a arm: Fix 32-bit ARM handling of the CTR register 
When booting on an ARMv8 core that implements either CTR.IDC or CTR.DIC
(indicating that some of the cache maintenance operations can be
removed when dealing with I/D-cache coherency, GRUB dies with a
"Unsupported cache type 0x........" message.

This is pretty likely to happen when running in a virtual machine
hosted on an arm64 machine (I've triggered it on a system built around
a bunch of Cortex-A55 cores, which implements CTR.IDC).

It turns out that the way GRUB deals with the CTR register is a bit
harsh for anything from ARMv7 onwards. The layout of the register is
backward compatible, meaning that nothing that gets added is allowed to
break earlier behaviour. In this case, ignoring IDC is completely fine,
and only results in unnecessary cache maintenance.

We can thus avoid being paranoid, and align the 32bit behaviour with
its 64bit equivalent.

This patch has the added benefit that it gets rid of a (gnu-specific)
case range too.

Signed-off-by: Marc Zyngier <maz@kernel.org>
Reviewed-by: Leif Lindholm <leif@nuviainc.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-25 15:02:51 +02:00
Ian Jackson
a81401ff49 templates/20_linux_xen: Support Xen Security Modules (XSM/FLASK) 
XSM is enabled by adding "flask=enforcing" as a Xen command line
argument, and providing the policy file as a grub module.

We make entries for both with and without XSM. If XSM is not compiled
into Xen, then there are no policy files, so no change to the boot
options.

Signed-off-by: Ian Jackson <ian.jackson@eu.citrix.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-25 15:00:56 +02:00
Ian Jackson
7a9b30143b templates/20_linux_xen: Ignore xenpolicy and config files too 
file_is_not_sym() currently only checks for xen-syms. Extend it to
disregard xenpolicy (XSM policy files) and files ending .config (which
are built by the Xen upstream build system in some configurations and
can therefore end up in /boot).

Rename the function accordingly, to file_is_not_xen_garbage().

Signed-off-by: Ian Jackson <ian.jackson@eu.citrix.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-25 15:00:37 +02:00
Javier Martinez Canillas
96be75ecbd net: Break out nested function 
Nested functions are not supported in C, but are permitted as an extension
in the GNU C dialect. Commit cb2f15c544 ("normal/main: Search for specific
config files for netboot") added a nested function which caused the build
to break when compiling with clang.

Break that out into a static helper function to make the code portable again.

Reported-by: Daniel Axtens <dja@axtens.net>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Tested-by: Daniel Axtens <dja@axtens.net>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-25 14:52:10 +02:00
Javier Martinez Canillas
cc6bd49a52 tpm: Enable module for all EFI platforms 
The module is only enabled for x86_64, but there's nothing specific to
x86_64 in the implementation and can be enabled for all EFI platforms.

Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-25 14:50:42 +02:00
Daniel Kiper
15d76540a7 INSTALL/configure: Update install doc and configure comment 
..to reflect the GRUB build reality in them.

Additionally, fix text formatting a bit.

Signed-off-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Leif Lindholm <leif@nuviainc.com>
 2020-05-25 14:49:53 +02:00
Daniel Kiper
c894713836 configure: Set gnu99 C language standard by default 
Commit d5a32255d (misc: Make grub_strtol() "end" pointers have safer
const qualifiers) introduced "restrict" keyword into some functions
definitions. This keyword was introduced in C99 standard. However, some
compilers by default may use C89 or something different. This behavior
leads to the breakage during builds when c89 or gnu89 is in force. So,
let's set gnu99 C language standard for all compilers by default. This
way a bit random build issue will be fixed and the GRUB source will be
build consistently regardless of type and version of the compiler.

It was decided to use gnu99 C language standard because it fixes the
issue mentioned above and also provides some useful extensions which are
used here and there in the GRUB source. Potentially we can use gnu11
too. However, this may reduce pool of older compilers which can be used
to build the GRUB. So, let's live with gnu99 until we discover that we
strongly require a feature from newer C standard.

The user is still able to override C language standard using relevant
*_CFLAGS variables.

Signed-off-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Leif Lindholm <leif@nuviainc.com>
 2020-05-25 14:43:16 +02:00
Tianjia Zhang
c867185b81 tpm: Rename function grub_tpm_log_event() to grub_tpm_measure() 
grub_tpm_log_event() and grub_tpm_measure() are two functions that
have the same effect. So, keep grub_tpm_log_event() and rename it
to grub_tpm_measure(). This way we get also a more clear semantics.

Signed-off-by: Tianjia Zhang <tianjia.zhang@linux.alibaba.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-15 15:37:28 +02:00
Daniel Kiper
f39f1ec5d9 autogen: Replace -iname with -ipath in find command 
..because -iname cannot be used to match paths.

Signed-off-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Leif Lindholm <leif@nuviainc.com>
Reviewed-by: Daniel Axtens <dja@axtens.net>
 2020-05-15 15:35:59 +02:00
Daniel Kiper
f2d56dea9d INSTALL: Update configure example 
..to make it more relevant.

Signed-off-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Leif Lindholm <leif@nuviainc.com>
 2020-05-15 15:34:43 +02:00
Daniel Kiper
4aa9614e0a configure: Drop unneeded TARGET_CFLAGS expansion 
Signed-off-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Leif Lindholm <leif@nuviainc.com>
 2020-05-15 15:33:08 +02:00
Jacob Kroon
5ab40eb9f7 docs/grub: Support for probing partition UUID on MSDOS disks 
Support was implemented in commit c7cb11b21 (probe: Support probing for
msdos PARTUUID).

Signed-off-by: Jacob Kroon <jacob.kroon@gmail.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-15 15:27:58 +02:00
Tianjia Zhang
0fa9ed41ac verifiers: Add verify string debug message 
Like grub_verifiers_open(), the grub_verify_string() should also
display this debug message, which is very helpful for debugging.

Signed-off-by: Tianjia Zhang <tianjia.zhang@linux.alibaba.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-15 15:26:41 +02:00
Javier Martinez Canillas
0f3600bf1b envblk: Fix buffer overrun when attempting to shrink a variable value 
If an existing variable is set with a value whose length is smaller than
the current value, a memory corruption can happen due copying padding '#'
characters outside of the environment block buffer.

This is caused by a wrong calculation of the previous free space position
after moving backward the characters that followed the old variable value.

That position is calculated to fill the remaining of the buffer with the
padding '#' characters. But since isn't calculated correctly, it can lead
to copies outside of the buffer.

The issue can be reproduced by creating a variable with a large value and
then try to set a new value that is much smaller:

$ grub2-editenv --version
grub2-editenv (GRUB) 2.04

$ grub2-editenv env create

$ grub2-editenv env set a="$(for i in {1..500}; do var="b$var"; done; echo $var)"

$ wc -c env
1024 grubenv

$ grub2-editenv env set a="$(for i in {1..50}; do var="b$var"; done; echo $var)"
malloc(): corrupted top size
Aborted (core dumped)

$ wc -c env
0 grubenv

Reported-by: Renaud Métrich <rmetrich@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-15 15:24:59 +02:00
Hans Ulrich Niedermann
2f317c8f19 docs: Remove docs for non-existing uppermem command 
Remove all documentation of and mentions of the uppermem
command from the docs/grub.texi file.

The uppermem command is not implemented in the GRUB source
at all and appears to never have been implemented despite
former plans to add an uppermem command.

To reduce user confusion, this even removes the paragraph
describing how GRUB's uppermem command was supposed to
complement the Linux kernel's mem= parameter.

Signed-off-by: Hans Ulrich Niedermann <hun@n-dimensional.de>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-15 15:23:00 +02:00
Hans Ulrich Niedermann
f7dcb6a5c2 docs: Remove docs for non-existing pxe_unload command 
Remove the documentation of the pxe_unload command from the
docs/grub.texi file.

The pxe_unload command is not implemented in the grub source
at this time at all. It appears to have been removed in commit
671a78acb (cleanup pxe and efi network release).

Signed-off-by: Hans Ulrich Niedermann <hun@n-dimensional.de>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-15 15:20:55 +02:00
Hans Ulrich Niedermann
2ceae0ae25 gitignore: Add a few forgotten file patterns 
Add a few patterns to .gitignore to cover files which are generated
by building grub ("make", "make check", "make dist") but which have
been forgotten to add to .gitignore in the past.

Signed-off-by: Hans Ulrich Niedermann <hun@n-dimensional.de>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-15 15:06:21 +02:00
Hans Ulrich Niedermann
641a144085 gitignore: Add leading slashes where appropriate 
Going through the list of gitignore patterns without a leading slash,
this adds a leading slash where it appears to have been forgotten.

Some gitignore patterns like ".deps/" or "Makefile" clearly should
match everywhere, so those definitively need no leading slash.

For some patterns like "ascii.bitmaps", it is unclear where in the
source tree they should match. Those patterns are kept as they are,
matching the patterns in the whole tree of subdirectories.

Signed-off-by: Hans Ulrich Niedermann <hun@n-dimensional.de>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-15 15:06:13 +02:00
Hans Ulrich Niedermann
6cfa746654 gitignore: Add trailing slashes for directories 
Add trailing slashes for all patterns matching directories.

Note that we do *not* add trailing slashes for *symlinks*
to directories.

Signed-off-by: Hans Ulrich Niedermann <hun@n-dimensional.de>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-15 15:04:17 +02:00
Hans Ulrich Niedermann
c745f02165 gitignore: Sort both pattern groups alphabetically 
Alphabetically sort the two groups of gitignore patterns:

  * The group of patterns without slashes, matching anywhere
    in the directory subtree.

  * The group of patterns with slashes, matching relative to the
    .gitignore file's directory

Signed-off-by: Hans Ulrich Niedermann <hun@n-dimensional.de>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-15 15:04:07 +02:00
Hans Ulrich Niedermann
26b7d55d82 gitignore: Group patterns with and without slash 
Group the .gitignore patterns into two groups:

  * Pattern not including a slash, i.e. matching files anywhere in
    the .gitignore file's directory and all of its subdirectories.

  * Patterns including a slash, i.e. matching only relative to the
    .gitignore file's directory.

Signed-off-by: Hans Ulrich Niedermann <hun@n-dimensional.de>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-15 14:59:47 +02:00
Hans Ulrich Niedermann
16923f88ad gitignore: Consistent leading slash is easier to read 
As all gitignore patterns containing a left or middle slash match
only relative to the .gitignore file's directory, we write them
all in the same manner with a leading slash.

This makes the file significantly easier to read.

Signed-off-by: Hans Ulrich Niedermann <hun@n-dimensional.de>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-15 14:50:30 +02:00
Daniel Kiper
eb46ee98bc mips/cache: Add missing nop's in delay slots 
Lack of them causes random instructions to be executed before the
jump really happens.

Signed-off-by: Vladimir Serbinenko <phcoder@google.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-05-15 14:30:07 +02:00
Patrick Steinhardt
c543d67810 luks2: Propagate error when reading area key fails 
When decrypting a given keyslot, all error cases except for one set up
an error and return the error code. The only exception is when we try to
read the area key: instead of setting up an error message, we directly
print it via grub_dprintf().

Convert the outlier to use grub_error() to allow more uniform handling
of errors.

Signed-off-by: Patrick Steinhardt <ps@kps.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-04-21 22:18:26 +02:00
Patrick Steinhardt
e933feb578 json: Get rid of casts for "jsmntok_t" 
With the upstream change having landed that adds a name to the
previously anonymous "jsmntok" typedef, we can now add a forward
declaration for that struct in our code. As a result, we no longer have
to store the "tokens" member of "struct grub_json" as a void pointer but
can instead use the forward declaration, allowing us to get rid of casts
of that field.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-04-21 22:16:41 +02:00
Patrick Steinhardt
3b81607b55 json: Update jsmn library to upstream commit 053d3cd 
Update our embedded version of the jsmn library to upstream commit
053d3cd (Merge pull request #175 from pks-t/pks/struct-type,
2020-04-02).

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-04-21 22:15:14 +02:00
Steve Langasek
46d76f8fef templates: Output a menu entry for firmware setup on UEFI FastBoot systems 
The fwsetup command allows to reboot into the EFI firmware setup menu, add
a template to include a menu entry on EFI systems that makes use of that
command to reboot into the EFI firmware settings.

This is useful for users since the hotkey to enter into the EFI setup menu
may not be the same on all systems so users can use the menu entry without
needing to figure out what key needs to be pressed.

Also, if fastboot is enabled in the BIOS then often it is not possible to
enter the firmware setup menu. So the entry is again useful for this case.

Signed-off-by: Steve Langasek <steve.langasek@ubuntu.com>
Signed-off-by: Dimitri John Ledkov <xnox@ubuntu.com>
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-04-21 22:14:12 +02:00
Hans de Goede
12341958d2 kern/term: Accept ESC, F4 and holding SHIFT as user interrupt keys 
On some devices the ESC key is the hotkey to enter the BIOS/EFI setup
screen, making it really hard to time pressing it right. Besides that
ESC is also pretty hard to discover for a user who does not know it
will unhide the menu.

This commit makes F4, which was chosen because is not used as a hotkey
to enter the BIOS setup by any vendor, also interrupt sleeps / stop the
menu countdown.

This solves the ESC gets into the BIOS setup and also somewhat solves
the discoverability issue, but leaves the timing issue unresolved.

This commit fixes the timing issue by also adding support for keeping
SHIFT pressed during boot to stop the menu countdown. This matches
what Ubuntu is doing, which should also help with discoverability.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-04-21 22:13:44 +02:00
Hans de Goede
2d7c3abd87 efi/console: Do not set text-mode until we actually need it 
If we're running with a hidden menu we may never need text mode, so do not
change the video-mode to text until we actually need it.

This allows to boot a machine without unnecessary graphical transitions and
provide a seamless boot experience to users.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-04-21 22:13:14 +02:00
Hans de Goede
ea138d11be efi/console: Implement getkeystatus() support 
Implement getkeystatus() support in the EFI console driver.

This is needed because the logic to determine if a key was pressed to make
the menu countdown stop will be changed by a later patch to also take into
account the SHIFT key being held down.

For this reason the EFI console driver has to support getkeystatus() to
allow detecting that event.

Note that if a non-modifier key gets pressed and repeated calls to
getkeystatus() are made then it will return the modifier status at the
time of the non-modifier key, until that key-press gets consumed by a
getkey() call.

This is a side-effect of how the EFI simple-text-input protocol works
and cannot be avoided.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-04-21 22:12:50 +02:00
Hans de Goede
8bab36af60 efi/console: Add grub_console_read_key_stroke() helper function 
This is a preparatory patch for adding getkeystatus() support to the
EFI console driver.

We can get modifier status through the simple_text_input read_key_stroke()
method, but if a non-modifier key is (also) pressed the read_key_stroke()
call will consume that key from the firmware's queue.

The new grub_console_read_key_stroke() helper buffers upto 1 key-stroke.
If it has a non-modifier key buffered, it will return that one, if its
buffer is empty, it will fills its buffer by getting a new key-stroke.

If called with consume=1 it will empty its buffer after copying the
key-data to the callers buffer, this is how getkey() will use it.

If called with consume=0 it will keep the last key-stroke buffered, this
is how getkeystatus() will call it. This means that if a non-modifier
key gets pressed, repeated getkeystatus() calls will return the modifiers
of that key-press until it is consumed by a getkey() call.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-04-21 22:11:17 +02:00
Hans de Goede
5bcdf67642 kern/term: Make grub_getkeystatus() helper function available everywhere 
Move grub_getkeystatushelper() function from grub-core/commands/keystatus.c
to grub-core/kern/term.c and export it so that it can be used outside of
the keystatus command code too.

There's no logic change in this patch. The function definition is moved so
it can be called from grub-core/kern/term.c in a subsequent patch. It will
be used to determine if a SHIFT key has was held down and use that also to
interrupt the countdown, without the need to press a key at the right time.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-04-21 22:08:52 +02:00
Javier Martinez Canillas
30586747f1 efi/console: Move grub_console_set{colorstate,cursor} higher in the file 
This is just a preparatory patch to move the functions higher in the file,
since these will be called by the grub_prepare_for_text_output() function
that will be introduced in a later patch.

The logic is unchanged by this patch. Functions definitions are just moved
to avoid a forward declaration in a later patch, keeping the code clean.

Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-04-21 22:07:56 +02:00
Paul Menzel
b0c7769a41 docs/grub: Fix typo in *preferred* 
Signed-off-by: Paul Menzel <pmenzel@molgen.mpg.de>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-04-21 22:03:09 +02:00
Daniel Axtens
06fd69a3fd powerpc/mkimage: Fix CHRP note descsz 
Currently, an image generated with 'grub-mkimage -n' causes an error when
read with 'readelf -a':

Displaying notes found at file offset 0x000106f0 with length 0x0000002c:
  Owner                Data size        Description
readelf: Warning: note with invalid namesz and/or descsz found at offset 0x0
readelf: Warning:  type: 0x1275, namesize: 0x00000008, descsize: 0x0000002c, alignment: 4

This is because the descsz of the CHRP note is set to
 sizeof (struct grub_ieee1275_note)
which is the size of the entire note, including name and elf header. The
desczs should contain only the contents, not the name and header sizes.

Set the descsz instead to 'sizeof (struct grub_ieee1275_note_desc)'

Resultant readelf output:

Displaying notes found at file offset 0x00010710 with length 0x0000002c:
  Owner                Data size        Description
  PowerPC              0x00000018       Unknown note type: (0x00001275)
   description data: ff ff ff ff 00 c0 00 00 ff ff ff ff ff ff ff ff ff ff ff ff 00 00 40 00

So far as I can tell this issue has existed for as long as the note
generation code has existed, but I guess nothing really checks descsz.

Signed-off-by: Daniel Axtens <dja@axtens.net>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-04-21 22:00:59 +02:00
Flavio Suligoi
2a6308b954 efi: Add missed space in GRUB_EFI_GLOBAL_VARIABLE_GUID 
Signed-off-by: Flavio Suligoi <f.suligoi@asem.it>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-31 12:17:03 +02:00
Michael Chang
68006d1732 zfs: Fix gcc10 error -Werror=zero-length-bounds 
We bumped into the build error while testing gcc-10 pre-release.

In file included from ../../include/grub/file.h:22,
		from ../../grub-core/fs/zfs/zfs.c:34:
../../grub-core/fs/zfs/zfs.c: In function 'zap_leaf_lookup':
../../grub-core/fs/zfs/zfs.c:2263:44: error: array subscript '<unknown>' is outside the bounds of an interior zero-length array 'grub_uint16_t[0]' {aka 'short unsigned int[0]'} [-Werror=zero-length-bounds]
2263 |   for (chunk = grub_zfs_to_cpu16 (l->l_hash[LEAF_HASH (blksft, h, l)], endian);
../../include/grub/types.h:241:48: note: in definition of macro 'grub_le_to_cpu16'
 241 | # define grub_le_to_cpu16(x) ((grub_uint16_t) (x))
     |                                                ^
../../grub-core/fs/zfs/zfs.c:2263:16: note: in expansion of macro 'grub_zfs_to_cpu16'
2263 |   for (chunk = grub_zfs_to_cpu16 (l->l_hash[LEAF_HASH (blksft, h, l)], endian);
     |                ^~~~~~~~~~~~~~~~~
In file included from ../../grub-core/fs/zfs/zfs.c:48:
../../include/grub/zfs/zap_leaf.h:72:16: note: while referencing 'l_hash'
  72 |  grub_uint16_t l_hash[0];
     |                ^~~~~~

Here I'd like to quote from the gcc document [1] which seems best to
explain what is going on here.

"Although the size of a zero-length array is zero, an array member of
this kind may increase the size of the enclosing type as a result of
tail padding. The offset of a zero-length array member from the
beginning of the enclosing structure is the same as the offset of an
array with one or more elements of the same type. The alignment of a
zero-length array is the same as the alignment of its elements.

Declaring zero-length arrays in other contexts, including as interior
members of structure objects or as non-member objects, is discouraged.
Accessing elements of zero-length arrays declared in such contexts is
undefined and may be diagnosed."

The l_hash[0] is apparnetly an interior member to the enclosed structure
while l_entries[0] is the trailing member. And the offending code tries
to access members in l_hash[0] array that triggers the diagnose.

Given that the l_entries[0] is used to get proper alignment to access
leaf chunks, we can accomplish the same thing through the ALIGN_UP macro
thus eliminating l_entries[0] from the structure. In this way we can
pacify the warning as l_hash[0] now becomes the last member to the
enclosed structure.

[1] https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html

Signed-off-by: Michael Chang <mchang@suse.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-31 12:17:03 +02:00
Michael Chang
bdf170d101 mdraid1x_linux: Fix gcc10 error -Werror=array-bounds 
We bumped into the build error while testing gcc-10 pre-release.

../../grub-core/disk/mdraid1x_linux.c: In function 'grub_mdraid_detect':
../../grub-core/disk/mdraid1x_linux.c:181:15: error: array subscript <unknown> is outside array bounds of 'grub_uint16_t[0]' {aka 'short unsigned int[0]'} [-Werror=array-bounds]
  181 |      (char *) &sb.dev_roles[grub_le_to_cpu32 (sb.dev_number)]
      |               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
../../grub-core/disk/mdraid1x_linux.c:98:17: note: while referencing 'dev_roles'
   98 |   grub_uint16_t dev_roles[0]; /* Role in array, or 0xffff for a spare, or 0xfffe for faulty.  */
      |                 ^~~~~~~~~
../../grub-core/disk/mdraid1x_linux.c:127:33: note: defined here 'sb'
  127 |       struct grub_raid_super_1x sb;
      |                                 ^~
cc1: all warnings being treated as errors

Apparently gcc issues the warning when trying to access sb.dev_roles
array's member, since it is a zero length array as the last element of
struct grub_raid_super_1x that is allocated sparsely without extra
chunks for the trailing bits, so the warning looks legitimate in this
regard.

As the whole thing here is doing offset computation, it is undue to use
syntax that would imply array member access then take address from it
later. Instead we could accomplish the same thing through basic array
pointer arithmetic to pacify the warning.

Signed-off-by: Michael Chang <mchang@suse.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-31 12:17:02 +02:00
Simon Hardy
6643507ce3 build: Fix GRUB i386-pc build with Ubuntu gcc 
With recent versions of gcc on Ubuntu a very large lzma_decompress.img file is
output. (e.g. 134479600 bytes instead of 2864.) This causes grub-mkimage to
fail with: "error: Decompressor is too big."

This seems to be caused by a section .note.gnu.property that is placed at an
offset such that objcopy needs to pad the img file with zeros.

This issue is present on:
Ubuntu 19.10 with gcc (Ubuntu 8.3.0-26ubuntu1~19.10) 8.3.0
Ubuntu 19.10 with gcc (Ubuntu 9.2.1-9ubuntu2) 9.2.1 20191008

This issue is not present on:
Ubuntu 19.10 with gcc (Ubuntu 7.5.0-3ubuntu1~19.10) 7.5.0
RHEL 8.0 with gcc 8.3.1 20190507 (Red Hat 8.3.1-4)

The issue can be fixed by removing the section using objcopy as shown in
this patch.

Signed-off-by: Simon Hardy <simon.hardy@itdev.co.uk>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-31 12:17:02 +02:00
Tianjia Zhang
800de4a1d0 efi/tpm: Fix memory leak in grub_tpm1/2_log_event() 
The memory requested for the event is not released here,
causing memory leaks. This patch fixes this problem.

Signed-off-by: Jia Zhang <zhang.jia@linux.alibaba.com>
Signed-off-by: Tianjia Zhang <tianjia.zhang@linux.alibaba.com>
Reviewed-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-31 12:16:32 +02:00
Michael Chang
5e5a47b8a7 docs: Document notes on LVM cache booting 
Add notes on LVM cache booting to the GRUB manual to help user understanding
the outstanding issue and status.

Signed-off-by: Michael Chang <mchang@suse.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-31 12:01:41 +02:00
Michael Chang
0454b04453 lvm: Add LVM cache logical volume handling 
The LVM cache logical volume is the logical volume consisting of the original
and the cache pool logical volume. The original is usually on a larger and
slower storage device while the cache pool is on a smaller and faster one. The
performance of the original volume can be improved by storing the frequently
used data on the cache pool to utilize the greater performance of faster
device.

The default cache mode "writethrough" ensures that any data written will be
stored both in the cache and on the origin LV, therefore grub can be straight
to read the original lv as no data loss is guarenteed.

The second cache mode is "writeback", which delays writing from the cache pool
back to the origin LV to have increased performance. The drawback is potential
data loss if losing the associated cache device.

During the boot time grub reads the LVM offline i.e. LVM volumes are not
activated and mounted, hence it should be fine to read directly from original
lv since all cached data should have been flushed back in the process of taking
it offline.

It is also not much helpful to the situation by adding fsync calls to the
install code. The fsync did not force to write back dirty cache to the original
device and rather it would update associated cache metadata to complete the
write transaction with the cache device. IOW the writes to cached blocks still
go only to the cache device.

To write back dirty cache, as LVM cache did not support dirty cache flush per
block range, there'no way to do it for file. On the other hand the "cleaner"
policy is implemented and can be used to write back "all" dirty blocks in a
cache, which effectively drain all dirty cache gradually to attain and last in
the "clean" state, which can be useful for shrinking or decommissioning a
cache. The result and effect is not what we are looking for here.

In conclusion, as it seems no way to enforce file writes to the original
device, grub may suffer from power failure as it cannot assemble the cache
device and read the dirty data from it. However since the case is only
applicable to writeback mode which is sensitive to data lost in nature, I'd
still like to propose my (relatively simple) patch and treat reading dirty
cache as improvement.

Signed-off-by: Michael Chang <mchang@suse.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-31 11:59:35 +02:00
Patrick Steinhardt
552c9fd081 gnulib: Fix build of base64 when compiling with memory debugging 
When building GRUB with memory management debugging enabled, then the
build fails because of `grub_debug_malloc()` and `grub_debug_free()`
being undefined in the luks2 module. The cause is that we patch
"base64.h" to unconditionaly include "config-util.h", which shouldn't be
included for modules at all. As a result, `MM_DEBUG` is defined when
building the module, causing it to use the debug memory allocation
functions. As these are not built into modules, we end up with a linker
error.

Fix the issue by removing the <config-util.h> include altogether. The
sole reason it was included was for the `_GL_ATTRIBUTE_CONST` macro,
which we can simply define as empty in case it's not set.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:58:36 +01:00
Patrick Steinhardt
2c43ab4ef7 build: Fix option to explicitly disable memory debugging 
The memory management system supports a debug mode that can be enabled
at build time by passing "--enable-mm-debug" to the configure script.
Passing the option will cause us define MM_DEBUG as expected, but in
fact the reverse option "--disable-mm-debug" will do the exact same
thing and also set up the define. This currently causes the build of
"lib/gnulib/base64.c" to fail as it tries to use `grub_debug_malloc()`
and `grub_debug_free()` even though both symbols aren't defined.

Seemingly, `AC_ARG_ENABLE()` will always execute the third argument if
either the positive or negative option was passed. Let's thus fix the
issue by moving the call to`AC_DEFINE()` into an explicit `if test
$xenable_mm_debug` block, similar to how other defines work.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Paul Menzel <pmenzel@molgen.mpg.de>
 2020-03-10 21:56:39 +01:00
David Michael
20def1a3c3 fat: Support file modification times 
This allows comparing file ages on EFI system partitions.

Signed-off-by: David Michael <fedora.dm0@gmail.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:52:07 +01:00
David Michael
8ad7c23864 exfat: Save the matching directory entry struct when searching 
This provides the node's attributes outside the iterator function
so the file modification time can be accessed and reported.

Signed-off-by: David Michael <fedora.dm0@gmail.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:48:05 +01:00
Mike Gilbert
1657e72f5b datetime: Enable the datetime module for the emu platform 
Fixes a build failure:

  grub-core/commands/date.c:49: undefined reference to `grub_get_weekday_name'
  grub-core/commands/ls.c:155: undefined reference to `grub_unixtime2datetime'

Bug: https://bugs.gentoo.org/711512

Signed-off-by: Mike Gilbert <floppym@gentoo.org>
Reviewed-by: Javier Martinez Canillas <javierm@redhat.com>
Tested-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:45:11 +01:00
John Paul Adrian Glaubitz
2bfd3654a6 build: Add soft-float handling for SuperH (sh4) 
While GRUB has no platform support for SuperH (sh4) yet, this change
adds the target-specific handling of soft-floats such that the GRUB
utilities can be built on this target.

Signed-off-by: John Paul Adrian Glaubitz <glaubitz@physik.fu-berlin.de>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:43:56 +01:00
Peter Jones
9b89b1dedb efi: Fix the type of grub_efi_status_t 
Currently, in some builds with some checkers, we see:

1. grub-core/disk/efi/efidisk.c:601: error[shiftTooManyBitsSigned]: Shifting signed 64-bit value by 63 bits is undefined behaviour

This is because grub_efi_status_t is defined as grub_efi_intn_t, which is
signed, and shifting into the sign bit is not defined behavior.  UEFI fixed
this in the spec in 2.3:

2.3 | Change the defined type of EFI_STATUS from INTN to UINTN | May 7, 2009

And the current EDK2 code has:
MdePkg/Include/Base.h-//
MdePkg/Include/Base.h-// Status codes common to all execution phases
MdePkg/Include/Base.h-//
MdePkg/Include/Base.h:typedef UINTN RETURN_STATUS;
MdePkg/Include/Base.h-
MdePkg/Include/Base.h-/**
MdePkg/Include/Base.h-  Produces a RETURN_STATUS code with the highest bit set.
MdePkg/Include/Base.h-
MdePkg/Include/Base.h-  @param  StatusCode    The status code value to convert into a warning code.
MdePkg/Include/Base.h-                        StatusCode must be in the range 0x00000000..0x7FFFFFFF.
MdePkg/Include/Base.h-
MdePkg/Include/Base.h-  @return The value specified by StatusCode with the highest bit set.
MdePkg/Include/Base.h-
MdePkg/Include/Base.h-**/
MdePkg/Include/Base.h-#define ENCODE_ERROR(StatusCode)     ((RETURN_STATUS)(MAX_BIT | (StatusCode)))
MdePkg/Include/Base.h-
MdePkg/Include/Base.h-/**
MdePkg/Include/Base.h-  Produces a RETURN_STATUS code with the highest bit clear.
MdePkg/Include/Base.h-
MdePkg/Include/Base.h-  @param  StatusCode    The status code value to convert into a warning code.
MdePkg/Include/Base.h-                        StatusCode must be in the range 0x00000000..0x7FFFFFFF.
MdePkg/Include/Base.h-
MdePkg/Include/Base.h-  @return The value specified by StatusCode with the highest bit clear.
MdePkg/Include/Base.h-
MdePkg/Include/Base.h-**/
MdePkg/Include/Base.h-#define ENCODE_WARNING(StatusCode)   ((RETURN_STATUS)(StatusCode))
MdePkg/Include/Base.h-
MdePkg/Include/Base.h-/**
MdePkg/Include/Base.h-  Returns TRUE if a specified RETURN_STATUS code is an error code.
MdePkg/Include/Base.h-
MdePkg/Include/Base.h-  This function returns TRUE if StatusCode has the high bit set.  Otherwise, FALSE is returned.
MdePkg/Include/Base.h-
MdePkg/Include/Base.h-  @param  StatusCode    The status code value to evaluate.
MdePkg/Include/Base.h-
MdePkg/Include/Base.h-  @retval TRUE          The high bit of StatusCode is set.
MdePkg/Include/Base.h-  @retval FALSE         The high bit of StatusCode is clear.
MdePkg/Include/Base.h-
MdePkg/Include/Base.h-**/
MdePkg/Include/Base.h-#define RETURN_ERROR(StatusCode)     (((INTN)(RETURN_STATUS)(StatusCode)) < 0)
...
Uefi/UefiBaseType.h:typedef RETURN_STATUS             EFI_STATUS;

This patch makes grub's implementation match the Edk2 declaration with regards
to the signedness of the type.

Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:42:31 +01:00
Peter Jones
3e8c338bfa efi/gop: Add debug output on GOP probing 
Add debug information to EFI GOP video driver probing function.

Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:42:13 +01:00
Peter Jones
c73cda3495 efi/uga: Use video instead of fb as debug condition 
All other video drivers use "video" as the debug condition instead of "fb"
so change this in the efi/uga driver to make it consistent with the others.

Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:41:38 +01:00
Peter Jones
df84d6e94c efi: Print error messages to grub_efi_allocate_pages_real() 
No messages were printed in this function, add some to ease debugging.

Also, the function returns a void * pointer so return NULL instead of
0 to make the code more readable.

Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:41:16 +01:00
Andrei Borzenkov
df5d96de42 efi/uga: Use 64 bit for fb_base 
We get 64 bit from PCI BAR but then truncate by assigning to 32 bit.
Make sure to check that pointer does not overflow on 32 bit platform.

Closes: 50931

Signed-off-by: Andrei Borzenkov <arvidjaar@gmail.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:40:40 +01:00
Alexander Graf
e642c95ab6 efi/gop: Add support for BLT_ONLY adapters 
EFI GOP has support for multiple different bitness types of frame buffers
and for a special "BLT only" type which is always defined to be RGBx.

Because grub2 doesn't ever directly access the frame buffer but instead
only renders graphics via the BLT interface anyway, we can easily support
these adapters.

The reason this has come up now is the emerging support for virtio-gpu
in OVMF. That adapter does not have the notion of a memory mapped frame
buffer and thus is BLT only.

Signed-off-by: Alexander Graf <agraf@suse.de>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:40:31 +01:00
Peter Jones
f0f97576e0 normal/completion: Fix possible NULL pointer dereference 
Coverity Scan reports that the grub_strrchr() function can return NULL if
the character is not found. Check if that's the case for dirfile pointer.

Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:40:23 +01:00
Peter Jones
8d88ae92b5 kern: Add grub_debug_enabled() 
Add a grub_debug_enabled() helper function instead of open coding it.

Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:40:06 +01:00
Peter Jones
42f4054faf Makefile: Make libgrub.pp depend on config-util.h 
If you build with "make -j48" a lot, sometimes you see:

gcc -E -DHAVE_CONFIG_H -I. -I..  -Wall -W -DGRUB_UTIL=1 -D_FILE_OFFSET_BITS=64 -I./include -DGRUB_FILE=\"grub_script.tab.h\" -I. -I.. -I. -I.. -I../include -I./include -I../grub-core/lib/libgcrypt-grub/src/  -I../grub-core/lib/minilzo -I../grub-core/lib/xzembed -DMINILZO_HAVE_CONFIG_H -Wall -W -DGRUB_UTIL=1 -D_FILE_OFFSET_BITS=64 -I./include -DGRUB_FILE=\"grub_script.tab.h\" -I. -I.. -I. -I.. -I../include -I./include -I../grub-core/lib/libgcrypt-grub/src/  -I./grub-core/gnulib -I../grub-core/gnulib -I/builddir/build/BUILD/grub-2.02/grub-aarch64-efi-2.02 -D_FILE_OFFSET_BITS=64 \
  -D'GRUB_MOD_INIT(x)=@MARKER@x@' grub_script.tab.h grub_script.yy.h ../grub-core/commands/blocklist.c ../grub-core/commands/macbless.c ../grub-core/commands/xnu_uuid.c ../grub-core/commands/testload.c ../grub-core/commands/ls.c ../grub-core/disk/dmraid_nvidia.c ../grub-core/disk/loopback.c ../grub-core/disk/lvm.c ../grub-core/disk/mdraid_linux.c ../grub-core/disk/mdraid_linux_be.c ../grub-core/disk/mdraid1x_linux.c ../grub-core/disk/raid5_recover.c ../grub-core/disk/raid6_recover.c ../grub-core/font/font.c ../grub-core/gfxmenu/font.c ../grub-core/normal/charset.c ../grub-core/video/fb/fbblit.c ../grub-core/video/fb/fbutil.c ../grub-core/video/fb/fbfill.c ../grub-core/video/fb/video_fb.c ../grub-core/video/video.c ../grub-core/video/capture.c ../grub-core/video/colors.c ../grub-core/unidata.c ../grub-core/io/bufio.c ../grub-core/fs/affs.c ../grub-core/fs/afs.c ../grub-core/fs/bfs.c ../grub-core/fs/btrfs.c ../grub-core/fs/cbfs.c ../grub-core/fs/cpio.c ../grub-core/fs/cpio_be.c ../grub-core/fs/odc.c ../grub-core/fs/newc.c ../grub-core/fs/ext2.c ../grub-core/fs/fat.c ../grub-core/fs/exfat.c ../grub-core/fs/fshelp.c ../grub-core/fs/hfs.c ../grub-core/fs/hfsplus.c ../grub-core/fs/hfspluscomp.c ../grub-core/fs/iso9660.c ../grub-core/fs/jfs.c ../grub-core/fs/minix.c ../grub-core/fs/minix2.c ../grub-core/fs/minix3.c ../grub-core/fs/minix_be.c ../grub-core/fs/minix2_be.c ../grub-core/fs/minix3_be.c ../grub-core/fs/nilfs2.c ../grub-core/fs/ntfs.c ../grub-core/fs/ntfscomp.c ../grub-core/fs/reiserfs.c ../grub-core/fs/romfs.c ../grub-core/fs/sfs.c ../grub-core/fs/squash4.c ../grub-core/fs/tar.c ../grub-core/fs/udf.c ../grub-core/fs/ufs2.c ../grub-core/fs/ufs.c ../grub-core/fs/ufs_be.c ../grub-core/fs/xfs.c ../grub-core/fs/zfs/zfscrypt.c ../grub-core/fs/zfs/zfs.c ../grub-core/fs/zfs/zfsinfo.c ../grub-core/fs/zfs/zfs_lzjb.c ../grub-core/fs/zfs/zfs_lz4.c ../grub-core/fs/zfs/zfs_sha256.c ../grub-core/fs/zfs/zfs_fletcher.c ../grub-core/lib/envblk.c ../grub-core/lib/hexdump.c ../grub-core/lib/LzFind.c ../grub-core/lib/LzmaEnc.c ../grub-core/lib/crc.c ../grub-core/lib/adler32.c ../grub-core/lib/crc64.c ../grub-core/normal/datetime.c ../grub-core/normal/misc.c ../grub-core/partmap/acorn.c ../grub-core/partmap/amiga.c ../grub-core/partmap/apple.c ../grub-core/partmap/sun.c ../grub-core/partmap/plan.c ../grub-core/partmap/dvh.c ../grub-core/partmap/sunpc.c ../grub-core/partmap/bsdlabel.c ../grub-core/partmap/dfly.c ../grub-core/script/function.c ../grub-core/script/lexer.c ../grub-core/script/main.c ../grub-core/script/script.c ../grub-core/script/argv.c ../grub-core/io/gzio.c ../grub-core/io/xzio.c ../grub-core/io/lzopio.c ../grub-core/kern/ia64/dl_helper.c ../grub-core/kern/arm/dl_helper.c ../grub-core/kern/arm64/dl_helper.c ../grub-core/lib/minilzo/minilzo.c ../grub-core/lib/xzembed/xz_dec_bcj.c ../grub-core/lib/xzembed/xz_dec_lzma2.c ../grub-core/lib/xzembed/xz_dec_stream.c ../util/misc.c ../grub-core/kern/command.c ../grub-core/kern/device.c ../grub-core/kern/disk.c ../grub-core/lib/disk.c ../util/getroot.c ../grub-core/osdep/unix/getroot.c ../grub-core/osdep/getroot.c ../grub-core/osdep/devmapper/getroot.c ../grub-core/osdep/relpath.c ../grub-core/kern/emu/hostdisk.c ../grub-core/osdep/devmapper/hostdisk.c ../grub-core/osdep/hostdisk.c ../grub-core/osdep/unix/hostdisk.c ../grub-core/osdep/exec.c ../grub-core/osdep/sleep.c ../grub-core/osdep/password.c ../grub-core/kern/emu/misc.c ../grub-core/kern/emu/mm.c ../grub-core/kern/env.c ../grub-core/kern/err.c ../grub-core/kern/file.c ../grub-core/kern/fs.c ../grub-core/kern/list.c ../grub-core/kern/misc.c ../grub-core/kern/partition.c ../grub-core/lib/crypto.c ../grub-core/disk/luks.c ../grub-core/disk/geli.c ../grub-core/disk/cryptodisk.c ../grub-core/disk/AFSplitter.c ../grub-core/lib/pbkdf2.c ../grub-core/commands/extcmd.c ../grub-core/lib/arg.c ../grub-core/disk/ldm.c ../grub-core/disk/diskfilter.c ../grub-core/partmap/gpt.c ../grub-core/partmap/msdos.c ../grub-core/fs/proc.c ../grub-core/fs/archelp.c > libgrub.pp || (rm -f libgrub.pp; exit 1)
rm -f stamp-h1
touch ../config-util.h.in
cd . && /bin/sh ./config.status config-util.h
config.status: creating config-util.h
In file included from ../include/grub/mm.h:25:0,
                 from ../include/grub/disk.h:29,
                 from ../include/grub/file.h:26,
                 from ../grub-core/fs/btrfs.c:21:
./config.h:38:10: fatal error: ./config-util.h: No such file or directory
 #include <config-util.h>
          ^~~~~~~~~~~~~~~
compilation terminated.
make: *** [Makefile:13098: libgrub.pp] Error 1

This is because libgrub.pp is built with -DGRUB_UTIL=1, which means
it'll try to include config-util.h, but a parallel make is actually
building that file.  I think.

Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:39:53 +01:00
Peter Jones
cc93c5a849 efi: Print more debug info in our module loader 
The function that searches the mods section base address does not have
any debug information. Add some debugging outputs that could be useful.

Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:39:44 +01:00
Peter Jones
ea04f131a4 linux/getroot: Handle rssd storage device names 
The Micron PCIe SSDs Linux driver (mtip32xx) exposes block devices
as /dev/rssd[a-z]+[0-9]*. Add support for these rssd device names.

Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:39:34 +01:00
Julian Andres Klode
87049f9716 smbios: Add a --linux argument to apply linux modalias-like filtering 
Linux creates modalias strings by filtering out non-ASCII, space,
and colon characters. Provide an option that does the same filtering
so people can create a modalias string in GRUB, and then match their
modalias patterns against it.

Signed-off-by: Julian Andres Klode <julian.klode@canonical.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:35:02 +01:00
Mike Gilbert
2e246b6fec po: Fix replacement of %m in sed programs 
When running make dist, I hit this error:

  rm -f en@arabic.gmo && /usr/bin/gmsgfmt -c --statistics --verbose -o en@arabic.gmo en@arabic.po
  en@arabic.po:5312: 'msgstr' is not a valid C format string, unlike 'msgid'.
  Reason: The character that terminates the directive number 3 is not a valid conversion specifier.
  /usr/bin/gmsgfmt: found 1 fatal error

This was caused by "%m" being replaced with foreign Unicode characters.
For example:

  msgid "cannot rename the file %s to %s: %m"
  msgstr "ﺹﺎﻨﻧﻮﺗ ﺮﻌﻧﺎﻤﻋ ﺖﻬﻋ ﻒִﻴﻠﻋ %s ﺕﻭ %s: %ﻡ"

Mimic the workaround used for "%s" by reversing the replacement of "%m" at
the end of the sed programs.

Signed-off-by: Mike Gilbert <floppym@gentoo.org>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:32:09 +01:00
Colin Watson
ac116bd659 gettext: Restore patches to po/Makefile.in.in 
These were inadvertently lost during the conversion to Gnulib (gnulib:
Upgrade Gnulib and switch to bootstrap tool; commit 35b909062). The
files in po/gettext-patches/ can be imported using "git am" on top of
the gettext tag corresponding to AM_GNU_GETTEXT_VERSION in configure.ac
(currently 0.18.3). They handle translation of messages in shell files,
make msgfmt output in little-endian format, and arrange to use @SHELL@
rather than /bin/sh.

There were some changes solely for the purpose of distributing extra
files; for ease of maintenance, I've added these to
conf/Makefile.extra-dist instead.

Fixes: https://savannah.gnu.org/bugs/?57298

Signed-off-by: Colin Watson <cjwatson@ubuntu.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-03-10 21:17:54 +01:00
Peter Jones
d5a32255de misc: Make grub_strtol() "end" pointers have safer const qualifiers 
Currently the string functions grub_strtol(), grub_strtoul(), and
grub_strtoull() don't declare the "end" pointer in such a way as to
require the pointer itself or the character array to be immutable to the
implementation, nor does the C standard do so in its similar functions,
though it does require us not to change any of it.

The typical declarations of these functions follow this pattern:

long
strtol(const char * restrict nptr, char ** restrict endptr, int base);

Much of the reason for this is historic, and a discussion of that
follows below, after the explanation of this change.  (GRUB currently
does not include the "restrict" qualifiers, and we name the arguments a
bit differently.)

The implementation is semantically required to treat the character array
as immutable, but such accidental modifications aren't stopped by the
compiler, and the semantics for both the callers and the implementation
of these functions are sometimes also helped by adding that requirement.

This patch changes these declarations to follow this pattern instead:

long
strtol(const char * restrict nptr,
       const char ** const restrict endptr,
       int base);

This means that if any modification to these functions accidentally
introduces either an errant modification to the underlying character
array, or an accidental assignment to endptr rather than *endptr, the
compiler should generate an error.  (The two uses of "restrict" in this
case basically mean strtol() isn't allowed to modify the character array
by going through *endptr, and endptr isn't allowed to point inside the
array.)

It also means the typical use case changes to:

  char *s = ...;
  const char *end;
  long l;

  l = strtol(s, &end, 10);

Or even:

  const char *p = str;
  while (p && *p) {
	  long l = strtol(p, &p, 10);
	  ...
  }

This fixes 26 places where we discard our attempts at treating the data
safely by doing:

  const char *p = str;
  long l;

  l = strtol(p, (char **)&ptr, 10);

It also adds 5 places where we do:

  char *p = str;
  while (p && *p) {
	  long l = strtol(p, (const char ** const)&p, 10);
	  ...
	  /* more calls that need p not to be pointer-to-const */
  }

While moderately distasteful, this is a better problem to have.

With one minor exception, I have tested that all of this compiles
without relevant warnings or errors, and that /much/ of it behaves
correctly, with gcc 9 using 'gcc -W -Wall -Wextra'.  The one exception
is the changes in grub-core/osdep/aros/hostdisk.c , which I have no idea
how to build.

Because the C standard defined type-qualifiers in a way that can be
confusing, in the past there's been a slow but fairly regular stream of
churn within our patches, which add and remove the const qualifier in many
of the users of these functions.  This change should help avoid that in
the future, and in order to help ensure this, I've added an explanation
in misc.h so that when someone does get a compiler warning about a type
error, they have the fix at hand.

The reason we don't have "const" in these calls in the standard is
purely anachronistic: C78 (de facto) did not have type qualifiers in the
syntax, and the "const" type qualifier was added for C89 (I think; it
may have been later).  strtol() appears to date from 4.3BSD in 1986,
which means it could not be added to those functions in the standard
without breaking compatibility, which is usually avoided.

The syntax chosen for type qualifiers is what has led to the churn
regarding usage of const, and is especially confusing on string
functions due to the lack of a string type.  Quoting from C99, the
syntax is:

 declarator:
  pointer[opt] direct-declarator
 direct-declarator:
  identifier
  ( declarator )
  direct-declarator [ type-qualifier-list[opt] assignment-expression[opt] ]
  ...
  direct-declarator [ type-qualifier-list[opt] * ]
  ...
 pointer:
  * type-qualifier-list[opt]
  * type-qualifier-list[opt] pointer
 type-qualifier-list:
  type-qualifier
  type-qualifier-list type-qualifier
 ...
 type-qualifier:
  const
  restrict
  volatile

So the examples go like:

const char foo;			// immutable object
const char *foo;		// mutable pointer to object
char * const foo;		// immutable pointer to mutable object
const char * const foo;		// immutable pointer to immutable object
const char const * const foo; 	// XXX extra const keyword in the middle
const char * const * const foo; // immutable pointer to immutable
				//   pointer to immutable object
const char ** const foo;	// immutable pointer to mutable pointer
				//   to immutable object

Making const left-associative for * and right-associative for everything
else may not have been the best choice ever, but here we are, and the
inevitable result is people using trying to use const (as they should!),
putting it at the wrong place, fighting with the compiler for a bit, and
then either removing it or typecasting something in a bad way.  I won't
go into describing restrict, but its syntax has exactly the same issue
as with const.

Anyway, the last example above actually represents the *behavior* that's
required of strtol()-like functions, so that's our choice for the "end"
pointer.

Signed-off-by: Peter Jones <pjones@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-02-28 12:41:29 +01:00
Mike Gilbert
c71be831f1 build: Disable PIE in TARGET_CCASFLAGS if needed 
PIE should be disabled in assembly sources as well, or else GRUB will
fail to boot.

Bug: https://bugs.gentoo.org/667852

Signed-off-by: Mike Gilbert <floppym@gentoo.org>
Signed-off-by: Matt Turner <mattst88@gmail.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
Tested-by: John Paul Adrian Glaubitz <glaubitz@physik.fu-berlin.de>
 2020-02-28 12:35:30 +01:00
Mike Gilbert
3137ecd97c build: Move TARGET_* assignments earlier 
On a 32-bit SPARC userland, configure fails to compile assembly and the
build fails:

    checking for options to compile assembly... configure: error: could not compile assembly

config.log shows:

    asm-tests/sparc64.S: Assembler messages:
    asm-tests/sparc64.S:5: Error: Architecture mismatch on "lduw [%o4+4],%o4".
    asm-tests/sparc64.S:5: (Requires v9|v9a|v9b|v9c|v9d|v9e|v9v|v9m|m8; requested architecture is sparclite.)
    asm-tests/sparc64.S:7: Error: Architecture mismatch on "stw %o5,[%o3]".
    asm-tests/sparc64.S:7: (Requires v9|v9a|v9b|v9c|v9d|v9e|v9v|v9m|m8; requested architecture is sparclite.)
    asm-tests/sparc64.S:8: Error: Architecture mismatch on "bne,pt %icc,1b ,pt %icc,1b".
    asm-tests/sparc64.S:8: (Requires v9|v9a|v9b|v9c|v9d|v9e|v9v|v9m|m8; requested architecture is sparclite.)

Simply moving these blocks earlier in configure.ac is sufficient to
ensure that the tests are executed with the appropriate flags
(specifically -m64 in this case).

Bug: https://bugs.gentoo.org/667850

Signed-off-by: Mike Gilbert <floppym@gentoo.org>
Signed-off-by: Matt Turner <mattst88@gmail.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
Tested-by: John Paul Adrian Glaubitz <glaubitz@physik.fu-berlin.de>
 2020-02-28 12:29:39 +01:00
Patrick Steinhardt
9404c41953 luks2: Add missing newline to debug message 
The debug message printed when decryption with a keyslot fails is
missing its trailing newline. Add it to avoid mangling it with
subsequent output.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-02-28 12:27:55 +01:00
Michael Chang
d0de8b37f6 verifiers: Fix calling uninitialized function pointer 
The necessary check for NULL before use of function ver->close is not
taking place in the failure path. This patch simply adds the missing
check and fixes the problem that GRUB hangs indefinitely after booting
rogue image without valid signature if secure boot is turned on.

Now it displays like this for booting rogue UEFI image:

  error: bad shim signature
  error: you need to load the kernel first

  Press any key to continue...

and then you can go back to boot menu by pressing any key or after a few
seconds expired.

Signed-off-by: Michael Chang <mchang@suse.com>
Reviewed-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-02-18 15:17:40 +01:00
Peter Jones
0ad07e928a grub-editenv: Make grub-editenv chase symlinks including those across devices 
The grub-editenv create command will wrongly overwrite /boot/grub2/grubenv
with a regular file if grubenv is a symbolic link. But instead, it should
create a new file in the path the symlink points to.

This lets /boot/grub2/grubenv be a symlink to /boot/efi/EFI/fedora/grubenv
even when they're different mount points, which allows grub2-editenv to be
the same across platforms (i.e. UEFI vs BIOS).

For example, in Fedora the GRUB EFI builds have prefix set to /EFI/fedora
(on the EFI System Partition), but for BIOS machine it'll be /boot/grub2
(which may or may not be its own mountpoint).

With this patch, on EFI machines we can make /boot/grub2/grubenv a symlink
to /boot/efi/EFI/fedora/grubenv, and the same copy of grub-set-default will
work on both kinds of systems.

Windows doesn't implement a readlink primitive, so the current behaviour is
maintained for this operating system.

Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Jonathan Lebon <jlebon@redhat.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-02-18 15:16:02 +01:00
Peter Jones
03e72830ab grub-editenv: Add grub_util_readlink() 
Currently grub-editenv and related tools are not able to follow symbolic
links when finding their config file. For example the grub-editenv create
command will wrongly overwrite a symlink in /boot/grub2/grubenv with a new
regular file, instead of creating a file in the path the symlink points to.

A following patch will change that and add support in grub-editenv to
follow symbolic links when finding the grub environment variables file.

Add a grub_util_readlink() helper function that is just a wrapper around
the platform specific function to read the value of a symbolic link. This
helper function will be used by the following patch for grub-editenv.

The helper function is not added for Windows, since this operating system
doesn't have a primitive to read the contents of a symbolic link.

Signed-off-by: Peter Jones <pjones@redhat.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-02-18 15:14:13 +01:00
Robert Marshall
9f03dc5d7b docs: Update info with grub.cfg netboot selection order 
Add documentation to the GRUB manual that specifies the order netboot
clients use to select a GRUB configuration file.

Also explain that the feature is enabled by default but can be disabled
by setting the "feature_net_search_cfg" environment variable to "n" in
an embedded configuration file.

Signed-off-by: Robert Marshall <rmarshall@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-02-18 15:12:07 +01:00
Paulo Flabiano Smorigo
cb2f15c544 normal/main: Search for specific config files for netboot 
This patch implements a search for a specific configuration when the config
file is on a remoteserver. It uses the following order:
   1) DHCP client UUID option.
   2) MAC address (in lower case hexadecimal with dash separators);
   3) IP (in upper case hexadecimal) or IPv6;
   4) The original grub.cfg file.

This procedure is similar to what is used by pxelinux and yaboot:
http://www.syslinux.org/wiki/index.php/PXELINUX#config

It is enabled by default but can be disabled by setting the environment
variable "feature_net_search_cfg" to "n" in an embedded configuration.

Fixes: https://bugzilla.redhat.com/show_bug.cgi?id=873406

Signed-off-by: Paulo Flabiano Smorigo <pfsmorigo@br.ibm.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-02-18 15:12:06 +01:00
Paulo Flabiano Smorigo
febc761e67 net/dhcp: Set net_<interface>_client{id, uuid} variables from DHCP options 
This patch sets a net_<interface>_clientid and net_<interface>_clientuuid
GRUB environment variables, using the DHCP client ID and UUID options if
these are found.

In the same way than net_<interface>_<option> variables are set for other
options such domain name, boot file, next server, etc.

Signed-off-by: Paulo Flabiano Smorigo <pfsmorigo@br.ibm.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-02-18 15:12:06 +01:00
Javier Martinez Canillas
e921119857 net/dhcp: Consistently use decimal numbers for DHCP/BOOTP options enum 
The DHCP Options and BOOTP Vendor Extensions enum values are a mixture of
decimal and hexadecimal numbers. Change this to consistently use decimal
numbers for all since that is how these values are defined by RFC 2132.

Suggested-by: Daniel Kiper <daniel.kiper@oracle.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-02-18 15:12:06 +01:00
Paulo Flabiano Smorigo
8c2c35dcc0 kern: Add %X option to printf functions 
The printf(3) function has support for the %X format specifier, to output
an unsigned hexadecimal integer in uppercase.

This can be achived in GRUB using the %x format specifier in grub_printf()
and calling grub_toupper(), but it is more convenient if there is support
for %X in grub_printf().

Signed-off-by: Paulo Flabiano Smorigo <pfsmorigo@br.ibm.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-02-18 15:12:06 +01:00
Javier Martinez Canillas
aa096037ae normal: Move common datetime functions out of the normal module 
The common datetime helper functions are currently included in the normal
module, but this makes any other module that calls these functions to have
a dependency with the normal module only for this reason.

Since the normal module does a lot of stuff, it calls functions from other
modules. But since other modules may depend on it for calling the datetime
helpers, this could lead to circular dependencies between modules.

As an example, when platform == xen the grub_get_datetime() function from
the datetime module calls to the grub_unixtime2datetime() helper function
from the normal module. Which leads to the following module dependency:

    datetime -> normal

and send_dhcp_packet() from the net module calls the grub_get_datetime()
function, which leads to the following module dependency:

    net -> datetime -> normal

but that means that the normal module is not allowed to depend on net or
any other module that depends on it due the transitive dependency caused
by datetime. A recent patch attempted to add support to fetch the config
file over the network, which leads to the following circular dependency:

    normal -> net -> datetime -> normal

So having the datetime helpers in the normal module makes it quite fragile
and easy to add circular dependencies like these, that break the build due
the genmoddep.awk script catching the issues.

Fix this by taking the datetime helper functions out of the normal module
and instead add them to the datetime module itself. Besides fixing these
issues, it makes more sense to have these helper functions there anyways.

Reported-by: Daniel Kiper <daniel.kiper@oracle.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-02-18 15:12:06 +01:00
Peter Jones
3165efcfc2 minilzo: Update to minilzo-2.08 
This patch updates the miniLZO library to a newer version, which among other
things fixes "CVE-2014-4607 - lzo: lzo1x_decompress_safe() integer overflow"
that is present in the current used in GRUB.

It also updates the "GRUB Developers Manual", to mention that the library is
used and describes the process to update it to a newer release when needed.

Resolves: http://savannah.gnu.org/bugs/?42635

Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-02-11 21:30:30 +01:00
Peter Jones
598de14d93 squash4: Fix an uninitialized variable 
gcc says:

grub-core/fs/squash4.c: In function ‘direct_read’:
grub-core/fs/squash4.c:868:10: error: ‘err’ may be used uninitialized in
this function [-Werror=maybe-uninitialized]
  868 |       if (err)
      |          ^
cc1: all warnings being treated as errors

This patch initializes it to GRUB_ERR_NONE.

Signed-off-by: Peter Jones <pjones@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-01-28 21:22:01 +01:00
C. Masloch
e96e785580 freedos: Fix FreeDOS command booting large files (near or above 64 KiB) 
While testing the 86-DOS lDebug [1] booting from GRUB2, newer versions of the
debugger would fail to load when booted using GRUB's freedos command. The
behaviour observed in a qemu i386 machine was that the ROM-BIOS's boot load
would start anew, instead of loading the selected debugger as kernel.

It came to light that there was a size limit: Kernel files that were 58880
bytes (E600h) long or shorter succeeded to boot, while files that were 64000
bytes or longer failed in the manner described.

Eventually it turned out that the relocator16 stub succeeded whenever it was
placed completely within the first 64 KiB of the Low Memory Area. The chunk
for the relocator is allocated with a minimum address of 0x8010 and a maximum
address just below 0xA0000 [2]. That means if the kernel is, for instance,
E600h bytes long, then the kernel will be allocated memory starting at 00600h
(the fixed FreeDOS kernel load address) up to E600h + 00600h = 0EC00h, which
leaves 1400h (5120) bytes for the relocator to stay in the first 64 KiB.
If the kernel is 64000 bytes (FA00h) long, then the relocator must go to
FA00h + 00600h = 10000h at least which is outside the first 64 KiB.

The problem is that the relocator16 initialises the DS register with a
"pseudo real mode" descriptor, which is defined with a segment limit of
64 KiB and a segment base of zero. After that, the relocator addressed
parts of itself (implicitly) using the DS register, with an offset from
ESI, which holds the linear address of the relocator's base [3]. With the
larger kernel files this would lead to accessing data beyond the 64 KiB
segment limit, presumably leading to a fault and perhaps a subsequent
triple-fault or such.

This patch fixes the relocator to set the segment base of the descriptors
to the base address of the relocator; then, the subsequent accesses to
the relocator's variables are done without the ESI register as an index.
This does not interfere with the relocator's or its target's normal
operation; the segment limits are still loaded with 64 KiB and all the
segment bases are subsequently reset by the relocator anyway.

Current versions of the debugger to test are uploaded to [4]. The file
ldebugnh.com (LZ4-compressed and built with -D_EXTHELP=0) at 58368 bytes
loads successfully, whereas ldebug.com at 64000 bytes fails. Loading one
of these files requires setting root to a FAT FS partition and using the
freedos command to specify the file as kernel:

set root='(hd0,msdos1)'
freedos /ldebug.com
boot

Booting the file using the multiboot command (which uses a WIP entrypoint
of the debugger) works, as it does not use GRUB's relocator16 but instead
includes a loader in the kernel itself, which drops it back to 86 Mode.

[1]: https://hg.ulukai.org/ecm/ldebug
[2]: http://git.savannah.gnu.org/cgit/grub.git/tree/grub-core/lib/i386/relocator.c?id=495781f5ed1b48bf27f16c53940d6700c181c74c#n127
[3]: http://git.savannah.gnu.org/cgit/grub.git/tree/grub-core/lib/i386/relocator16.S?id=495781f5ed1b48bf27f16c53940d6700c181c74c#n97
[4]: https://ulukai.org/ecm/lDebug-5479a7988d21-nohelp.zip

Signed-off-by: C. Masloch <pushbx@ulukai.org>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-01-28 21:16:48 +01:00
Patrick Steinhardt
365e0cc3e7 disk: Implement support for LUKS2 
With cryptsetup 2.0, a new version of LUKS was introduced that breaks
compatibility with the previous version due to various reasons. GRUB
currently lacks any support for LUKS2, making it impossible to decrypt
disks encrypted with that version. This commit implements support for
this new format.

Note that LUKS1 and LUKS2 are quite different data formats. While they
do share the same disk signature in the first few bytes, representation
of encryption parameters is completely different between both versions.
While the former version one relied on a single binary header, only,
LUKS2 uses the binary header only in order to locate the actual metadata
which is encoded in JSON. Furthermore, the new data format is a lot more
complex to allow for more flexible setups, like e.g. having multiple
encrypted segments and other features that weren't previously possible.
Because of this, it was decided that it doesn't make sense to keep both
LUKS1 and LUKS2 support in the same module and instead to implement it
in two different modules luks and luks2.

The proposed support for LUKS2 is able to make use of the metadata to
decrypt such disks. Note though that in the current version, only the
PBKDF2 key derival function is supported. This can mostly attributed to
the fact that the libgcrypt library currently has no support for either
Argon2i or Argon2id, which are the remaining KDFs supported by LUKS2. It
wouldn't have been much of a problem to bundle those algorithms with
GRUB itself, but it was decided against that in order to keep down the
number of patches required for initial LUKS2 support. Adding it in the
future would be trivial, given that the code structure is already in
place.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-01-10 14:30:24 +01:00
Patrick Steinhardt
dd3f49b106 luks: Move configuration of ciphers into cryptodisk 
The luks module contains quite a lot of logic to parse cipher and
cipher-mode strings like aes-xts-plain64 into constants to apply them
to the grub_cryptodisk_t structure. This code will be required by the
upcoming luks2 module, as well, which is why this commit moves it into
its own function grub_cryptodisk_setcipher in the cryptodisk module.
While the strings are probably rather specific to the LUKS modules, it
certainly does make sense that the cryptodisk module houses code to set
up its own internal ciphers instead of hosting that code in the luks
module.

Except for necessary adjustments around error handling, this commit does
an exact move of the cipher configuration logic from luks.c to
cryptodisk.c. Any behavior changes are unintentional.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-01-10 14:29:37 +01:00
Patrick Steinhardt
5324c335b1 afsplitter: Move into its own module 
While the AFSplitter code is currently used only by the luks module,
upcoming support for luks2 will add a second module that depends on it.
To avoid any linker errors when adding the code to both modules because
of duplicated symbols, this commit moves it into its own standalone
module afsplitter as a preparatory step.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-01-10 14:27:49 +01:00
Patrick Steinhardt
9fbdec2f6b bootstrap: Add gnulib's base64 module 
The upcoming support for LUKS2 disc encryption requires us to include a
parser for base64-encoded data, as it is used to represent salts and
digests. As gnulib already has code to decode such data, we can just
add it to the boostrapping configuration in order to make it available
in GRUB.

The gnulib module makes use of booleans via the <stdbool.h> header. As
GRUB does not provide any POSIX wrapper header for this, but instead
implements support for bool in <sys/types.h>, we need to patch
base64.h to not use <stdbool.h> anymore. We unfortunately cannot include
<sys/types.h> instead, as it would then use gnulib's internal header
while compiling the gnulib object but our own <sys/types.h> when
including it in a GRUB module. Because of this, the patch replaces the
include with a direct typedef.

A second fix is required to make available _GL_ATTRIBUTE_CONST, which
is provided by the configure script. As base64.h does not include
<config.h>, it is thus not available and results in a compile error.
This is fixed by adding an include of <config-util.h>.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-01-10 14:26:40 +01:00
Patrick Steinhardt
c6a84545a3 json: Implement wrapping interface 
While the newly added jsmn library provides the parsing interface, it
does not provide any kind of interface to act on parsed tokens. Instead,
the caller is expected to handle pointer arithmetics inside of the token
array in order to extract required information. While simple, this
requires users to know some of the inner workings of the library and is
thus quite an unintuitive interface.

This commit adds a new interface on top of the jsmn parser that provides
convenience functions to retrieve values from the parsed json type, grub_json_t.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-01-10 14:13:22 +01:00
Patrick Steinhardt
528938d503 json: Import upstream jsmn-1.1.0 
The upcoming support for LUKS2 encryption will require a JSON parser to
decode all parameters required for decryption of a drive. As there is
currently no other tool that requires JSON, and as gnulib does not
provide a parser, we need to introduce a new one into the code base. The
backend for the JSON implementation is going to be the jsmn library [1].
It has several benefits that make it a very good fit for inclusion in
GRUB:

    - It is licensed under MIT.
    - It is written in C89.
    - It has no dependencies, not even libc.
    - It is small with only about 500 lines of code.
    - It doesn't do any dynamic memory allocation.
    - It is testen on x86, amd64, ARM and AVR.

The library itself comes as a single header, only, that contains both
declarations and definitions. The exposed interface is kind of
simplistic, though, and does not provide any convenience features
whatsoever. Thus there will be a separate interface provided by GRUB
around this parser that is going to be implemented in the following
commit. This change only imports jsmn.h from tag v1.1.0 and adds it
unmodified to a new json module with the following command:

curl -L https://raw.githubusercontent.com/zserge/jsmn/v1.1.0/jsmn.h \
    -o grub-core/lib/json/jsmn.h

Upstream jsmn commit hash: fdcef3ebf886fa210d14956d3c068a653e76a24e
Upstream jsmn commit name: Modernize (#149), 2019-04-20

[1]: https://github.com/zserge/jsmn

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2020-01-10 14:12:12 +01:00
Lukasz Hawrylko
0f3f5b7c13 multiboot2: Set min address for mbi allocation to 0x1000 
In some cases GRUB2 allocates multiboot2 structure at 0 address, that is
a confusing behavior. Consumers of that structure can have internal NULL-checks
that will throw an error when get a pointer to data allocated at address 0.
To prevent that, define min address for mbi allocation on x86 and x86_64
platforms.

Signed-off-by: Lukasz Hawrylko <lukasz.hawrylko@linux.intel.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-12-20 20:35:21 +01:00
Paul Menzel
7e28ca82bb docs: Export "superusers" variable to apply to submenus 
Signed-off-by: Paul Menzel <pmenzel@molgen.mpg.de>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-12-20 20:35:21 +01:00
Daniel Kiper
b53a2f2c66 loader/i386/linux: Fix an underflow in the setup_header length calculation 
Recent work around x86 Linux kernel loader revealed an underflow in the
setup_header length calculation and another related issue. Both lead to
the memory overwrite and later machine crash.

Currently when the GRUB copies the setup_header into the linux_params
(struct boot_params, traditionally known as "zero page") it assumes the
setup_header size as sizeof(linux_i386_kernel_header/lh). This is
incorrect. It should use the value calculated accordingly to the Linux
kernel boot protocol. Otherwise in case of pretty old kernel, to be
exact Linux kernel boot protocol, the GRUB may write more into
linux_params than it was expected to. Fortunately this is not very big
issue. Though it has to be fixed. However, there is also an underflow
which is grave. It happens when

  sizeof(linux_i386_kernel_header/lh) > "real size of the setup_header".

Then len value wraps around and grub_file_read() reads whole kernel into
the linux_params overwriting memory past it. This leads to the GRUB
memory allocator breakage and finally to its crash during boot.

The patch fixes both issues. Additionally, it moves the code not related to
grub_memset(linux_params)/grub_memcpy(linux_params)/grub_file_read(linux_params)
section outside of it to not confuse the reader.

Fixes: e683cfb0cf (loader/i386/linux: Calculate the setup_header length)

Signed-off-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Ross Philipson <ross.philipson@oracle.com>
Reviewed-by: Krystian Hebel <krystian.hebel@3mdeb.com>
 2019-12-20 20:35:21 +01:00
David Sterba
495781f5ed btrfs: Add support for new RAID1C34 profiles 
New 3- and 4-copy variants of RAID1 were merged into Linux kernel 5.5.
Add the two new profiles to the list of recognized ones. As this builds
on the same code as RAID1, only the redundancy level needs to be
adjusted, the rest is done by the existing code.

Signed-off-by: David Sterba <dsterba@suse.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-12-06 20:38:01 +01:00
Lenny Szubowicz
e2c09aed97 tftp: Normalize slashes in TFTP paths 
Some TFTP servers do not handle multiple consecutive slashes correctly.
This patch avoids sending TFTP requests with non-normalized paths.

Signed-off-by: Lenny Szubowicz <lszubowi@redhat.com>
Signed-off-by: Mark Salter <msalter@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-12-06 20:26:36 +01:00
Michael Chang
5e5a15872d grub-editenv: Warn a user against editing environment block 
The environment block is a preallocated 1024-byte file which serves as
persistent storage for environment variables. It has its own format
which is sensitive to corruption if an editor does not know how to
process it. Besides that the editor may inadvertently change grubenv
file size and/or make it sparse which can lead to unexpected results.

This patch adds a message to the grubenv file to warn a user against
editing it by tools other than grub-editenv.

Signed-off-by: Michael Chang <mchang@suse.com>
Reviewed-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-11-18 14:19:25 +01:00
Michael Chang
42acdd3b40 hostdisk: Set linux file descriptor to O_CLOEXEC as default 
We are often bothered by this sort of lvm warning while running grub-install
every now and then:

  File descriptor 4 (/dev/vda1) leaked on vgs invocation. Parent PID 1991: /usr/sbin/grub2-install

The requirement related to the warning is dictated in the lvm man page:

  "On invocation, lvm requires that only the standard file descriptors stdin,
  stdout and stderr are available.  If others are found, they get closed and
  messages are issued warning about the leak.  This warning can be suppressed by
  setting the environment variable LVM_SUPPRESS_FD_WARNINGS."

While it could be disabled through settings, most Linux distributions seem to
enable it by default and the justification provided by the developer looks to
be valid to me: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=466138#15

Rather than trying to close and reopen the file descriptor to the same file
multiple times, which is rather cumbersome, for the sake of no vgs invocation
could happen in between. This patch enables the close-on-exec flag (O_CLOEXEC)
for new file descriptor returned by the open() system call, making it closed
thus not inherited by the child process forked and executed by the exec()
family of functions.

Fixes Debian bug #466138.

Signed-off-by: Michael Chang <mchang@suse.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-11-18 13:42:55 +01:00
Eli Schwartz
28a7e597de grub-mkconfig: Use portable "command -v" to detect installed programs 
The "which" utility is not guaranteed to be installed either, and if it
is, its behavior is not portable either.

Conversely, the "command -v" shell builtin is required to exist in all
POSIX 2008 compliant shells, and is thus guaranteed to work everywhere.

Examples of open-source shells likely to be installed as /bin/sh on
Linux, which implement the 11-year-old standard: ash, bash, busybox,
dash, ksh, mksh and zsh.

A side benefit of using the POSIX portable option is that it requires
neither an external disk executable, nor (because unlike "which", the
exit code is reliable) a subshell fork. This therefore represents a mild
speedup.

Signed-off-by: Eli Schwartz <eschwartz@archlinux.org>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-10-28 15:38:48 +01:00
Peter Jones
b78d570a36 templates: Add GRUB_DISABLE_UUID 
The grub-mkconfig and 10_linux scripts by default attempt to use a UUID to
set the root kernel command line parameter and the $root GRUB environment
variable.

The former can be disabled by setting the GRUB_DISABLE_LINUX_UUID variable
to "true", but there is currently no way to disable the latter.

The generated grub config uses the search command with the --fs-uuid option
to find the device that has to be set as $root, i.e:

 search --no-floppy --fs-uuid --set=root ...

This is usually more reliable but in some cases it may not be appropriate,
so this patch introduces a new GRUB_DISABLE_UUID variable that can be used
to disable searching for the $root device by filesystem UUID.

When disabled, the $root device will be set to the value specified in the
device.map as found by the grub-probe --target=compatibility_hint option.

When setting GRUB_DISABLE_UUID=true, the GRUB_DISABLE_LINUX_UUID and
GRUB_DISABLE_LINUX_PARTUUID variables will also be set to "true" unless
these have been explicitly set to "false".

That way, the GRUB_DISABLE_UUID variable can be used to force using the
device names for both GRUB and Linux.

Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Nicholas Vinson <nvinson234@gmail.com>
 2019-10-28 15:35:40 +01:00
Michael Bideau
33203ca348 at_keyboard: Fix unreliable key presses 
This patch fixes an issue that prevented the at_keyboard module to work
(for me). The cause was a bad/wrong return value in the
grub_at_keyboard_getkey() function in grub-core/term/at_keyboard.c file
at line 237. My symptoms were to have an unresponsive keyboard. Keys
needed to be pressed 10x and more to effectively be printed sometimes
generating multiple key presses (after 1 or 2 sec of no printing). It
was very problematic when typing passphrase in early stage (with
GRUB_ENABLE_CRYPTODISK). When switched to "console" terminal input
keyboard worked perfectly. It also worked great with the GRUB 2.02
packaged by Debian (2.02+dfsg1-20). It was not an output issue but an
input one.

I've managed to analyze the issue and found that it came from the commit
216950a4e (at_keyboard: Split protocol from controller code.). Three
lines where moved from the fetch_key() function in
grub-core/term/at_keyboard.c file to the beginning of
grub_at_keyboard_getkey() function (same file). However, returning -1
made sense when it happened in fetch_key() function but not anymore in
grub_at_keyboard_getkey() function which should return GRUB_TERM_NO_KEY.
I think it was just an incomplete cut-paste missing a small manual
correction. Let's fix it.

Note: Commit message updated by Daniel Kiper.

Signed-off-by: Michael Bideau <mica.devel@gmail.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-10-21 14:07:47 +02:00
Prarit Bhargava
ee4bd79ef2 templates: Fix bad test on GRUB_DISABLE_SUBMENU 
The GRUB_DISABLE_SUBMENU option is different than the others in the sense
that it has to be set to "y" instead of "true" to be enabled.

That causes a lot of confusion to users, some may wrongly set it to "true"
expecting that will work the same than with most options, and some may set
it to "yes" since for other options the value to set is a word and not a
single character.

This patch changes all the grub.d scripts using the GRUB_DISABLE_SUBMENU
option, so they check if it was set to "true" instead of "y", making it
consistent with all the other options.

But to keep backward compatibility for users that set the option to "y" in
/etc/default/grub file, keep testing for this value. And also do it for
"yes", since it is a common mistake made by users caused by this option
being inconsistent with the others.

Signed-off-by: Prarit Bhargava <prarit@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-10-21 14:05:02 +02:00
Nicholas Vinson
c7cb11b219 probe: Support probing for msdos PARTUUID 
Extend partition UUID probing support in GRUB core to display pseudo
partition UUIDs for MBR (MSDOS) partitions.

Signed-off-by: Nicholas Vinson <nvinson234@gmail.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-10-21 14:00:54 +02:00
Colin Watson
ff3e91be9c grub-mkconfig: Fix typo in --help output 
The short form of "--version" that grub-mkconfig accepts is "-V", not "-v".

Fixes Debian bug #935504.

Signed-off-by: Colin Watson <cjwatson@ubuntu.com>
Reviewed-by: Vladimir 'phcoder' Serbinenko <phcoder@gmail.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-09-23 13:20:02 +02:00
Andreas Schwab
11268841e2 grub-install: Define default platform for RISC-V 
Signed-off-by: Andreas Schwab <schwab@suse.de>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Alexander Graf <agraf@csgraf.de>
 2019-09-23 13:19:19 +02:00
Andreas Schwab
a57977b5fa RISC-V: Add __clzdi2 symbol 
This is needed for the zstd module build for riscv64-emu.

Signed-off-by: Andreas Schwab <schwab@suse.de>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-09-23 13:17:15 +02:00
Peter Jones
f9e28d250a gitattributes: Mark po/exclude.pot as binary so git won't try to diff nonprintables 
Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-09-23 13:17:15 +02:00
Marcel Kolaja
ab2e53c8a1 grub-mkconfig: Honor a symlink when generating configuration by grub-mkconfig 
Honor a symlink when generating configuration by grub-mkconfig, so that
the -o option follows it rather than overwriting it with a regular file.

Signed-off-by: Marcel Kolaja <mkolaja@redhat.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-09-23 13:17:15 +02:00
Gustavo Luiz Duarte
fc085f7f18 net: Fix crash on http 
Don't free file->data on receiving FIN flag since it is used all over
without checking. http_close() will be called later to free that memory.

Fixes bug: https://bugzilla.redhat.com/show_bug.cgi?id=860834

Signed-off-by: Gustavo Luiz Duarte <gustavold@linux.vnet.ibm.com>
Signed-off-by: Javier Martinez Canillas <javierm@redhat.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-09-23 13:16:48 +02:00
Andre Przywara
3ea9bc3c06 docs: Document newly introduced net_dhcp command 
Commit 5bc41db756 ("net/dhcp: Add explicit net_dhcp command")
introduced the new command "net_dhcp", which (for now) is an alias for
the existing "net_bootp". Unfortunately the TEXI documentation was not
adjusted accordingly.

Rename the existing paragraph about net_bootp to read net_dhcp instead,
and make the net_bootp stanza point to this new command.

On the way add the newly parsed TFTP_SERVER_NAME and BOOTFILE_NAME
packets to the list of supported DHCP options.

Fixes bug: https://savannah.gnu.org/bugs/?56725

Reported-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
Signed-off-by: Andre Przywara <andre.przywara@arm.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-09-23 13:15:25 +02:00
James Clarke
4e75b2ae31 [PATCH] sparc64: Fix BIOS Boot Partition support 
Currently, gpt_offset is uninitialised when using a BIOS Boot Partition
but is used unconditionally inside save_blocklists. Instead, ensure it
is always initialised to 0 (note that there is already separate code to
do the equivalent adjustment after we call save_blocklists on this code
path).

This patch has been tested on a T5-2 LDOM.

Signed-off-by: James Clarke <jrtc27@jrtc27.com>
Tested-by: John Paul Adrian Glaubitz <glaubitz@physik.fu-berlin.de>
Reviewed-by: Vladimir Serbinenko <phcoder@gmail.com>
Reviewed-by: Eric Snowberg <eric.snowberg@oracle.com>

---
 util/setup.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)
 2019-07-18 14:33:16 +02:00
Vladimir Serbinenko
8f6843ce60 configure: Add -fno-ident when available 
MinGW for i386-pc without this option generates a .rdata$zzz symbol that is
page-aligned and hence lzma_decompress no longer fits in its allocated space.
Additionally, MinGW with -fno-ident also saves a bit of space in modules. In
case of other compilers we already strip the relevant sections, so, this
option has no effect.

More info can be found at https://github.com/msys2/MINGW-packages/issues/21

Signed-off-by: Vladimir Serbinenko <phcoder@gmail.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-07-11 21:06:49 +02:00
Heinrich Schuchardt
15cfd02b74 lsefisystab: Add support for device tree table 
The device tree may passed by the firmware as UEFI configuration
table. Let lsefisystab display a short text and not only the GUID
for the device tree.

Here is an example output:

  grub> lsefisystab
  Address: 0xbff694d8
  Signature: 5453595320494249 revision: 00020046
  Vendor: Das U-Boot, Version=20190700
  2 tables:
  0xbe741000  eb9d2d31-2d88-11d3-9a160090273fc14d   SMBIOS
  0x87f00000  b1b621d5-f19c-41a5-830bd9152c69aae0   DEVICE TREE

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
Reviewed-by: Leif Lindholm <leif.lindholm@linaro.org>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-07-11 21:06:49 +02:00
David Michael
688023cd0a smbios: Add a module for retrieving SMBIOS information 
The following are two use cases from Rajat Jain <rajatjain@juniper.net>:

  1) We have a board that boots Linux and this board itself can be plugged
     into one of different chassis types. We need to pass different
     parameters to the kernel based on the "CHASSIS_TYPE" information
     that is passed by the bios in the DMI/SMBIOS tables.

  2) We may have a USB stick that can go into multiple boards, and the
     exact kernel to be loaded depends on the machine information
     (PRODUCT_NAME etc) passed via the DMI.

Signed-off-by: David Michael <fedora.dm0@gmail.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-07-11 21:06:12 +02:00
David Michael
261df54f17 lsefisystab: Define SMBIOS3 entry point structures for EFI 
This adds the GUID and includes it in lsefisystab output.

Signed-off-by: David Michael <fedora.dm0@gmail.com>
Reviewed-by: Leif Lindholm <leif.lindholm@linaro.org>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-07-11 18:13:15 +02:00
David Michael
dabdfa1c6a verifiers: Blocklist fallout cleanup 
Blocklist fallout cleanup after commit 5c6f9bc15 (generic/blocklist: Fix
implicit declaration of function grub_file_filter_disable_compression()).

Signed-off-by: David Michael <fedora.dm0@gmail.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-07-11 18:06:23 +02:00
Andreas Schwab
2bf40e9e5b RISC-V: Fix computation of pc-relative relocation offset 
The offset calculation was missing the relocation addend.

Signed-off-by: Andreas Schwab <schwab@suse.de>
Tested-by: Chester Lin <clin@suse.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-07-11 17:50:40 +02:00
Leif Lindholm
2d55ffecbb configure: Disable arm movw/movt relocations for GCC 
When building for arm, we already disable movw/movt relocations for clang,
since they are incompatible with PE.

When building with bare metal GCC toolchains (like the one used in the
travis ci scripts), we end up with these relocations again. So add an
additional test for the '-mword-relocations' flag used by GCC.

Reported-by: Alexander Graf <agraf@csgraf.de>
Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-07-11 17:49:54 +02:00
Jacob Kroon
f2b9083f85 probe: Support probing for partition UUID with --part-uuid 
Linux supports root=PARTUUID=<partuuid> boot argument, so add
support for probing it. Compared to the fs UUID, the partition
UUID does not change when reformatting a partition.

For now, only disks using a GPT partition table are supported.

Signed-off-by: Jacob Kroon <jacob.kroon@gmail.com>
Reviewed-by: Paul Menzel <pmenzel@molgen.mpg.de>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-07-11 17:46:46 +02:00
Daniel Kiper
26094f5241 Bump version to 2.05 
Signed-off-by: Daniel Kiper <daniel.kiper@oracle.com>
 2019-07-05 11:30:53 +02:00
281 changed files with 9943 additions and 8025 deletions
Download patch file Download diff file Expand all files Collapse all files

1
.gitattributes vendored Normal file
View file

@ -0,0 +1 @@
po/exclude.pot binary

469
.gitignore vendored
View file

@ -1,238 +1,277 @@
*~ #
00_header # Ignore patterns in this directory and all subdirectories.
10_* #
20_linux_xen
30_os-prober
40_custom
41_custom
*.1 *.1
*.8 *.8
ABOUT-NLS *.a
aclocal.m4
ahci_test
ascii.bitmaps
ascii.h
autom4te.cache
build-aux
build-grub-gen-asciih
build-grub-gen-widthspec
build-grub-mkfont
cdboot_test
cmp_test
config.cache
config.guess
config.h
config-util.h
config-util.h.in
config.log
config.status
config.sub
configure
core_compress_test
DISTLIST
docs/*.info
docs/stamp-vti
docs/version.texi
ehci_test
example_grub_script_test
example_scripted_test
example_unit_test
*.exec *.exec
*.exec.exe *.exec.exe
fddboot_test
genkernsyms.sh
gensymlist.sh
gentrigtables
gentrigtables.exe
gettext_strings_test
gpt_unit_test
/gnulib
grub-bin2h
/grub-bios-setup
/grub-bios-setup.exe
grub_cmd_date
grub_cmd_echo
grub_cmd_regexp
grub_cmd_set_date
grub_cmd_sleep
/grub-editenv
/grub-editenv.exe
grub-emu
grub-emu-lite
grub-emu.exe
grub-emu-lite.exe
grub_emu_init.c
grub_emu_init.h
/grub-file
/grub-file.exe
grub-fstest
grub-fstest.exe
grub_fstest_init.c
grub_fstest_init.h
grub_func_test
grub-install
grub-install.exe
grub-kbdcomp
/grub-macbless
/grub-macbless.exe
grub-macho2img
/grub-menulst2cfg
/grub-menulst2cfg.exe
/grub-mk*
grub-mount
/grub-ofpathname
/grub-ofpathname.exe
grub-core/build-grub-pe2elf.exe
/grub-probe
/grub-probe.exe
grub_probe_init.c
grub_probe_init.h
/grub-reboot
grub_script_blanklines
grub_script_blockarg
grub_script_break
grub-script-check
grub-script-check.exe
grub_script_check_init.c
grub_script_check_init.h
grub_script_comments
grub_script_continue
grub_script_dollar
grub_script_echo1
grub_script_echo_keywords
grub_script_escape_comma
grub_script_eval
grub_script_expansion
grub_script_final_semicolon
grub_script_for1
grub_script_functions
grub_script_gettext
grub_script_if
grub_script_leading_whitespace
grub_script_no_commands
grub_script_not
grub_script_return
grub_script_setparams
grub_script_shift
grub_script_strcmp
grub_script_test
grub_script_vars1
grub_script_while1
grub_script.tab.c
grub_script.tab.h
grub_script.yy.c
grub_script.yy.h
grub-set-default
grub_setup_init.c
grub_setup_init.h
grub-shell
grub-shell-tester
grub-sparc64-setup
grub-sparc64-setup.exe
/grub-syslinux2cfg
/grub-syslinux2cfg.exe
gzcompress_test
hddboot_test
help_test
*.img
*.image *.image
*.image.exe *.image.exe
include/grub/cpu *.img
include/grub/machine
INSTALL.grub
install-sh
lib/libgcrypt-grub
libgrub_a_init.c
*.log *.log
*.lst *.lst
lzocompress_test
*.marker *.marker
Makefile
/m4
*.mod *.mod
mod-*.c
missing
netboot_test
*.o *.o
*.a
ohci_test
partmap_test
pata_test
*.pf2 *.pf2
*.pp *.pp
po/*.mo
po/grub.pot
po/Makefile.in.in
po/Makevars
po/Makevars.template
po/POTFILES
po/Rules-quot
po/stamp-po
printf_test
priority_queue_unit_test
pseries_test
stamp-h
stamp-h1
stamp-h.in
symlist.c
symlist.h
trigtables.c
*.trs *.trs
uhci_test *~
update-grub_lib .deps-core/
unidata.c .deps-util/
xzcompress_test .deps/
Makefile.in .dirstamp
DISTLIST
GPATH GPATH
GRTAGS GRTAGS
GSYMS GSYMS
GTAGS GTAGS
compile Makefile
depcomp Makefile.in
ascii.bitmaps
genkernsyms.sh
gensymlist.sh
grub-bin2h
grub-emu
grub-emu-lite
grub-emu-lite.exe
grub-emu.exe
grub-macho2img
grub_emu_init.c
grub_emu_init.h
grub_probe_init.c
grub_probe_init.h
grub_script.tab.c
grub_script.tab.h
grub_script.yy.c
grub_script.yy.h
grub_script_check_init.c
grub_script_check_init.h
grub_setup_init.c
grub_setup_init.h
mdate-sh mdate-sh
texinfo.tex mod-*.c
grub-core/lib/libgcrypt-grub update-grub_lib
.deps
.deps-util
.deps-core
.dirstamp
Makefile.util.am
contrib
grub-core/bootinfo.txt
grub-core/Makefile.core.am
grub-core/Makefile.gcry.def
grub-core/contrib
grub-core/gdb_grub
grub-core/genmod.sh
grub-core/gensyminfo.sh
grub-core/gmodule.pl
grub-core/grub.chrp
grub-core/modinfo.sh
grub-core/*.module
grub-core/*.module.exe
grub-core/*.pp
grub-core/kernel.img.bin
util/bash-completion.d/grub
grub-core/lib/gnulib
grub-core/rs_decoder.h
widthspec.bin widthspec.bin
widthspec.h
docs/stamp-1 #
docs/version-dev.texi # Ignore patterns relative to this .gitignore file's directory.
Makefile.utilgcry.def #
po/*.po /00_header
po/*.gmo /10_*
po/LINGUAS /20_linux_xen
po/remove-potcdate.sed /30_os-prober
include/grub/gcrypt/gcrypt.h /30_uefi-firmware
include/grub/gcrypt/g10lib.h /40_custom
po/POTFILES.in /41_custom
po/POTFILES-shell.in /ABOUT-NLS
/grub-glue-efi /ChangeLog
/grub-render-label /INSTALL.grub
/grub-glue-efi.exe /Makefile.util.am
/grub-render-label.exe /Makefile.utilgcry.def
/aclocal.m4
/ahci_test
/ascii.h
/autom4te.cache/
/btrfs_test
/build-aux/
/build-grub-gen-asciih
/build-grub-gen-widthspec
/build-grub-mkfont
/cdboot_test
/cmp_test
/compile
/config-util.h
/config-util.h.in
/config.cache
/config.guess
/config.h
/config.log
/config.status
/config.sub
/configure
/contrib
/core_compress_test
/cpio_test
/date_test
/depcomp
/docs/*.info
/docs/*.info-[0-9]*
/docs/stamp-1
/docs/stamp-vti
/docs/version-dev.texi
/docs/version.texi
/ehci_test
/example_grub_script_test
/example_scripted_test
/example_unit_test
/exfat_test
/ext234_test
/f2fs_test
/fat_test
/fddboot_test
/file_filter_test
/garbage-gen /garbage-gen
/garbage-gen.exe /garbage-gen.exe
/gettext_strings_test
/gnulib/
/grub-2.[0-9]*/
/grub-2.[0-9]*.tar.gz
/grub-bios-setup
/grub-bios-setup.exe
/grub-core/*.module
/grub-core/*.module.exe
/grub-core/*.pp
/grub-core/Makefile.core.am
/grub-core/Makefile.gcry.def
/grub-core/bootinfo.txt
/grub-core/build-grub-module-verifier
/grub-core/build-grub-pe2elf.exe
/grub-core/contrib
/grub-core/gdb_grub
/grub-core/genmod.sh
/grub-core/gensyminfo.sh
/grub-core/gentrigtables
/grub-core/gentrigtables.exe
/grub-core/gmodule.pl
/grub-core/grub.chrp
/grub-core/kernel.img.bin
/grub-core/lib/gnulib
/grub-core/lib/libgcrypt-grub
/grub-core/modinfo.sh
/grub-core/rs_decoder.h
/grub-core/symlist.c
/grub-core/symlist.h
/grub-core/trigtables.c
/grub-core/unidata.c
/grub-editenv
/grub-editenv.exe
/grub-file
/grub-file.exe
/grub-fs-tester /grub-fs-tester
grub-core/build-grub-module-verifier /grub-fstest
/grub-fstest.exe
/grub-glue-efi
/grub-glue-efi.exe
/grub-install
/grub-install.exe
/grub-kbdcomp
/grub-macbless
/grub-macbless.exe
/grub-menulst2cfg
/grub-menulst2cfg.exe
/grub-mk*
/grub-mount
/grub-ofpathname
/grub-ofpathname.exe
/grub-probe
/grub-probe.exe
/grub-reboot
/grub-render-label
/grub-render-label.exe
/grub-script-check
/grub-script-check.exe
/grub-set-default
/grub-shell
/grub-shell-tester
/grub-sparc64-setup
/grub-sparc64-setup.exe
/grub-syslinux2cfg
/grub-syslinux2cfg.exe
/grub_cmd_date
/grub_cmd_echo
/grub_cmd_regexp
/grub_cmd_set_date
/grub_cmd_sleep
/grub_cmd_test
/grub_cmd_tr
/grub_fstest_init.c
/grub_fstest_init.h
/grub_func_test
/grub_script_blanklines
/grub_script_blockarg
/grub_script_break
/grub_script_comments
/grub_script_continue
/grub_script_dollar
/grub_script_echo1
/grub_script_echo_keywords
/grub_script_escape_comma
/grub_script_eval
/grub_script_expansion
/grub_script_final_semicolon
/grub_script_for1
/grub_script_functions
/grub_script_gettext
/grub_script_if
/grub_script_leading_whitespace
/grub_script_no_commands
/grub_script_not
/grub_script_return
/grub_script_setparams
/grub_script_shift
/grub_script_strcmp
/grub_script_test
/grub_script_vars1
/grub_script_while1
/gzcompress_test
/hddboot_test
/help_test
/hfs_test
/hfsplus_test
/include/grub/cpu
/include/grub/gcrypt/g10lib.h
/include/grub/gcrypt/gcrypt.h
/include/grub/machine
/install-sh
/iso9660_test
/jfs_test
/lib/libgcrypt-grub
/libgrub_a_init.c
/lzocompress_test
/m4/
/minixfs_test
/missing
/netboot_test
/nilfs2_test
/ntfs_test
/ohci_test
/partmap_test
/pata_test
/po/*.gmo
/po/*.mo
/po/*.po
/po/LINGUAS
/po/Makefile.in.in
/po/Makevars
/po/Makevars.template
/po/POTFILES
/po/POTFILES-shell.in
/po/POTFILES.in
/po/Rules-quot
/po/grub.pot
/po/remove-potcdate.sed
/po/stamp-po
/printf_test
/priority_queue_unit_test
/pseries_test
/reiserfs_test
/romfs_test
/squashfs_test
/stamp-h
/stamp-h.in
/stamp-h1
/syslinux_test
/tar_test
/test_sha512sum
/test_unset
/tests/syslinux/ubuntu10.04_grub.cfg
/texinfo.tex
/udf_test
/uhci_test
/util/bash-completion.d/grub
/widthspec.h
/xfs_test
/xzcompress_test
/zfs_test

3
.travis.yml
View file

@ -12,6 +12,7 @@ language: c
addons: addons:
apt: apt:
packages: packages:
- autopoint
- libsdl1.2-dev - libsdl1.2-dev
- lzop - lzop
- ovmf - ovmf
@ -35,7 +36,7 @@ before_script:
script: script:
# Comments must be outside the command strings below, or the Travis parser # Comments must be outside the command strings below, or the Travis parser
# will get confused. # will get confused.
- ./autogen.sh - ./bootstrap
# Build all selected GRUB targets. # Build all selected GRUB targets.
- for target in $GRUB_TARGETS; do - for target in $GRUB_TARGETS; do

69
INSTALL
View file

@ -11,27 +11,9 @@ GRUB depends on some software packages installed into your system. If
you don't have any of them, please obtain and install them before you don't have any of them, please obtain and install them before
configuring the GRUB. configuring the GRUB.
* GCC 4.1.3 or later * GCC 5.1.0 or later
Note: older versions may work but support is limited Experimental support for clang 3.8.0 or later (results in much bigger binaries)
Experimental support for clang 3.3 or later (results in much bigger binaries)
for i386, x86_64, arm (including thumb), arm64, mips(el), powerpc, sparc64 for i386, x86_64, arm (including thumb), arm64, mips(el), powerpc, sparc64
Note: clang 3.2 or later works for i386 and x86_64 targets but results in
much bigger binaries.
earlier versions not tested
Note: clang 3.2 or later works for arm
earlier versions not tested
Note: clang on arm64 is not supported due to
https://llvm.org/bugs/show_bug.cgi?id=26030
Note: clang 3.3 or later works for mips(el)
earlier versions fail to generate .reginfo and hence gprel relocations
fail.
Note: clang 3.2 or later works for powerpc
earlier versions not tested
Note: clang 3.5 or later works for sparc64
earlier versions return "error: unable to interface with target machine"
Note: clang has no support for ia64 and hence you can't compile GRUB
for ia64 with clang
* GNU Make * GNU Make
* GNU Bison 2.3 or later * GNU Bison 2.3 or later
* GNU gettext 0.17 or later * GNU gettext 0.17 or later
@ -160,12 +142,20 @@ For this example the configure line might look like (more details below)
(some options are optional and included here for completeness but some rarely (some options are optional and included here for completeness but some rarely
used options are omitted): used options are omitted):
./configure BUILD_CC=gcc BUILD_PKG_CONFIG=pkg-config --host=amd64-linux-gnu ./configure --host=x86_64-linux-gnu --target=arm-linux-gnueabihf \
CC=amd64-linux-gnu-gcc CFLAGS="-g -O2" PKG_CONFIG=amd64-linux-gnu-pkg-config --with-platform=efi BUILD_CC=gcc BUILD_PKG_CONFIG=pkg-config \
--target=arm --with-platform=uboot TARGET_CC=arm-elf-gcc HOST_CC=x86_64-linux-gnu-gcc HOST_CFLAGS='-g -O2' \
TARGET_CFLAGS="-Os -march=armv6" TARGET_CCASFLAGS="-march=armv6" PKG_CONFIG=x86_64-linux-gnu-pkg-config TARGET_CC=arm-linux-gnueabihf-gcc \
TARGET_OBJCOPY="arm-elf-objcopy" TARGET_STRIP="arm-elf-strip" TARGET_CFLAGS='-Os -march=armv8.3-a' TARGET_CCASFLAGS='-march=armv8.3-a' \
TARGET_NM=arm-elf-nm TARGET_RANLIB=arm-elf-ranlib LEX=gflex TARGET_OBJCOPY=arm-linux-gnueabihf-objcopy \
TARGET_STRIP=arm-linux-gnueabihf-strip TARGET_NM=arm-linux-gnueabihf-nm \
TARGET_RANLIB=arm-linux-gnueabihf-ranlib LEX=flex
Normally, for building a GRUB on amd64 with tools to run on amd64 to
generate images to run on ARM, using your Linux distribution's
packaged cross compiler, the following would suffice:
./configure --target=arm-linux-gnueabihf --with-platform=efi
You need to use following options to specify tools and platforms. For minimum You need to use following options to specify tools and platforms. For minimum
version look at prerequisites. All tools not mentioned in this section under version look at prerequisites. All tools not mentioned in this section under
@ -182,20 +172,23 @@ corresponding platform are not needed for the platform in question.
- For host - For host
1. --host= to autoconf name of host. 1. --host= to autoconf name of host.
2. CC= for gcc able to compile for host 2. CC= for gcc able to compile for host.
3. HOST_CFLAGS= for C options for host. 3. CFLAGS= for C options for host.
4. HOST_CPPFLAGS= for C preprocessor options for host. 4. HOST_CC= for gcc able to compile for host.
5. HOST_LDFLAGS= for linker options for host. 5. HOST_CFLAGS= for C options for host.
6. PKG_CONFIG= for pkg-config for host (optional). 6. HOST_CPPFLAGS= for C preprocessor options for host.
7. Libdevmapper if any must be in standard linker folders (-ldevmapper) (optional). 7. HOST_LDFLAGS= for linker options for host.
8. Libfuse if any must be in standard linker folders (-lfuse) (optional). 8. PKG_CONFIG= for pkg-config for host (optional).
9. Libzfs if any must be in standard linker folders (-lzfs) (optional). 9. Libdevmapper if any must be in standard linker folders (-ldevmapper) (optional).
10. Liblzma if any must be in standard linker folders (-llzma) (optional). 10. Libfuse if any must be in standard linker folders (-lfuse) (optional).
11. Libzfs if any must be in standard linker folders (-lzfs) (optional).
12. Liblzma if any must be in standard linker folders (-llzma) (optional).
Note: The HOST_* variables override not prefixed variables.
- For target - For target
1. --target= to autoconf cpu name of target. 1. --target= to autoconf cpu name of target.
2. --with-platform to choose firmware. 2. --with-platform to choose firmware.
3. TARGET_CC= for gcc able to compile for target 3. TARGET_CC= for gcc able to compile for target.
4. TARGET_CFLAGS= for C options for target. 4. TARGET_CFLAGS= for C options for target.
5. TARGET_CPPFLAGS= for C preprocessor options for target. 5. TARGET_CPPFLAGS= for C preprocessor options for target.
6. TARGET_CCASFLAGS= for assembler options for target. 6. TARGET_CCASFLAGS= for assembler options for target.
@ -204,6 +197,10 @@ corresponding platform are not needed for the platform in question.
9. TARGET_STRIP= for strip for target. 9. TARGET_STRIP= for strip for target.
10. TARGET_NM= for nm for target. 10. TARGET_NM= for nm for target.
11. TARGET_RANLIB= for ranlib for target. 11. TARGET_RANLIB= for ranlib for target.
Note: If the TARGET_* variables are not specified then they will default
to be the same as the host variables. If host variables are not
specified then the TARGET_* variables will default to be the same
as not prefixed variables.
- Additionally for emu, for host and target. - Additionally for emu, for host and target.
1. SDL is looked for in standard linker directories (-lSDL) (optional) 1. SDL is looked for in standard linker directories (-lSDL) (optional)

2
Makefile.am
View file

@ -37,7 +37,7 @@ grub_script.yy.c: grub_script.yy.h
CLEANFILES += grub_script.yy.c grub_script.yy.h CLEANFILES += grub_script.yy.c grub_script.yy.h
# For libgrub.a # For libgrub.a
libgrub.pp: grub_script.tab.h grub_script.yy.h $(libgrubmods_a_SOURCES) $(libgrubkern_a_SOURCES) libgrub.pp: config-util.h grub_script.tab.h grub_script.yy.h $(libgrubmods_a_SOURCES) $(libgrubkern_a_SOURCES)
$(CPP) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libgrubmods_a_CPPFLAGS) $(libgrubkern_a_CPPFLAGS) $(CPPFLAGS) \ $(CPP) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libgrubmods_a_CPPFLAGS) $(libgrubkern_a_CPPFLAGS) $(CPPFLAGS) \
-D'GRUB_MOD_INIT(x)=@MARKER@x@' $^ > $@ || (rm -f $@; exit 1) -D'GRUB_MOD_INIT(x)=@MARKER@x@' $^ > $@ || (rm -f $@; exit 1)
CLEANFILES += libgrub.pp CLEANFILES += libgrub.pp

54
Makefile.util.def
View file

@ -3,7 +3,7 @@ AutoGen definitions Makefile.tpl;
library = { library = {
name = libgrubkern.a; name = libgrubkern.a;
cflags = '$(CFLAGS_GNULIB)'; cflags = '$(CFLAGS_GNULIB)';
cppflags = '$(CPPFLAGS_GNULIB)'; cppflags = '$(CPPFLAGS_GNULIB) -I$(srcdir)/grub-core/lib/json';
common = util/misc.c; common = util/misc.c;
common = grub-core/kern/command.c; common = grub-core/kern/command.c;
@ -36,7 +36,9 @@ library = {
common = grub-core/kern/misc.c; common = grub-core/kern/misc.c;
common = grub-core/kern/partition.c; common = grub-core/kern/partition.c;
common = grub-core/lib/crypto.c; common = grub-core/lib/crypto.c;
common = grub-core/lib/json/json.c;
common = grub-core/disk/luks.c; common = grub-core/disk/luks.c;
common = grub-core/disk/luks2.c;
common = grub-core/disk/geli.c; common = grub-core/disk/geli.c;
common = grub-core/disk/cryptodisk.c; common = grub-core/disk/cryptodisk.c;
common = grub-core/disk/AFSplitter.c; common = grub-core/disk/AFSplitter.c;
@ -139,7 +141,7 @@ library = {
common = grub-core/lib/crc.c; common = grub-core/lib/crc.c;
common = grub-core/lib/adler32.c; common = grub-core/lib/adler32.c;
common = grub-core/lib/crc64.c; common = grub-core/lib/crc64.c;
common = grub-core/normal/datetime.c; common = grub-core/lib/datetime.c;
common = grub-core/normal/misc.c; common = grub-core/normal/misc.c;
common = grub-core/partmap/acorn.c; common = grub-core/partmap/acorn.c;
common = grub-core/partmap/amiga.c; common = grub-core/partmap/amiga.c;
@ -240,8 +242,19 @@ program = {
common = util/grub-editenv.c; common = util/grub-editenv.c;
common = util/editenv.c; common = util/editenv.c;
common = util/grub-install-common.c;
common = grub-core/osdep/init.c; common = grub-core/osdep/init.c;
common = grub-core/osdep/compress.c;
extra_dist = grub-core/osdep/unix/compress.c;
extra_dist = grub-core/osdep/basic/compress.c;
common = util/mkimage.c;
common = util/grub-mkimage32.c;
common = util/grub-mkimage64.c;
common = grub-core/osdep/config.c;
common = util/config.c;
common = util/resolve.c;
ldadd = '$(LIBLZMA)';
ldadd = libgrubmods.a; ldadd = libgrubmods.a;
ldadd = libgrubgcry.a; ldadd = libgrubgcry.a;
ldadd = libgrubkern.a; ldadd = libgrubkern.a;
@ -502,6 +515,12 @@ script = {
installdir = grubconf; installdir = grubconf;
}; };
script = {
name = '30_uefi-firmware';
common = util/grub.d/30_uefi-firmware.in;
installdir = grubconf;
};
script = { script = {
name = '40_custom'; name = '40_custom';
common = util/grub.d/40_custom.in; common = util/grub.d/40_custom.in;
@ -1175,18 +1194,6 @@ script = {
common = tests/grub_cmd_tr.in; common = tests/grub_cmd_tr.in;
}; };
script = {
testcase;
name = gptrepair_test;
common = tests/gptrepair_test.in;
};
script = {
testcase;
name = gptprio_test;
common = tests/gptprio_test.in;
};
script = { script = {
testcase; testcase;
name = file_filter_test; name = file_filter_test;
@ -1282,25 +1289,6 @@ program = {
ldadd = '$(LIBDEVMAPPER) $(LIBZFS) $(LIBNVPAIR) $(LIBGEOM)'; ldadd = '$(LIBDEVMAPPER) $(LIBZFS) $(LIBNVPAIR) $(LIBGEOM)';
}; };
program = {
testcase;
name = gpt_unit_test;
common = tests/gpt_unit_test.c;
common = tests/lib/unit_test.c;
common = grub-core/commands/search_part_label.c;
common = grub-core/commands/search_part_uuid.c;
common = grub-core/commands/search_disk_uuid.c;
common = grub-core/disk/host.c;
common = grub-core/kern/emu/hostfs.c;
common = grub-core/lib/gpt.c;
common = grub-core/tests/lib/test.c;
ldadd = libgrubmods.a;
ldadd = libgrubgcry.a;
ldadd = libgrubkern.a;
ldadd = grub-core/gnulib/libgnu.a;
ldadd = '$(LIBDEVMAPPER) $(LIBZFS) $(LIBNVPAIR) $(LIBGEOM)';
};
program = { program = {
name = grub-menulst2cfg; name = grub-menulst2cfg;
mansection = 1; mansection = 1;

2
autogen.sh
View file

@ -13,7 +13,7 @@ fi
export LC_COLLATE=C export LC_COLLATE=C
unset LC_ALL unset LC_ALL
find . -iname '*.[ch]' ! -ipath './grub-core/lib/libgcrypt-grub/*' ! -ipath './build-aux/*' ! -ipath './grub-core/lib/libgcrypt/src/misc.c' ! -ipath './grub-core/lib/libgcrypt/src/global.c' ! -ipath './grub-core/lib/libgcrypt/src/secmem.c' ! -ipath './util/grub-gen-widthspec.c' ! -ipath './util/grub-gen-asciih.c' ! -ipath './gnulib/*' ! -iname './grub-core/lib/gnulib/*' |sort > po/POTFILES.in find . -iname '*.[ch]' ! -ipath './grub-core/lib/libgcrypt-grub/*' ! -ipath './build-aux/*' ! -ipath './grub-core/lib/libgcrypt/src/misc.c' ! -ipath './grub-core/lib/libgcrypt/src/global.c' ! -ipath './grub-core/lib/libgcrypt/src/secmem.c' ! -ipath './util/grub-gen-widthspec.c' ! -ipath './util/grub-gen-asciih.c' ! -ipath './gnulib/*' ! -ipath './grub-core/lib/gnulib/*' |sort > po/POTFILES.in
find util -iname '*.in' ! -name Makefile.in |sort > po/POTFILES-shell.in find util -iname '*.in' ! -name Makefile.in |sort > po/POTFILES-shell.in
echo "Importing unicode..." echo "Importing unicode..."

11
bootstrap.conf
View file

@ -23,6 +23,7 @@ GNULIB_REVISION=d271f868a8df9bbec29049d01e056481b7a1a263
# directly. # directly.
gnulib_modules=" gnulib_modules="
argp argp
base64
error error
fnmatch fnmatch
getdelim getdelim
@ -78,10 +79,18 @@ cp -a INSTALL INSTALL.grub
bootstrap_post_import_hook () { bootstrap_post_import_hook () {
set -e set -e
for patchname in fix-null-deref fix-width no-abort; do for patchname in fix-base64 fix-null-deref fix-width no-abort; do
patch -d grub-core/lib/gnulib -p2 \ patch -d grub-core/lib/gnulib -p2 \
< "grub-core/lib/gnulib-patches/$patchname.patch" < "grub-core/lib/gnulib-patches/$patchname.patch"
done done
for patchname in \
0001-Support-POTFILES-shell \
0002-Handle-gettext_printf-shell-function \
0003-Make-msgfmt-output-in-little-endian \
0004-Use-SHELL-rather-than-bin-sh; do
patch -d po -p3 \
< "po/gettext-patches/$patchname.patch"
done
FROM_BOOTSTRAP=1 ./autogen.sh FROM_BOOTSTRAP=1 ./autogen.sh
set +e # bootstrap expects this set +e # bootstrap expects this
} }

16
conf/Makefile.extra-dist
View file

@ -28,6 +28,7 @@ EXTRA_DIST += grub-core/gensymlist.sh
EXTRA_DIST += grub-core/genemuinit.sh EXTRA_DIST += grub-core/genemuinit.sh
EXTRA_DIST += grub-core/genemuinitheader.sh EXTRA_DIST += grub-core/genemuinitheader.sh
EXTRA_DIST += grub-core/lib/gnulib-patches/fix-base64.patch
EXTRA_DIST += grub-core/lib/gnulib-patches/fix-null-deref.patch EXTRA_DIST += grub-core/lib/gnulib-patches/fix-null-deref.patch
EXTRA_DIST += grub-core/lib/gnulib-patches/fix-width.patch EXTRA_DIST += grub-core/lib/gnulib-patches/fix-width.patch
EXTRA_DIST += grub-core/lib/gnulib-patches/no-abort.patch EXTRA_DIST += grub-core/lib/gnulib-patches/no-abort.patch
@ -110,6 +111,21 @@ EXTRA_DIST += grub-core/osdep/windows/password.c
EXTRA_DIST += grub-core/osdep/windows/random.c EXTRA_DIST += grub-core/osdep/windows/random.c
EXTRA_DIST += grub-core/osdep/windows/sleep.c EXTRA_DIST += grub-core/osdep/windows/sleep.c
EXTRA_DIST += po/gettext-patches/0001-Support-POTFILES-shell.patch
EXTRA_DIST += po/gettext-patches/0002-Handle-gettext_printf-shell-function.patch
EXTRA_DIST += po/gettext-patches/0003-Make-msgfmt-output-in-little-endian.patch
EXTRA_DIST += po/gettext-patches/0004-Use-SHELL-rather-than-bin-sh.patch
EXTRA_DIST += po/POTFILES-shell.in
EXTRA_DIST += po/README
EXTRA_DIST += po/Rules-translit
EXTRA_DIST += po/Rules-windowsdir
EXTRA_DIST += po/arabic.sed
EXTRA_DIST += po/cyrillic.sed
EXTRA_DIST += po/greek.sed
EXTRA_DIST += po/grub.d.sed
EXTRA_DIST += po/hebrew.sed
EXTRA_DIST += tests/dfly-mbr-mbexample.mbr.img.gz EXTRA_DIST += tests/dfly-mbr-mbexample.mbr.img.gz
EXTRA_DIST += tests/dfly-mbr-mbexample.dfly.img.gz EXTRA_DIST += tests/dfly-mbr-mbexample.dfly.img.gz

87
configure.ac
View file

@ -26,12 +26,15 @@ dnl This is necessary because the target type in autoconf does not
dnl describe such a system very well. dnl describe such a system very well.
dnl dnl
dnl The current strategy is to use variables with no prefix (such as dnl The current strategy is to use variables with no prefix (such as
dnl CC, CFLAGS, etc.) for the host type, variables with prefix "BUILD_" dnl CC, CFLAGS, etc.) for the host and target type, variables with
dnl (such as BUILD_CC, BUILD_CFLAGS, etc.) for the build type and variables dnl prefix "BUILD_" (such as BUILD_CC, BUILD_CFLAGS, etc.) for the
dnl with the prefix "TARGET_" (such as TARGET_CC, TARGET_CFLAGS, etc.) are dnl build type, variables with prefix "HOST_" (such as HOST_CC,
dnl used for the target type. See INSTALL for full list of variables. dnl HOST_CFLAGS, etc.) for the host type and variables with the prefix
dnl "TARGET_" (such as TARGET_CC, TARGET_CFLAGS, etc.) are used for
dnl the target type. See INSTALL for full list of variables and
dnl description of the relationships between them.
AC_INIT([GRUB],[2.04],[bug-grub@gnu.org]) AC_INIT([GRUB],[2.05],[bug-grub@gnu.org])
AC_CONFIG_AUX_DIR([build-aux]) AC_CONFIG_AUX_DIR([build-aux])
@ -77,9 +80,15 @@ grub_TRANSFORM([grub-file])
# Optimization flag. Allow user to override. # Optimization flag. Allow user to override.
if test "x$TARGET_CFLAGS" = x; then if test "x$TARGET_CFLAGS" = x; then
TARGET_CFLAGS="$TARGET_CFLAGS -Os" TARGET_CFLAGS=-Os
fi fi
# Enable support for "restrict" keyword and other
# features from gnu99 C language standard.
BUILD_CFLAGS="-std=gnu99 $BUILD_CFLAGS"
HOST_CFLAGS="-std=gnu99 $HOST_CFLAGS"
TARGET_CFLAGS="-std=gnu99 $TARGET_CFLAGS"
# Default HOST_CPPFLAGS # Default HOST_CPPFLAGS
HOST_CPPFLAGS="$HOST_CPPFLAGS -Wall -W" HOST_CPPFLAGS="$HOST_CPPFLAGS -Wall -W"
HOST_CPPFLAGS="$HOST_CPPFLAGS -DGRUB_UTIL=1" HOST_CPPFLAGS="$HOST_CPPFLAGS -DGRUB_UTIL=1"
@ -562,6 +571,24 @@ CPPFLAGS="$TARGET_CPPFLAGS"
LDFLAGS="$TARGET_LDFLAGS" LDFLAGS="$TARGET_LDFLAGS"
LIBS="" LIBS=""
if test "x$target_m32" = x1; then
# Force 32-bit mode.
TARGET_CFLAGS="$TARGET_CFLAGS -m32"
TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m32"
TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m32"
TARGET_LDFLAGS="$TARGET_LDFLAGS -m32"
TARGET_MODULE_FORMAT="elf32"
fi
if test "x$target_m64" = x1; then
# Force 64-bit mode.
TARGET_CFLAGS="$TARGET_CFLAGS -m64"
TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m64"
TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m64"
TARGET_LDFLAGS="$TARGET_LDFLAGS -m64"
TARGET_MODULE_FORMAT="elf64"
fi
# debug flags. # debug flags.
TARGET_CFLAGS="$TARGET_CFLAGS $WARN_FLAGS -g -Wredundant-decls -Wmissing-prototypes -Wmissing-declarations" TARGET_CFLAGS="$TARGET_CFLAGS $WARN_FLAGS -g -Wredundant-decls -Wmissing-prototypes -Wmissing-declarations"
TARGET_CCASFLAGS="$TARGET_CCASFLAGS -g" TARGET_CCASFLAGS="$TARGET_CCASFLAGS -g"
@ -750,24 +777,6 @@ if test "x$target_cpu" = xi386 && test "x$platform" != xemu; then
TARGET_CFLAGS="$TARGET_CFLAGS -march=i386" TARGET_CFLAGS="$TARGET_CFLAGS -march=i386"
fi fi
if test "x$target_m32" = x1; then
# Force 32-bit mode.
TARGET_CFLAGS="$TARGET_CFLAGS -m32"
TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m32"
TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m32"
TARGET_LDFLAGS="$TARGET_LDFLAGS -m32"
TARGET_MODULE_FORMAT="elf32"
fi
if test "x$target_m64" = x1; then
# Force 64-bit mode.
TARGET_CFLAGS="$TARGET_CFLAGS -m64"
TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m64"
TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m64"
TARGET_LDFLAGS="$TARGET_LDFLAGS -m64"
TARGET_MODULE_FORMAT="elf64"
fi
if test "x$grub_cv_cc_target_clang" = xno && test "x$target_cpu" = xi386 && test "x$platform" != xemu && test "x$platform" != xefi; then if test "x$grub_cv_cc_target_clang" = xno && test "x$target_cpu" = xi386 && test "x$platform" != xemu && test "x$platform" != xefi; then
TARGET_CFLAGS="$TARGET_CFLAGS -mrtd -mregparm=3" TARGET_CFLAGS="$TARGET_CFLAGS -mrtd -mregparm=3"
fi fi
@ -854,6 +863,11 @@ if test x"$platform" != xemu ; then
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])], AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
[grub_cv_target_cc_soft_float="-mno-inline-float-divide -mno-inline-sqrt"], []) [grub_cv_target_cc_soft_float="-mno-inline-float-divide -mno-inline-sqrt"], [])
fi fi
if test "x$target_cpu" = xsh4; then
CFLAGS="$TARGET_CFLAGS -m4-nofpu -Werror"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
[grub_cv_target_cc_soft_float="-m4-nofpu"], [])
fi
for cand in "-msoft-float -Xclang -msoft-float -Xclang -no-implicit-float" \ for cand in "-msoft-float -Xclang -msoft-float -Xclang -no-implicit-float" \
"-Xclang -msoft-float -Xclang -no-implicit-float" \ "-Xclang -msoft-float -Xclang -no-implicit-float" \
"-Xclang -msoft-float" "-msoft-float"; do "-Xclang -msoft-float" "-msoft-float"; do
@ -999,6 +1013,17 @@ if test "x$grub_cv_cc_fno_unwind_tables" = xyes; then
TARGET_CFLAGS="$TARGET_CFLAGS -fno-unwind-tables" TARGET_CFLAGS="$TARGET_CFLAGS -fno-unwind-tables"
fi fi
# Do not generate .ident sections.
AC_CACHE_CHECK([whether -fno-ident works], [grub_cv_cc_fno_ident], [
CFLAGS="$TARGET_CFLAGS -fno-ident"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
[grub_cv_cc_fno_ident=yes],
[grub_cv_cc_fno_ident=no])
])
if test "x$grub_cv_cc_fno_ident" = xyes; then
TARGET_CFLAGS="$TARGET_CFLAGS -fno-ident"
fi
CFLAGS="$TARGET_CFLAGS" CFLAGS="$TARGET_CFLAGS"
@ -1198,7 +1223,8 @@ if test "x$target_cpu" = xarm; then
AC_CACHE_CHECK([for options to disable movt and movw], grub_cv_target_cc_mno_movt, [ AC_CACHE_CHECK([for options to disable movt and movw], grub_cv_target_cc_mno_movt, [
grub_cv_target_cc_mno_movt=no grub_cv_target_cc_mno_movt=no
for cand in "-mno-movt" \ for cand in "-mno-movt" \
"-mllvm -arm-use-movt=0"; do "-mllvm -arm-use-movt=0" \
"-mword-relocations"; do
if test x"$grub_cv_target_cc_mno_movt" != xno ; then if test x"$grub_cv_target_cc_mno_movt" != xno ; then
break break
fi fi
@ -1251,6 +1277,7 @@ grub_CHECK_LINK_PIE
# `-fPIE' or '-fpie' and '-pie' in the default specs. # `-fPIE' or '-fpie' and '-pie' in the default specs.
if [ x"$pie_possible" = xyes ]; then if [ x"$pie_possible" = xyes ]; then
TARGET_CFLAGS="$TARGET_CFLAGS -fno-PIE -fno-pie" TARGET_CFLAGS="$TARGET_CFLAGS -fno-PIE -fno-pie"
TARGET_CCASFLAGS="$TARGET_CCASFLAGS -fno-PIE -fno-pie"
fi fi
if [ x"$link_nopie_needed" = xyes ] || [ x"$pie_possible" = xyes ]; then if [ x"$link_nopie_needed" = xyes ] || [ x"$pie_possible" = xyes ]; then
@ -1358,7 +1385,7 @@ fi
# Check for libgcc symbols # Check for libgcc symbols
if test x"$platform" = xemu; then if test x"$platform" = xemu; then
AC_CHECK_FUNCS(__udivsi3 __umodsi3 __divsi3 __modsi3 __divdi3 __moddi3 __udivdi3 __umoddi3 __ctzdi2 __ctzsi2 __aeabi_uidiv __aeabi_uidivmod __aeabi_idiv __aeabi_idivmod __aeabi_ulcmp __muldi3 __aeabi_lmul __aeabi_memcpy __aeabi_memcpy4 __aeabi_memcpy8 __aeabi_memclr __aeabi_memclr4 __aeabi_memclr8 __aeabi_memset __aeabi_lasr __aeabi_llsl __aeabi_llsr _restgpr_14_x __ucmpdi2 __ashldi3 __ashrdi3 __lshrdi3 __bswapsi2 __bswapdi2 __bzero __register_frame_info __deregister_frame_info ___chkstk_ms __chkstk_ms) AC_CHECK_FUNCS(__udivsi3 __umodsi3 __divsi3 __modsi3 __divdi3 __moddi3 __udivdi3 __umoddi3 __ctzdi2 __ctzsi2 __clzdi2 __aeabi_uidiv __aeabi_uidivmod __aeabi_idiv __aeabi_idivmod __aeabi_ulcmp __muldi3 __aeabi_lmul __aeabi_memcpy __aeabi_memcpy4 __aeabi_memcpy8 __aeabi_memclr __aeabi_memclr4 __aeabi_memclr8 __aeabi_memset __aeabi_lasr __aeabi_llsl __aeabi_llsr _restgpr_14_x __ucmpdi2 __ashldi3 __ashrdi3 __lshrdi3 __bswapsi2 __bswapdi2 __bzero __register_frame_info __deregister_frame_info ___chkstk_ms __chkstk_ms)
fi fi
if test "x$TARGET_APPLE_LINKER" = x1 ; then if test "x$TARGET_APPLE_LINKER" = x1 ; then
@ -1435,9 +1462,11 @@ LIBS="$tmp_LIBS"
# Memory manager debugging. # Memory manager debugging.
AC_ARG_ENABLE([mm-debug], AC_ARG_ENABLE([mm-debug],
AS_HELP_STRING([--enable-mm-debug], AS_HELP_STRING([--enable-mm-debug],
[include memory manager debugging]), [include memory manager debugging]))
[AC_DEFINE([MM_DEBUG], [1], if test x$enable_mm_debug = xyes; then
[Define to 1 if you enable memory manager debugging.])]) AC_DEFINE([MM_DEBUG], [1],
[Define to 1 if you enable memory manager debugging.])
fi
AC_ARG_ENABLE([cache-stats], AC_ARG_ENABLE([cache-stats],
AS_HELP_STRING([--enable-cache-stats], AS_HELP_STRING([--enable-cache-stats],

37
docs/grub-dev.texi
View file

@ -490,6 +490,8 @@ to update it.
@menu @menu
* Gnulib:: * Gnulib::
* jsmn::
* minilzo::
@end menu @end menu
@node Gnulib @node Gnulib
@ -545,6 +547,41 @@ AC_SYS_LARGEFILE
@end example @end example
It will also be necessary to adjust the patches in
@file{po/gettext-patches/} to apply to an older version of gettext.
@node jsmn
@section jsmn
jsmn is a minimalistic JSON parser which is implemented in a single header file
@file{jsmn.h}. To import a different version of the jsmn parser, you may simply
download the @file{jsmn.h} header from the desired tag or commit to the target
directory:
@example
curl -L https://raw.githubusercontent.com/zserge/jsmn/v1.1.0/jsmn.h \
-o grub-core/lib/json/jsmn.h
@end example
@node minilzo
@section minilzo
miniLZO is a very lightweight subset of the LZO library intended for easy
inclusion in other projects. It is generated automatically from the LZO
source code and contains the most important LZO functions.
To upgrade to a new version of the miniLZO library, download the release
tarball and copy the files into the target directory:
@example
curl -L -O http://www.oberhumer.com/opensource/lzo/download/minilzo-2.08.tar.gz
tar -zxf minilzo-2.08.tar.gz
rm minilzo-2.08/testmini.c
rm -r grub-core/lib/minilzo/*
cp minilzo-2.08/*.[hc] grub-core/lib/minilzo
rm -r minilzo-2.08*
@end example
@node Porting @node Porting
@chapter Porting @chapter Porting

252
docs/grub.texi
View file

@ -894,6 +894,7 @@ magic.
@menu @menu
* General boot methods:: How to boot OSes with GRUB generally * General boot methods:: How to boot OSes with GRUB generally
* Loopback booting:: Notes on booting from loopbacks * Loopback booting:: Notes on booting from loopbacks
* LVM cache booting:: Notes on booting from LVM cache logical volume
* OS-specific notes:: Notes on some operating systems * OS-specific notes:: Notes on some operating systems
@end menu @end menu
@ -991,6 +992,26 @@ way. Please consider alternative boot methods like copying all files
from the image to actual partition. Consult your OS documentation for from the image to actual partition. Consult your OS documentation for
more details more details
@node LVM cache booting
@section Booting from LVM cache logical volume
The LVM cache logical volume is the logical volume consisting of the original
and the cache pool logical volume. The original is usually on a larger and
slower storage device while the cache pool is on a smaller and faster one. The
performance of the original volume can be improved by storing the frequently
used data on the cache pool to utilize the greater performance of faster
device.
GRUB boots from LVM cache logical volume merely by reading it's original
logical volume so that dirty data in cache pool volume is disregarded. This is
not a problem for "writethrough" cache mode as it ensures that any data written
will be stored both on the cache and the origin LV. For the other cache mode
"writeback", which delays writing from the cache pool back to the origin LV to
boost performance, GRUB may fail to boot in the wake of accidental power outage
due to it's inability to assemble the cache device for reading the required
dirty data left behind. The situation will be improved after adding full
support to the LVM cache logical volume in the future.
@node OS-specific notes @node OS-specific notes
@section Some caveats on OS-specific issues @section Some caveats on OS-specific issues
@ -1093,12 +1114,6 @@ grub> @kbd{initrd16 /initrd}
Finally, run the command @command{boot} (@pxref{boot}). Finally, run the command @command{boot} (@pxref{boot}).
@end enumerate @end enumerate
@strong{Caution:} If you use an initrd and specify the @samp{mem=}
option to the kernel to let it use less than actual memory size, you
will also have to specify the same memory size to GRUB. To let GRUB know
the size, run the command @command{uppermem} @emph{before} loading the
kernel. @xref{uppermem}, for more information.
@node NetBSD @node NetBSD
@subsection NetBSD @subsection NetBSD
@ -1309,12 +1324,12 @@ menu and then wait for the timeout set by @samp{GRUB_TIMEOUT} to expire
before booting the default entry. Pressing a key interrupts the timeout. before booting the default entry. Pressing a key interrupts the timeout.
If this option is set to @samp{countdown} or @samp{hidden}, then, before If this option is set to @samp{countdown} or @samp{hidden}, then, before
displaying the menu, GRUB will wait for the timeout set by displaying the menu, GRUB will wait for the timeout set by @samp{GRUB_TIMEOUT}
@samp{GRUB_TIMEOUT} to expire. If @key{ESC} is pressed during that time, it to expire. If @key{ESC} or @key{F4} are pressed, or @key{SHIFT} is held down
will display the menu and wait for input. If a hotkey associated with a during that time, it will display the menu and wait for input. If a hotkey
menu entry is pressed, it will boot the associated menu entry immediately. associated with a menu entry is pressed, it will boot the associated menu entry
If the timeout expires before either of these happens, it will boot the immediately. If the timeout expires before either of these happens, it will
default entry. In the @samp{countdown} case, it will show a one-line boot the default entry. In the @samp{countdown} case, it will show a one-line
indication of the remaining time. indication of the remaining time.
@item GRUB_DEFAULT_BUTTON @item GRUB_DEFAULT_BUTTON
@ -1441,6 +1456,15 @@ enable the use of partition UUIDs, set this option to @samp{false}.
If this option is set to @samp{true}, disable the generation of recovery If this option is set to @samp{true}, disable the generation of recovery
mode menu entries. mode menu entries.
@item GRUB_DISABLE_UUID
Normally, @command{grub-mkconfig} will generate menu entries that use
universally-unique identifiers (UUIDs) to identify various filesystems to
search for files. This is usually more reliable, but in some cases it may
not be appropriate. To disable this use of UUIDs, set this option to
@samp{true}. Setting this option to @samp{true}, will also set the options
@samp{GRUB_DISABLE_LINUX_UUID} and @samp{GRUB_DISABLE_LINUX_PARTUUID} to
@samp{true}, unless they have been explicilty set to @samp{false}.
@item GRUB_VIDEO_BACKEND @item GRUB_VIDEO_BACKEND
If graphical video support is required, either because the @samp{gfxterm} If graphical video support is required, either because the @samp{gfxterm}
graphical terminal is in use or because @samp{GRUB_GFXPAYLOAD_LINUX} is set, graphical terminal is in use or because @samp{GRUB_GFXPAYLOAD_LINUX} is set,
@ -1495,7 +1519,7 @@ Normally, @command{grub-mkconfig} will generate top level menu entry for
the kernel with highest version number and put all other found kernels the kernel with highest version number and put all other found kernels
or alternative menu entries for recovery mode in submenu. For entries returned or alternative menu entries for recovery mode in submenu. For entries returned
by @command{os-prober} first entry will be put on top level and all others by @command{os-prober} first entry will be put on top level and all others
in submenu. If this option is set to @samp{y}, flat menu with all entries in submenu. If this option is set to @samp{true}, flat menu with all entries
on top level will be generated instead. Changing this option will require on top level will be generated instead. Changing this option will require
changing existing values of @samp{GRUB_DEFAULT}, @samp{fallback} (@pxref{fallback}) changing existing values of @samp{GRUB_DEFAULT}, @samp{fallback} (@pxref{fallback})
and @samp{default} (@pxref{default}) environment variables as well as saved and @samp{default} (@pxref{default}) environment variables as well as saved
@ -1529,16 +1553,16 @@ configurations, but have better replacements:
@table @samp @table @samp
@item GRUB_HIDDEN_TIMEOUT @item GRUB_HIDDEN_TIMEOUT
Wait this many seconds before displaying the menu. If @key{ESC} is pressed Wait this many seconds before displaying the menu. If @key{ESC} or @key{F4} are
during that time, display the menu and wait for input according to pressed, or @key{SHIFT} is held down during that time, display the menu and wait
@samp{GRUB_TIMEOUT}. If a hotkey associated with a menu entry is pressed, for input according to @samp{GRUB_TIMEOUT}. If a hotkey associated with a menu
boot the associated menu entry immediately. If the timeout expires before entry is pressed, boot the associated menu entry immediately. If the timeout
either of these happens, display the menu for the number of seconds expires before either of these happens, display the menu for the number of
specified in @samp{GRUB_TIMEOUT} before booting the default entry. seconds specified in @samp{GRUB_TIMEOUT} before booting the default entry.
If you set @samp{GRUB_HIDDEN_TIMEOUT}, you should also set If you set @samp{GRUB_HIDDEN_TIMEOUT}, you should also set
@samp{GRUB_TIMEOUT=0} so that the menu is not displayed at all unless @samp{GRUB_TIMEOUT=0} so that the menu is not displayed at all unless
@key{ESC} is pressed. @key{ESC} or @key{F4} are pressed, or @key{SHIFT} is held down.
This option is unset by default, and is deprecated in favour of the less This option is unset by default, and is deprecated in favour of the less
confusing @samp{GRUB_TIMEOUT_STYLE=countdown} or confusing @samp{GRUB_TIMEOUT_STYLE=countdown} or
@ -2486,6 +2510,57 @@ grub-mknetdir --net-directory=/srv/tftp --subdir=/boot/grub -d /usr/lib/grub/i38
Then follow instructions printed out by grub-mknetdir on configuring your DHCP Then follow instructions printed out by grub-mknetdir on configuring your DHCP
server. server.
The grub.cfg file is placed in the same directory as the path output by
grub-mknetdir hereafter referred to as FWPATH. GRUB will search for its
configuration files in order using the following rules where the appended
value corresponds to a value on the client machine.
@example
@group
@samp{(FWPATH)}/grub.cfg-@samp{(UUID OF MACHINE)}
@samp{(FWPATH)}/grub.cfg-@samp{(MAC ADDRESS OF NIC)}
@samp{(FWPATH)}/grub.cfg-@samp{(IPv4 OR IPv6 ADDRESS)}
@samp{(FWPATH)}/grub.cfg
@end group
@end example
The UUID is the Client Machine Identifier Option Definition as specified in
RFC 4578. The client will only attempt to loouk up a UUID config file if it
was provided by the DHCP server.
The client will only attempt to look up an IPv6 address config once, however,
it will try the IPv4 multiple times. The concrete example below shows what
would happen under the IPv4 case.
@example
@group
UUID: 7726a678-7fc0-4853-a4f6-c85ac36a120a
MAC: 52:54:00:ec:33:81
IPV4: 10.0.0.130 (0A000082)
@end group
@end example
@example
@group
@samp{(FWPATH)}/grub.cfg-7726a678-7fc0-4853-a4f6-c85ac36a120a
@samp{(FWPATH)}/grub.cfg-52-54-00-ec-33-81
@samp{(FWPATH)}/grub.cfg-0A000082
@samp{(FWPATH)}/grub.cfg-0A00008
@samp{(FWPATH)}/grub.cfg-0A0000
@samp{(FWPATH)}/grub.cfg-0A000
@samp{(FWPATH)}/grub.cfg-0A00
@samp{(FWPATH)}/grub.cfg-0A0
@samp{(FWPATH)}/grub.cfg-0A
@samp{(FWPATH)}/grub.cfg-0
@samp{(FWPATH)}/grub.cfg
@end group
@end example
This feature is enabled by default but it can be disabled by setting the
@samp{feature_net_search_cfg} to @samp{n}. Since this happens before the
configuration file is read by GRUB, this option has to be disabled in an
embedded configuration file (@pxref{Embedded configuration}).
After GRUB has started, files on the TFTP server will be accessible via the After GRUB has started, files on the TFTP server will be accessible via the
@samp{(tftp)} device. @samp{(tftp)} device.
@ -3930,7 +4005,6 @@ you forget a command, you can run the command @command{help}
* password_pbkdf2:: Set a hashed password * password_pbkdf2:: Set a hashed password
* play:: Play a tune * play:: Play a tune
* probe:: Retrieve device info * probe:: Retrieve device info
* pxe_unload:: Unload the PXE environment
* rdmsr:: Read values from model-specific registers * rdmsr:: Read values from model-specific registers
* read:: Read user input * read:: Read user input
* reboot:: Reboot your computer * reboot:: Reboot your computer
@ -3950,7 +4024,6 @@ you forget a command, you can run the command @command{help}
* true:: Do nothing, successfully * true:: Do nothing, successfully
* trust:: Add public key to list of trusted keys * trust:: Add public key to list of trusted keys
* unset:: Unset an environment variable * unset:: Unset an environment variable
* uppermem:: Set the upper memory size
@comment * vbeinfo:: List available video modes @comment * vbeinfo:: List available video modes
* verify_detached:: Verify detached digital signature * verify_detached:: Verify detached digital signature
* videoinfo:: List available video modes * videoinfo:: List available video modes
@ -4202,8 +4275,9 @@ is requested interactively. Option @var{device} configures specific grub device
with specified @var{uuid}; option @option{-a} configures all detected encrypted with specified @var{uuid}; option @option{-a} configures all detected encrypted
devices; option @option{-b} configures all geli containers that have boot flag set. devices; option @option{-b} configures all geli containers that have boot flag set.
GRUB suports devices encrypted using LUKS and geli. Note that necessary modules (@var{luks} and @var{geli}) have to be loaded manually before this command can GRUB suports devices encrypted using LUKS, LUKS2 and geli. Note that necessary
be used. modules (@var{luks}, @var{luks2} and @var{geli}) have to be loaded manually
before this command can be used.
@end deffn @end deffn
@ -4221,13 +4295,12 @@ hour, minute, and second unchanged.
@node devicetree @node devicetree
@subsection linux @subsection devicetree
@deffn Command devicetree file @deffn Command devicetree file
Load a device tree blob (.dtb) from a filesystem, for later use by a Linux Load a device tree blob (.dtb) from a filesystem, for later use by a Linux
kernel. Does not perform merging with any device tree supplied by firmware, kernel. Does not perform merging with any device tree supplied by firmware,
but rather replaces it completely. but rather replaces it completely.
@ref{GNU/Linux}.
@end deffn @end deffn
@node distrust @node distrust
@ -4424,22 +4497,22 @@ about each of the commands whose names begin with those @var{patterns}.
@node initrd @node initrd
@subsection initrd @subsection initrd
@deffn Command initrd file @deffn Command initrd file [file @dots{}]
Load an initial ramdisk for a Linux kernel image, and set the appropriate Load, in order, all initial ramdisks for a Linux kernel image, and set
parameters in the Linux setup area in memory. This may only be used after the appropriate parameters in the Linux setup area in memory. This may only
the @command{linux} command (@pxref{linux}) has been run. See also be used after the @command{linux} command (@pxref{linux}) has been run. See
@ref{GNU/Linux}. also @ref{GNU/Linux}.
@end deffn @end deffn
@node initrd16 @node initrd16
@subsection initrd16 @subsection initrd16
@deffn Command initrd16 file @deffn Command initrd16 file [file @dots{}]
Load an initial ramdisk for a Linux kernel image to be booted in 16-bit Load, in order, all initial ramdisks for a Linux kernel image to be booted in
mode, and set the appropriate parameters in the Linux setup area in memory. 16-bit mode, and set the appropriate parameters in the Linux setup area in
This may only be used after the @command{linux16} command (@pxref{linux16}) memory. This may only be used after the @command{linux16} command
has been run. See also @ref{GNU/Linux}. (@pxref{linux16}) has been run. See also @ref{GNU/Linux}.
This command is only available on x86 systems. This command is only available on x86 systems.
@end deffn @end deffn
@ -4647,7 +4720,7 @@ be reloaded after using this command (@pxref{module}).
Some kernels have known problems. You need to specify --quirk-* for those. Some kernels have known problems. You need to specify --quirk-* for those.
--quirk-bad-kludge is a problem seen in several products that they include --quirk-bad-kludge is a problem seen in several products that they include
loading kludge information with invalid data in ELF file. GRUB prior to 0.97 loading kludge information with invalid data in ELF file. GRUB prior to 0.97
and some custom builds prefered ELF information while 0.97 and GRUB 2 and some custom builds preferred ELF information while 0.97 and GRUB 2
use kludge. Use this option to ignore kludge. use kludge. Use this option to ignore kludge.
Known affected systems: old Solaris, SkyOS. Known affected systems: old Solaris, SkyOS.
@ -4772,19 +4845,11 @@ a rest.
@node probe @node probe
@subsection probe @subsection probe
@deffn Command probe [@option{--set} var] @option{--driver}|@option{--partmap}|@option{--fs}|@option{--fs-uuid}|@option{--label} device @deffn Command probe [@option{--set} var] @option{--driver}|@option{--partmap}|@option{--fs}|@option{--fs-uuid}|@option{--label}|@option{--part-uuid} device
Retrieve device information. If option @option{--set} is given, assign result Retrieve device information. If option @option{--set} is given, assign result
to variable @var{var}, otherwise print information on the screen. to variable @var{var}, otherwise print information on the screen.
@end deffn
The option @option{--part-uuid} is currently only implemented for MSDOS and GPT formatted disks.
@node pxe_unload
@subsection pxe_unload
@deffn Command pxe_unload
Unload the PXE environment (@pxref{Network}).
This command is only available on PC BIOS systems.
@end deffn @end deffn
@ -5078,9 +5143,10 @@ Alias for @code{hashsum --hash sha512 arg @dots{}}. See command @command{hashsum
@deffn Command sleep [@option{--verbose}] [@option{--interruptible}] count @deffn Command sleep [@option{--verbose}] [@option{--interruptible}] count
Sleep for @var{count} seconds. If option @option{--interruptible} is given, Sleep for @var{count} seconds. If option @option{--interruptible} is given,
allow @key{ESC} to interrupt sleep. With @option{--verbose} show countdown allow pressing @key{ESC}, @key{F4} or holding down @key{SHIFT} to interrupt
of remaining seconds. Exit code is set to 0 if timeout expired and to 1 sleep. With @option{--verbose} show countdown of remaining seconds. Exit code
if timeout was interrupted by @key{ESC}. is set to 0 if timeout expired and to 1 if timeout was interrupted using any
of the mentioned keys.
@end deffn @end deffn
@ -5122,21 +5188,27 @@ return. Only one of these options may be specified at a time.
@item @item
When given @option{--get-byte}, return the value of the byte When given @option{--get-byte}, return the value of the byte
at @var{offset} bytes into the selected SMBIOS structure. at @var{offset} bytes into the selected SMBIOS structure.
It will be formatted as an unsigned decimal integer.
@item @item
When given @option{--get-word}, return the value of the word (two bytes) When given @option{--get-word}, return the value of the word (two bytes)
at @var{offset} bytes into the selected SMBIOS structure. at @var{offset} bytes into the selected SMBIOS structure.
It will be formatted as an unsigned decimal integer.
@item @item
When given @option{--get-dword}, return the value of the dword (four bytes) When given @option{--get-dword}, return the value of the dword (four bytes)
at @var{offset} bytes into the selected SMBIOS structure. at @var{offset} bytes into the selected SMBIOS structure.
It will be formatted as an unsigned decimal integer.
@item @item
When given @option{--get-qword}, return the value of the qword (eight bytes) When given @option{--get-qword}, return the value of the qword (eight bytes)
at @var{offset} bytes into the selected SMBIOS structure. at @var{offset} bytes into the selected SMBIOS structure.
It will be formatted as an unsigned decimal integer.
@item @item
When given @option{--get-string}, return the string with its index found When given @option{--get-string}, return the string with its index found
at @var{offset} bytes into the selected SMBIOS structure. at @var{offset} bytes into the selected SMBIOS structure.
@item @item
When given @option{--get-uuid}, return the value of the UUID (sixteen bytes) When given @option{--get-uuid}, return the value of the UUID (sixteen bytes)
at @var{offset} bytes into the selected SMBIOS structure. at @var{offset} bytes into the selected SMBIOS structure.
It will be formatted as lower-case hyphenated hexadecimal digits, with the
first three fields as little-endian, and the rest printed byte-by-byte.
@end itemize @end itemize
The default action is to print the value of the requested field to the console, The default action is to print the value of the requested field to the console,
@ -5268,12 +5340,6 @@ Unset the environment variable @var{envvar}.
@end deffn @end deffn
@node uppermem
@subsection uppermem
This command is not yet implemented for GRUB 2, although it is planned.
@ignore @ignore
@node vbeinfo @node vbeinfo
@subsection vbeinfo @subsection vbeinfo
@ -5357,10 +5423,11 @@ This command is only available on AArch64 systems.
* net_add_addr:: Add a network address * net_add_addr:: Add a network address
* net_add_dns:: Add a DNS server * net_add_dns:: Add a DNS server
* net_add_route:: Add routing entry * net_add_route:: Add routing entry
* net_bootp:: Perform a bootp autoconfiguration * net_bootp:: Perform a bootp/DHCP autoconfiguration
* net_del_addr:: Remove IP address from interface * net_del_addr:: Remove IP address from interface
* net_del_dns:: Remove a DNS server * net_del_dns:: Remove a DNS server
* net_del_route:: Remove a route entry * net_del_route:: Remove a route entry
* net_dhcp:: Perform a DHCP autoconfiguration
* net_get_dhcp_option:: Retrieve DHCP options * net_get_dhcp_option:: Retrieve DHCP options
* net_ipv6_autoconf:: Perform IPv6 autoconfiguration * net_ipv6_autoconf:: Perform IPv6 autoconfiguration
* net_ls_addr:: List interfaces * net_ls_addr:: List interfaces
@ -5407,8 +5474,44 @@ by @var{shortname} which can be used to remove it (@pxref{net_del_route}).
@subsection net_bootp @subsection net_bootp
@deffn Command net_bootp [@var{card}] @deffn Command net_bootp [@var{card}]
Alias for net_dhcp, for compatibility with older Grub versions. Will perform
the same DHCP handshake with potential fallback to BOOTP as the net_dhcp
command (@pxref{net_dhcp}).
@end deffn
@node net_del_addr
@subsection net_del_addr
@deffn Command net_del_addr @var{interface}
Remove configured @var{interface} with associated address.
@end deffn
@node net_del_dns
@subsection net_del_dns
@deffn Command net_del_dns @var{address}
Remove @var{address} from list of servers used during name lookup.
@end deffn
@node net_del_route
@subsection net_del_route
@deffn Command net_del_route @var{shortname}
Remove route entry identified by @var{shortname}.
@end deffn
@node net_dhcp
@subsection net_dhcp
@deffn Command net_dhcp [@var{card}]
Perform configuration of @var{card} using DHCP protocol. If no card name Perform configuration of @var{card} using DHCP protocol. If no card name
is specified, try to configure all existing cards. If configuration was is specified, try to configure all existing cards.
Falls back to the BOOTP protocol, if needed. If configuration was
successful, interface with name @var{card}@samp{:dhcp} and configured successful, interface with name @var{card}@samp{:dhcp} and configured
address is added to @var{card}. address is added to @var{card}.
@comment If server provided gateway information in @comment If server provided gateway information in
@ -5435,35 +5538,17 @@ Sets environment variable @samp{net_}@var{<card>}@samp{_dhcp_rootpath}
@item 18 (Extensions Path) @item 18 (Extensions Path)
Sets environment variable @samp{net_}@var{<card>}@samp{_dhcp_extensionspath} Sets environment variable @samp{net_}@var{<card>}@samp{_dhcp_extensionspath}
(@pxref{net_@var{<interface>}_extensionspath}) to the value of option. (@pxref{net_@var{<interface>}_extensionspath}) to the value of option.
@item 66 (TFTP Server Name)
Sets environment variable @samp{net_}@var{<card>}@samp{_dhcp_server_name}
(@pxref{net_@var{<interface>}_dhcp_server_name}) to the value of option.
@item 67 (Filename)
Sets environment variable @samp{net_}@var{<card>}@samp{_boot_file}
(@pxref{net_@var{<interface>}_boot_file}) to the value of option.
@end table @end table
@end deffn @end deffn
@node net_del_addr
@subsection net_del_addr
@deffn Command net_del_addr @var{interface}
Remove configured @var{interface} with associated address.
@end deffn
@node net_del_dns
@subsection net_del_dns
@deffn Command net_del_dns @var{address}
Remove @var{address} from list of servers used during name lookup.
@end deffn
@node net_del_route
@subsection net_del_route
@deffn Command net_del_route @var{shortname}
Remove route entry identified by @var{shortname}.
@end deffn
@node net_get_dhcp_option @node net_get_dhcp_option
@subsection net_get_dhcp_option @subsection net_get_dhcp_option
@ -5681,7 +5766,8 @@ the GRUB command line, edit menu entries, and execute any menu entry. If
@samp{superusers} is set, then use of the command line and editing of menu @samp{superusers} is set, then use of the command line and editing of menu
entries are automatically restricted to superusers. Setting @samp{superusers} entries are automatically restricted to superusers. Setting @samp{superusers}
to empty string effectively disables both access to CLI and editing of menu to empty string effectively disables both access to CLI and editing of menu
entries. entries. Note: The environment variable needs to be exported to also affect
the section defined by the @samp{submenu} command (@pxref{submenu}).
Other users may be allowed to execute specific menu entries by giving a list of Other users may be allowed to execute specific menu entries by giving a list of
usernames (as above) using the @option{--users} option to the usernames (as above) using the @option{--users} option to the

2
gentpl.py
View file

@ -766,7 +766,7 @@ def image(defn, platform):
if test x$(TARGET_APPLE_LINKER) = x1; then \ if test x$(TARGET_APPLE_LINKER) = x1; then \
$(MACHO2IMG) $< $@; \ $(MACHO2IMG) $< $@; \
else \ else \
$(TARGET_OBJCOPY) $(""" + cname(defn) + """_OBJCOPYFLAGS) --strip-unneeded -R .note -R .comment -R .note.gnu.build-id -R .MIPS.abiflags -R .reginfo -R .rel.dyn -R .note.gnu.gold-version -R .ARM.exidx $< $@; \ $(TARGET_OBJCOPY) $(""" + cname(defn) + """_OBJCOPYFLAGS) --strip-unneeded -R .note -R .comment -R .note.gnu.build-id -R .MIPS.abiflags -R .reginfo -R .rel.dyn -R .note.gnu.gold-version -R .note.gnu.property -R .ARM.exidx $< $@; \
fi fi
""") """)

1
grub-core/Makefile.am
View file

@ -92,7 +92,6 @@ KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/term.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/time.h KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/time.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/mm_private.h KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/mm_private.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/net.h KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/net.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/tpm.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/memory.h KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/memory.h
if COND_i386_pc if COND_i386_pc

78
grub-core/Makefile.core.def
View file

@ -140,7 +140,6 @@ kernel = {
common = kern/rescue_parser.c; common = kern/rescue_parser.c;
common = kern/rescue_reader.c; common = kern/rescue_reader.c;
common = kern/term.c; common = kern/term.c;
common = kern/tpm.c;
noemu = kern/compiler-rt.c; noemu = kern/compiler-rt.c;
noemu = kern/mm.c; noemu = kern/mm.c;
@ -204,7 +203,6 @@ kernel = {
efi = term/efi/console.c; efi = term/efi/console.c;
efi = kern/acpi.c; efi = kern/acpi.c;
efi = kern/efi/acpi.c; efi = kern/efi/acpi.c;
efi = kern/efi/tpm.c;
i386_coreboot = kern/i386/pc/acpi.c; i386_coreboot = kern/i386/pc/acpi.c;
i386_multiboot = kern/i386/pc/acpi.c; i386_multiboot = kern/i386/pc/acpi.c;
i386_coreboot = kern/acpi.c; i386_coreboot = kern/acpi.c;
@ -264,7 +262,6 @@ kernel = {
i386_pc = kern/i386/pc/init.c; i386_pc = kern/i386/pc/init.c;
i386_pc = kern/i386/pc/mmap.c; i386_pc = kern/i386/pc/mmap.c;
i386_pc = kern/i386/pc/tpm.c;
i386_pc = term/i386/pc/console.c; i386_pc = term/i386/pc/console.c;
i386_qemu = bus/pci.c; i386_qemu = bus/pci.c;
@ -891,32 +888,11 @@ module = {
enable = x86_64_efi; enable = x86_64_efi;
}; };
module = {
name = getenv;
common = commands/efi/getenv.c;
enable = efi;
};
module = { module = {
name = gptsync; name = gptsync;
common = commands/gptsync.c; common = commands/gptsync.c;
}; };
module = {
name = gptrepair;
common = commands/gptrepair.c;
};
module = {
name = gptprio;
common = commands/gptprio.c;
};
module = {
name = gpt;
common = lib/gpt.c;
};
module = { module = {
name = halt; name = halt;
nopc = commands/halt.c; nopc = commands/halt.c;
@ -974,7 +950,7 @@ module = {
module = { module = {
name = shim_lock; name = shim_lock;
common = commands/efi/shim_lock.c; common = commands/efi/shim_lock.c;
enable = x86_64_efi; enable = efi;
}; };
module = { module = {
@ -1104,21 +1080,6 @@ module = {
common = commands/search_label.c; common = commands/search_label.c;
}; };
module = {
name = search_part_uuid;
common = commands/search_part_uuid.c;
};
module = {
name = search_part_label;
common = commands/search_part_label.c;
};
module = {
name = search_disk_uuid;
common = commands/search_disk_uuid.c;
};
module = { module = {
name = setpci; name = setpci;
common = commands/setpci.c; common = commands/setpci.c;
@ -1215,10 +1176,27 @@ module = {
common = disk/cryptodisk.c; common = disk/cryptodisk.c;
}; };
module = {
name = json;
common = lib/json/json.c;
};
module = {
name = afsplitter;
common = disk/AFSplitter.c;
};
module = { module = {
name = luks; name = luks;
common = disk/luks.c; common = disk/luks.c;
common = disk/AFSplitter.c; };
module = {
name = luks2;
common = disk/luks2.c;
common = lib/gnulib/base64.c;
cflags = '$(CFLAGS_POSIX) $(CFLAGS_GNULIB)';
cppflags = '$(CPPFLAGS_POSIX) $(CPPFLAGS_GNULIB) -I$(srcdir)/lib/json';
}; };
module = { module = {
@ -1709,6 +1687,7 @@ module = {
module = { module = {
name = datetime; name = datetime;
common = lib/datetime.c;
cmos = lib/cmos_datetime.c; cmos = lib/cmos_datetime.c;
efi = lib/efi/datetime.c; efi = lib/efi/datetime.c;
uboot = lib/dummy/datetime.c; uboot = lib/dummy/datetime.c;
@ -1721,7 +1700,6 @@ module = {
i386_xen_pvh = lib/xen/datetime.c; i386_xen_pvh = lib/xen/datetime.c;
mips_arc = lib/arc/datetime.c; mips_arc = lib/arc/datetime.c;
enable = noemu;
}; };
module = { module = {
@ -1903,14 +1881,6 @@ module = {
enable = x86_64_efi; enable = x86_64_efi;
}; };
module = {
name = linuxefi;
efi = loader/i386/efi/linux.c;
efi = lib/cmdline.c;
enable = i386_efi;
enable = x86_64_efi;
};
module = { module = {
name = chain; name = chain;
efi = loader/efi/chainloader.c; efi = loader/efi/chainloader.c;
@ -1956,7 +1926,6 @@ module = {
common = normal/autofs.c; common = normal/autofs.c;
common = normal/color.c; common = normal/color.c;
common = normal/completion.c; common = normal/completion.c;
common = normal/datetime.c;
common = normal/menu.c; common = normal/menu.c;
common = normal/menu_entry.c; common = normal/menu_entry.c;
common = normal/menu_text.c; common = normal/menu_text.c;
@ -2531,7 +2500,7 @@ module = {
name = tpm; name = tpm;
common = commands/tpm.c; common = commands/tpm.c;
efi = commands/efi/tpm.c; efi = commands/efi/tpm.c;
enable = x86_64_efi; enable = efi;
}; };
module = { module = {
@ -2565,8 +2534,3 @@ module = {
common = commands/i386/wrmsr.c; common = commands/i386/wrmsr.c;
enable = x86; enable = x86;
}; };
module = {
name = fwconfig;
common = commands/fwconfig.c;
enable = x86;
};

30
grub-core/boot/i386/pc/boot.S
View file

@ -24,14 +24,11 @@
* defines for the code go here * defines for the code go here
*/ */
#define TPM 1
/* Print message string */ /* Print message string */
#define MSG(x) movw $x, %si; call LOCAL(message) #define MSG(x) movw $x, %si; call LOCAL(message)
#define ERR(x) movw $x, %si; jmp LOCAL(error_message) #define ERR(x) movw $x, %si; jmp LOCAL(error_message)
.macro floppy .macro floppy
#ifndef TPM
part_start: part_start:
LOCAL(probe_values): LOCAL(probe_values):
@ -88,7 +85,6 @@ fd_probe_error_string: .asciz "Floppy"
movb MACRO_DOLLAR(79), %ch movb MACRO_DOLLAR(79), %ch
jmp LOCAL(final_init) jmp LOCAL(final_init)
#endif
.endm .endm
.macro scratch .macro scratch
@ -259,7 +255,6 @@ real_start:
/* set %si to the disk address packet */ /* set %si to the disk address packet */
movw $disk_address_packet, %si movw $disk_address_packet, %si
#ifndef TPM
/* check if LBA is supported */ /* check if LBA is supported */
movb $0x41, %ah movb $0x41, %ah
movw $0x55aa, %bx movw $0x55aa, %bx
@ -279,7 +274,6 @@ real_start:
andw $1, %cx andw $1, %cx
jz LOCAL(chs_mode) jz LOCAL(chs_mode)
#endif
LOCAL(lba_mode): LOCAL(lba_mode):
xorw %ax, %ax xorw %ax, %ax
@ -323,9 +317,6 @@ LOCAL(lba_mode):
jmp LOCAL(copy_buffer) jmp LOCAL(copy_buffer)
LOCAL(chs_mode): LOCAL(chs_mode):
#ifdef TPM
jmp LOCAL(general_error)
#else
/* /*
* Determine the hard disk geometry from the BIOS! * Determine the hard disk geometry from the BIOS!
* We do this first, so that LS-120 IDE floppies work correctly. * We do this first, so that LS-120 IDE floppies work correctly.
@ -437,7 +428,7 @@ setup_sectors:
jc LOCAL(read_error) jc LOCAL(read_error)
movw %es, %bx movw %es, %bx
#endif /* TPM */
LOCAL(copy_buffer): LOCAL(copy_buffer):
/* /*
* We need to save %cx and %si because the startup code in * We need to save %cx and %si because the startup code in
@ -460,25 +451,6 @@ LOCAL(copy_buffer):
popw %ds popw %ds
popa popa
#ifdef TPM
pusha
movw $0xBB00, %ax /* TCG_StatusCheck */
int $0x1A
test %eax, %eax
jnz boot /* No TPM or TPM deactivated */
movw $0xBB07, %ax /* TCG_CompactHashLogExtendEvent */
movw $GRUB_BOOT_MACHINE_KERNEL_ADDR, %di
xorl %esi, %esi
movl $0x41504354, %ebx /* TCPA */
movl $0x200, %ecx /* Measure 512 bytes */
movl $0x8, %edx /* PCR 8 */
int $0x1A
boot:
popa
#endif
/* boot kernel */ /* boot kernel */
jmp *(LOCAL(kernel_address)) jmp *(LOCAL(kernel_address))

44
grub-core/boot/i386/pc/diskboot.S
View file

@ -19,8 +19,6 @@
#include <grub/symbol.h> #include <grub/symbol.h>
#include <grub/machine/boot.h> #include <grub/machine/boot.h>
#define TPM 1
/* /*
* defines for the code go here * defines for the code go here
*/ */
@ -60,21 +58,6 @@ _start:
/* this sets up for the first run through "bootloop" */ /* this sets up for the first run through "bootloop" */
movw $LOCAL(firstlist), %di movw $LOCAL(firstlist), %di
#ifdef TPM
/* clear EAX to remove potential garbage */
xorl %eax, %eax
/* 8(%di) = number of sectors to read */
movw 8(%di), %ax
/* Multiply number of sectors to read with 512 bytes. EAX is 32bit
* which is large enough to hold values of up to 4GB. I doubt there
* will ever be a core.img larger than that. ;-) */
shll $9, %eax
/* write result to bytes_to_measure var */
movl %eax, bytes_to_measure
#endif
/* save the sector number of the second sector in %ebp */ /* save the sector number of the second sector in %ebp */
movl (%di), %ebp movl (%di), %ebp
@ -312,29 +295,6 @@ LOCAL(copy_buffer):
/* END OF MAIN LOOP */ /* END OF MAIN LOOP */
LOCAL(bootit): LOCAL(bootit):
#ifdef TPM
pusha
movw $0xBB07, %ax /* TCG_CompactHashLogExtendEvent */
movw $0x0, %bx
movw %bx, %es
/* We've already measured the first 512 bytes, now measure the rest */
xorl %edi, %edi
movw $(GRUB_BOOT_MACHINE_KERNEL_ADDR + 0x200), %di
movl $0x41504354, %ebx /* EBX = "TCPA" */
/* %ecx = The length, in bytes, of the buffer to measure */
movl $bytes_to_measure, %esi
movl (%esi), %ecx
xorl %esi, %esi
movl $0x9, %edx /* PCR 9 */
int $0x1A
popa
#endif
/* print a newline */ /* print a newline */
MSG(notification_done) MSG(notification_done)
popw %dx /* this makes sure %dl is our "boot" drive */ popw %dx /* this makes sure %dl is our "boot" drive */
@ -369,10 +329,6 @@ geometry_error_string: .asciz "Geom"
read_error_string: .asciz "Read" read_error_string: .asciz "Read"
general_error_string: .asciz " Error" general_error_string: .asciz " Error"
#ifdef TPM
bytes_to_measure: .long 0
#endif
/* /*
* message: write the string pointed to by %si * message: write the string pointed to by %si
* *

8
grub-core/bus/usb/usbhub.c
View file

@ -149,8 +149,8 @@ grub_usb_add_hub (grub_usb_device_t dev)
grub_usb_set_configuration (dev, 1); grub_usb_set_configuration (dev, 1);
dev->nports = hubdesc.portcnt; dev->nports = hubdesc.portcnt;
dev->children = grub_zalloc (hubdesc.portcnt * sizeof (dev->children[0])); dev->children = grub_calloc (hubdesc.portcnt, sizeof (dev->children[0]));
dev->ports = grub_zalloc (dev->nports * sizeof (dev->ports[0])); dev->ports = grub_calloc (dev->nports, sizeof (dev->ports[0]));
if (!dev->children || !dev->ports) if (!dev->children || !dev->ports)
{ {
grub_free (dev->children); grub_free (dev->children);
@ -268,8 +268,8 @@ grub_usb_controller_dev_register_iter (grub_usb_controller_t controller, void *d
/* Query the number of ports the root Hub has. */ /* Query the number of ports the root Hub has. */
hub->nports = controller->dev->hubports (controller); hub->nports = controller->dev->hubports (controller);
hub->devices = grub_zalloc (sizeof (hub->devices[0]) * hub->nports); hub->devices = grub_calloc (hub->nports, sizeof (hub->devices[0]));
hub->ports = grub_zalloc (sizeof (hub->ports[0]) * hub->nports); hub->ports = grub_calloc (hub->nports, sizeof (hub->ports[0]));
if (!hub->devices || !hub->ports) if (!hub->devices || !hub->ports)
{ {
grub_free (hub->devices); grub_free (hub->devices);

3
grub-core/commands/date.c
View file

@ -59,7 +59,8 @@ grub_cmd_date (grub_command_t cmd __attribute__ ((unused)),
for (; argc; argc--, args++) for (; argc; argc--, args++)
{ {
char *p, c; const char *p;
char c;
int m1, ofs, n, cur_mask; int m1, ofs, n, cur_mask;
p = args[0]; p = args[0];

153
grub-core/commands/efi/getenv.c
View file

@ -1,153 +0,0 @@
/* getenv.c - retrieve EFI variables. */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2009 Free Software Foundation, Inc.
* Copyright (C) 2014 CoreOS, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/efi/efi.h>
#include <grub/dl.h>
#include <grub/env.h>
#include <grub/err.h>
#include <grub/extcmd.h>
#include <grub/i18n.h>
#include <grub/misc.h>
#include <grub/mm.h>
GRUB_MOD_LICENSE ("GPLv3+");
static const struct grub_arg_option options_getenv[] = {
{"var-name", 'e', 0,
N_("Environment variable to query"),
N_("VARNAME"), ARG_TYPE_STRING},
{"var-guid", 'g', 0,
N_("GUID of environment variable to query"),
N_("GUID"), ARG_TYPE_STRING},
{"binary", 'b', 0,
N_("Read binary data and represent it as hex"),
0, ARG_TYPE_NONE},
{0, 0, 0, 0, 0, 0}
};
enum options_getenv
{
GETENV_VAR_NAME,
GETENV_VAR_GUID,
GETENV_BINARY,
};
static grub_err_t
grub_cmd_getenv (grub_extcmd_context_t ctxt, int argc, char **args)
{
struct grub_arg_list *state = ctxt->state;
char *envvar = NULL, *guid = NULL, *bindata = NULL, *data = NULL;
grub_size_t datasize;
grub_efi_guid_t efi_var_guid;
grub_efi_boolean_t binary = state[GETENV_BINARY].set;
unsigned int i;
if (!state[GETENV_VAR_NAME].set || !state[GETENV_VAR_GUID].set)
{
grub_error (GRUB_ERR_INVALID_COMMAND, N_("-e and -g are required"));
goto done;
}
if (argc != 1)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("unexpected arguments"));
goto done;
}
envvar = state[GETENV_VAR_NAME].arg;
guid = state[GETENV_VAR_GUID].arg;
if (grub_strlen(guid) != 36 ||
guid[8] != '-' ||
guid[13] != '-' ||
guid[18] != '-' ||
guid[23] != '-')
{
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid GUID"));
goto done;
}
/* Forgive me father for I have sinned */
guid[8] = 0;
efi_var_guid.data1 = grub_strtoul(guid, NULL, 16);
guid[13] = 0;
efi_var_guid.data2 = grub_strtoul(guid + 9, NULL, 16);
guid[18] = 0;
efi_var_guid.data3 = grub_strtoul(guid + 14, NULL, 16);
efi_var_guid.data4[7] = grub_strtoul(guid + 34, NULL, 16);
guid[34] = 0;
efi_var_guid.data4[6] = grub_strtoul(guid + 32, NULL, 16);
guid[32] = 0;
efi_var_guid.data4[5] = grub_strtoul(guid + 30, NULL, 16);
guid[30] = 0;
efi_var_guid.data4[4] = grub_strtoul(guid + 28, NULL, 16);
guid[28] = 0;
efi_var_guid.data4[3] = grub_strtoul(guid + 26, NULL, 16);
guid[26] = 0;
efi_var_guid.data4[2] = grub_strtoul(guid + 24, NULL, 16);
guid[23] = 0;
efi_var_guid.data4[1] = grub_strtoul(guid + 21, NULL, 16);
guid[21] = 0;
efi_var_guid.data4[0] = grub_strtoul(guid + 19, NULL, 16);
data = grub_efi_get_variable(envvar, &efi_var_guid, &datasize);
if (!data || !datasize)
{
grub_error (GRUB_ERR_FILE_NOT_FOUND, N_("No such variable"));
goto done;
}
if (binary)
{
bindata = grub_zalloc(datasize * 2 + 1);
for (i=0; i<datasize; i++)
grub_snprintf(bindata + i*2, 3, "%02x", data[i] & 0xff);
if (grub_env_set (args[0], bindata))
goto done;
}
else if (grub_env_set (args[0], data))
{
goto done;
}
grub_errno = GRUB_ERR_NONE;
done:
grub_free(bindata);
grub_free(data);
return grub_errno;
}
static grub_extcmd_t cmd_getenv;
GRUB_MOD_INIT(getenv)
{
cmd_getenv = grub_register_extcmd ("getenv", grub_cmd_getenv, 0,
N_("-e envvar -g guidenv setvar"),
N_("Read a firmware environment variable"),
options_getenv);
}
GRUB_MOD_FINI(getenv)
{
grub_unregister_extcmd (cmd_getenv);
}

18
grub-core/commands/efi/loadbios.c
View file

@ -30,7 +30,6 @@ GRUB_MOD_LICENSE ("GPLv3+");
static grub_efi_guid_t acpi_guid = GRUB_EFI_ACPI_TABLE_GUID; static grub_efi_guid_t acpi_guid = GRUB_EFI_ACPI_TABLE_GUID;
static grub_efi_guid_t acpi2_guid = GRUB_EFI_ACPI_20_TABLE_GUID; static grub_efi_guid_t acpi2_guid = GRUB_EFI_ACPI_20_TABLE_GUID;
static grub_efi_guid_t smbios_guid = GRUB_EFI_SMBIOS_TABLE_GUID; static grub_efi_guid_t smbios_guid = GRUB_EFI_SMBIOS_TABLE_GUID;
static grub_efi_guid_t smbios3_guid = GRUB_EFI_SMBIOS3_TABLE_GUID;
#define EBDA_SEG_ADDR 0x40e #define EBDA_SEG_ADDR 0x40e
#define LOW_MEM_ADDR 0x413 #define LOW_MEM_ADDR 0x413
@ -94,7 +93,7 @@ static void
fake_bios_data (int use_rom) fake_bios_data (int use_rom)
{ {
unsigned i; unsigned i;
void *acpi, *smbios, *smbios3; void *acpi, *smbios;
grub_uint16_t *ebda_seg_ptr, *low_mem_ptr; grub_uint16_t *ebda_seg_ptr, *low_mem_ptr;
ebda_seg_ptr = (grub_uint16_t *) EBDA_SEG_ADDR; ebda_seg_ptr = (grub_uint16_t *) EBDA_SEG_ADDR;
@ -104,7 +103,6 @@ fake_bios_data (int use_rom)
acpi = 0; acpi = 0;
smbios = 0; smbios = 0;
smbios3 = 0;
for (i = 0; i < grub_efi_system_table->num_table_entries; i++) for (i = 0; i < grub_efi_system_table->num_table_entries; i++)
{ {
grub_efi_packed_guid_t *guid = grub_efi_packed_guid_t *guid =
@ -129,11 +127,6 @@ fake_bios_data (int use_rom)
smbios = grub_efi_system_table->configuration_table[i].vendor_table; smbios = grub_efi_system_table->configuration_table[i].vendor_table;
grub_dprintf ("efi", "SMBIOS: %p\n", smbios); grub_dprintf ("efi", "SMBIOS: %p\n", smbios);
} }
else if (! grub_memcmp (guid, &smbios3_guid, sizeof (grub_efi_guid_t)))
{
smbios3 = grub_efi_system_table->configuration_table[i].vendor_table;
grub_dprintf ("efi", "SMBIOS3: %p\n", smbios3);
}
} }
*ebda_seg_ptr = FAKE_EBDA_SEG; *ebda_seg_ptr = FAKE_EBDA_SEG;
@ -144,13 +137,8 @@ fake_bios_data (int use_rom)
if (acpi) if (acpi)
grub_memcpy ((char *) ((FAKE_EBDA_SEG << 4) + 16), acpi, 1024 - 16); grub_memcpy ((char *) ((FAKE_EBDA_SEG << 4) + 16), acpi, 1024 - 16);
if (use_rom) if ((use_rom) && (smbios))
{ grub_memcpy ((char *) SBIOS_ADDR, (char *) smbios + 16, 16);
if (smbios)
grub_memcpy ((char *) SBIOS_ADDR, (char *) smbios, 31);
if (smbios3)
grub_memcpy ((char *) SBIOS_ADDR + 32, (char *) smbios3, 24);
}
} }
static grub_err_t static grub_err_t

4
grub-core/commands/efi/lsefisystab.c
View file

@ -40,6 +40,7 @@ static const struct guid_mapping guid_mappings[] =
{ GRUB_EFI_CRC32_GUIDED_SECTION_EXTRACTION_GUID, { GRUB_EFI_CRC32_GUIDED_SECTION_EXTRACTION_GUID,
"CRC32 GUIDED SECTION EXTRACTION"}, "CRC32 GUIDED SECTION EXTRACTION"},
{ GRUB_EFI_DEBUG_IMAGE_INFO_TABLE_GUID, "DEBUG IMAGE INFO"}, { GRUB_EFI_DEBUG_IMAGE_INFO_TABLE_GUID, "DEBUG IMAGE INFO"},
{ GRUB_EFI_DEVICE_TREE_GUID, "DEVICE TREE"},
{ GRUB_EFI_DXE_SERVICES_TABLE_GUID, "DXE SERVICES"}, { GRUB_EFI_DXE_SERVICES_TABLE_GUID, "DXE SERVICES"},
{ GRUB_EFI_HCDP_TABLE_GUID, "HCDP"}, { GRUB_EFI_HCDP_TABLE_GUID, "HCDP"},
{ GRUB_EFI_HOB_LIST_GUID, "HOB LIST"}, { GRUB_EFI_HOB_LIST_GUID, "HOB LIST"},
@ -72,7 +73,8 @@ grub_cmd_lsefisystab (struct grub_command *cmd __attribute__ ((unused)),
grub_printf ("Vendor: "); grub_printf ("Vendor: ");
for (vendor_utf16 = st->firmware_vendor; *vendor_utf16; vendor_utf16++); for (vendor_utf16 = st->firmware_vendor; *vendor_utf16; vendor_utf16++);
vendor = grub_malloc (4 * (vendor_utf16 - st->firmware_vendor) + 1); /* Allocate extra 3 bytes to simplify math. */
vendor = grub_calloc (4, vendor_utf16 - st->firmware_vendor + 1);
if (!vendor) if (!vendor)
return grub_errno; return grub_errno;
*grub_utf16_to_utf8 ((grub_uint8_t *) vendor, st->firmware_vendor, *grub_utf16_to_utf8 ((grub_uint8_t *) vendor, st->firmware_vendor,

4
grub-core/commands/efi/smbios.c
View file

@ -1,7 +1,7 @@
/* smbios.c - get smbios tables. */ /* smbios.c - get smbios tables. */
/* /*
* GRUB -- GRand Unified Bootloader * GRUB -- GRand Unified Bootloader
* Copyright (C) 2015 Free Software Foundation, Inc. * Copyright (C) 2019 Free Software Foundation, Inc.
* *
* GRUB is free software: you can redistribute it and/or modify * GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
@ -37,6 +37,7 @@ grub_machine_smbios_get_eps (void)
return (struct grub_smbios_eps *) return (struct grub_smbios_eps *)
grub_efi_system_table->configuration_table[i].vendor_table; grub_efi_system_table->configuration_table[i].vendor_table;
} }
return 0; return 0;
} }
@ -55,5 +56,6 @@ grub_machine_smbios_get_eps3 (void)
return (struct grub_smbios_eps3 *) return (struct grub_smbios_eps3 *)
grub_efi_system_table->configuration_table[i].vendor_table; grub_efi_system_table->configuration_table[i].vendor_table;
} }
return 0; return 0;
} }

101
grub-core/commands/efi/tpm.c
View file

@ -119,103 +119,6 @@ grub_tpm_handle_find (grub_efi_handle_t *tpm_handle,
return 0; return 0;
} }
static grub_err_t
grub_tpm1_execute (grub_efi_handle_t tpm_handle,
PassThroughToTPM_InputParamBlock *inbuf,
PassThroughToTPM_OutputParamBlock *outbuf)
{
grub_efi_status_t status;
grub_efi_tpm_protocol_t *tpm;
grub_uint32_t inhdrsize = sizeof (*inbuf) - sizeof (inbuf->TPMOperandIn);
grub_uint32_t outhdrsize =
sizeof (*outbuf) - sizeof (outbuf->TPMOperandOut);
tpm = grub_efi_open_protocol (tpm_handle, &tpm_guid,
GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL);
if (!grub_tpm1_present (tpm))
return 0;
/* UEFI TPM protocol takes the raw operand block, no param block header. */
status = efi_call_5 (tpm->pass_through_to_tpm, tpm,
inbuf->IPBLength - inhdrsize, inbuf->TPMOperandIn,
outbuf->OPBLength - outhdrsize, outbuf->TPMOperandOut);
switch (status)
{
case GRUB_EFI_SUCCESS:
return 0;
case GRUB_EFI_DEVICE_ERROR:
return grub_error (GRUB_ERR_IO, N_("Command failed"));
case GRUB_EFI_INVALID_PARAMETER:
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("Invalid parameter"));
case GRUB_EFI_BUFFER_TOO_SMALL:
return grub_error (GRUB_ERR_BAD_ARGUMENT,
N_("Output buffer too small"));
case GRUB_EFI_NOT_FOUND:
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("TPM unavailable"));
default:
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("Unknown TPM error"));
}
}
static grub_err_t
grub_tpm2_execute (grub_efi_handle_t tpm_handle,
PassThroughToTPM_InputParamBlock *inbuf,
PassThroughToTPM_OutputParamBlock *outbuf)
{
grub_efi_status_t status;
grub_efi_tpm2_protocol_t *tpm;
grub_uint32_t inhdrsize = sizeof (*inbuf) - sizeof (inbuf->TPMOperandIn);
grub_uint32_t outhdrsize =
sizeof (*outbuf) - sizeof (outbuf->TPMOperandOut);
tpm = grub_efi_open_protocol (tpm_handle, &tpm2_guid,
GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL);
if (!grub_tpm2_present (tpm))
return 0;
/* UEFI TPM protocol takes the raw operand block, no param block header. */
status = efi_call_5 (tpm->submit_command, tpm,
inbuf->IPBLength - inhdrsize, inbuf->TPMOperandIn,
outbuf->OPBLength - outhdrsize, outbuf->TPMOperandOut);
switch (status)
{
case GRUB_EFI_SUCCESS:
return 0;
case GRUB_EFI_DEVICE_ERROR:
return grub_error (GRUB_ERR_IO, N_("Command failed"));
case GRUB_EFI_INVALID_PARAMETER:
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("Invalid parameter"));
case GRUB_EFI_BUFFER_TOO_SMALL:
return grub_error (GRUB_ERR_BAD_ARGUMENT,
N_("Output buffer too small"));
case GRUB_EFI_NOT_FOUND:
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("TPM unavailable"));
default:
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("Unknown TPM error"));
}
}
grub_err_t
grub_tpm_execute (PassThroughToTPM_InputParamBlock *inbuf,
PassThroughToTPM_OutputParamBlock *outbuf)
{
grub_efi_handle_t tpm_handle;
grub_uint8_t protocol_version;
/* Absence of a TPM isn't a failure. */
if (!grub_tpm_handle_find (&tpm_handle, &protocol_version))
return 0;
if (protocol_version == 1)
return grub_tpm1_execute (tpm_handle, inbuf, outbuf);
else
return grub_tpm2_execute (tpm_handle, inbuf, outbuf);
}
static grub_err_t static grub_err_t
grub_tpm1_log_event (grub_efi_handle_t tpm_handle, unsigned char *buf, grub_tpm1_log_event (grub_efi_handle_t tpm_handle, unsigned char *buf,
grub_size_t size, grub_uint8_t pcr, grub_size_t size, grub_uint8_t pcr,
@ -247,6 +150,7 @@ grub_tpm1_log_event (grub_efi_handle_t tpm_handle, unsigned char *buf,
algorithm = TCG_ALG_SHA; algorithm = TCG_ALG_SHA;
status = efi_call_7 (tpm->log_extend_event, tpm, (grub_addr_t) buf, (grub_uint64_t) size, status = efi_call_7 (tpm->log_extend_event, tpm, (grub_addr_t) buf, (grub_uint64_t) size,
algorithm, event, &eventnum, &lastevent); algorithm, event, &eventnum, &lastevent);
grub_free (event);
switch (status) switch (status)
{ {
@ -297,6 +201,7 @@ grub_tpm2_log_event (grub_efi_handle_t tpm_handle, unsigned char *buf,
status = efi_call_5 (tpm->hash_log_extend_event, tpm, 0, (grub_addr_t) buf, status = efi_call_5 (tpm->hash_log_extend_event, tpm, 0, (grub_addr_t) buf,
(grub_uint64_t) size, event); (grub_uint64_t) size, event);
grub_free (event);
switch (status) switch (status)
{ {
@ -317,7 +222,7 @@ grub_tpm2_log_event (grub_efi_handle_t tpm_handle, unsigned char *buf,
} }
grub_err_t grub_err_t
grub_tpm_log_event (unsigned char *buf, grub_size_t size, grub_uint8_t pcr, grub_tpm_measure (unsigned char *buf, grub_size_t size, grub_uint8_t pcr,
const char *description) const char *description)
{ {
grub_efi_handle_t tpm_handle; grub_efi_handle_t tpm_handle;

122
grub-core/commands/fwconfig.c
View file

@ -1,122 +0,0 @@
/* fwconfig.c - command to read config from qemu fwconfig */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2015 CoreOS, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/dl.h>
#include <grub/misc.h>
#include <grub/extcmd.h>
#include <grub/env.h>
#include <grub/cpu/io.h>
#include <grub/i18n.h>
#include <grub/mm.h>
GRUB_MOD_LICENSE ("GPLv3+");
#define SELECTOR 0x510
#define DATA 0x511
#define SIGNATURE_INDEX 0x00
#define DIRECTORY_INDEX 0x19
static grub_extcmd_t cmd_read_fwconfig;
struct grub_qemu_fwcfgfile {
grub_uint32_t size;
grub_uint16_t select;
grub_uint16_t reserved;
char name[56];
};
static const struct grub_arg_option options[] =
{
{0, 'v', 0, N_("Save read value into variable VARNAME."),
N_("VARNAME"), ARG_TYPE_STRING},
{0, 0, 0, 0, 0, 0}
};
static grub_err_t
grub_cmd_fwconfig (grub_extcmd_context_t ctxt __attribute__ ((unused)),
int argc, char **argv)
{
grub_uint32_t i, j, value = 0;
struct grub_qemu_fwcfgfile file;
char fwsig[4], signature[4] = { 'Q', 'E', 'M', 'U' };
if (argc != 2)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("two arguments expected"));
/* Verify that we have meaningful hardware here */
grub_outw(SIGNATURE_INDEX, SELECTOR);
for (i=0; i<sizeof(fwsig); i++)
fwsig[i] = grub_inb(DATA);
if (grub_memcmp(fwsig, signature, sizeof(signature)) != 0)
return grub_error (GRUB_ERR_BAD_DEVICE, N_("invalid fwconfig hardware signature: got 0x%x%x%x%x"), fwsig[0], fwsig[1], fwsig[2], fwsig[3]);
/* Find out how many file entries we have */
grub_outw(DIRECTORY_INDEX, SELECTOR);
value = grub_inb(DATA) | grub_inb(DATA) << 8 | grub_inb(DATA) << 16 | grub_inb(DATA) << 24;
value = grub_be_to_cpu32(value);
/* Read the file description for each file */
for (i=0; i<value; i++)
{
for (j=0; j<sizeof(file); j++)
{
((char *)&file)[j] = grub_inb(DATA);
}
/* Check whether it matches what we're looking for, and if so read the file */
if (grub_strncmp(file.name, argv[0], sizeof(file.name)) == 0)
{
grub_uint32_t filesize = grub_be_to_cpu32(file.size);
grub_uint16_t location = grub_be_to_cpu16(file.select);
char *data = grub_malloc(filesize+1);
if (!data)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("can't allocate buffer for data"));
grub_outw(location, SELECTOR);
for (j=0; j<filesize; j++)
{
data[j] = grub_inb(DATA);
}
data[filesize] = '\0';
grub_env_set (argv[1], data);
grub_free(data);
return 0;
}
}
return grub_error (GRUB_ERR_FILE_NOT_FOUND, N_("couldn't find entry %s"), argv[0]);
}
GRUB_MOD_INIT(fwconfig)
{
cmd_read_fwconfig =
grub_register_extcmd ("fwconfig", grub_cmd_fwconfig, 0,
N_("PATH VAR"),
N_("Set VAR to the contents of fwconfig PATH"),
options);
}
GRUB_MOD_FINI(fwconfig)
{
grub_unregister_extcmd (cmd_read_fwconfig);
}

223
grub-core/commands/gptprio.c
View file

@ -1,223 +0,0 @@
/* gptprio.c - manage priority based partition selection. */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2009 Free Software Foundation, Inc.
* Copyright (C) 2014 CoreOS, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/device.h>
#include <grub/env.h>
#include <grub/err.h>
#include <grub/extcmd.h>
#include <grub/gpt_partition.h>
#include <grub/i18n.h>
#include <grub/misc.h>
GRUB_MOD_LICENSE ("GPLv3+");
static const struct grub_arg_option options_next[] = {
{"set-device", 'd', 0,
N_("Set a variable to the name of selected partition."),
N_("VARNAME"), ARG_TYPE_STRING},
{"set-uuid", 'u', 0,
N_("Set a variable to the GPT UUID of selected partition."),
N_("VARNAME"), ARG_TYPE_STRING},
{0, 0, 0, 0, 0, 0}
};
enum options_next
{
NEXT_SET_DEVICE,
NEXT_SET_UUID,
};
static unsigned int
grub_gptprio_priority (struct grub_gpt_partentry *entry)
{
return (unsigned int) grub_gpt_entry_attribute
(entry, GRUB_GPT_PART_ATTR_OFFSET_GPTPRIO_PRIORITY, 4);
}
static unsigned int
grub_gptprio_tries_left (struct grub_gpt_partentry *entry)
{
return (unsigned int) grub_gpt_entry_attribute
(entry, GRUB_GPT_PART_ATTR_OFFSET_GPTPRIO_TRIES_LEFT, 4);
}
static void
grub_gptprio_set_tries_left (struct grub_gpt_partentry *entry,
unsigned int tries_left)
{
grub_gpt_entry_set_attribute
(entry, tries_left, GRUB_GPT_PART_ATTR_OFFSET_GPTPRIO_TRIES_LEFT, 4);
}
static unsigned int
grub_gptprio_successful (struct grub_gpt_partentry *entry)
{
return (unsigned int) grub_gpt_entry_attribute
(entry, GRUB_GPT_PART_ATTR_OFFSET_GPTPRIO_SUCCESSFUL, 1);
}
static grub_err_t
grub_find_next (const char *disk_name,
const grub_gpt_part_guid_t *part_type,
char **part_name, char **part_guid)
{
struct grub_gpt_partentry *part, *part_found = NULL;
grub_device_t dev = NULL;
grub_gpt_t gpt = NULL;
grub_uint32_t i, part_index;
dev = grub_device_open (disk_name);
if (!dev)
goto done;
gpt = grub_gpt_read (dev->disk);
if (!gpt)
goto done;
if (grub_gpt_repair (dev->disk, gpt))
goto done;
for (i = 0; (part = grub_gpt_get_partentry (gpt, i)) != NULL; i++)
{
if (grub_memcmp (part_type, &part->type, sizeof (*part_type)) == 0)
{
unsigned int priority, tries_left, successful, old_priority = 0;
priority = grub_gptprio_priority (part);
tries_left = grub_gptprio_tries_left (part);
successful = grub_gptprio_successful (part);
if (part_found)
old_priority = grub_gptprio_priority (part_found);
if ((tries_left || successful) && priority > old_priority)
{
part_index = i;
part_found = part;
}
}
}
if (!part_found)
{
grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("no such partition"));
goto done;
}
if (grub_gptprio_tries_left (part_found))
{
unsigned int tries_left = grub_gptprio_tries_left (part_found);
grub_gptprio_set_tries_left (part_found, tries_left - 1);
if (grub_gpt_update (gpt))
goto done;
if (grub_gpt_write (dev->disk, gpt))
goto done;
}
*part_name = grub_xasprintf ("%s,gpt%u", disk_name, part_index + 1);
if (!*part_name)
goto done;
*part_guid = grub_gpt_guid_to_str (&part_found->guid);
if (!*part_guid)
goto done;
grub_errno = GRUB_ERR_NONE;
done:
grub_gpt_free (gpt);
if (dev)
grub_device_close (dev);
return grub_errno;
}
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_guid_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;
}
static grub_extcmd_t cmd_next;
GRUB_MOD_INIT(gptprio)
{
cmd_next = grub_register_extcmd ("gptprio.next", grub_cmd_next, 0,
N_("-d VARNAME -u VARNAME [DEVICE]"),
N_("Select next partition to boot."),
options_next);
}
GRUB_MOD_FINI(gptprio)
{
grub_unregister_extcmd (cmd_next);
}

110
grub-core/commands/gptrepair.c
View file

@ -1,110 +0,0 @@
/* gptrepair.c - verify and restore GPT info from alternate location. */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2009 Free Software Foundation, Inc.
* Copyright (C) 2014 CoreOS, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/command.h>
#include <grub/device.h>
#include <grub/err.h>
#include <grub/gpt_partition.h>
#include <grub/i18n.h>
#include <grub/misc.h>
GRUB_MOD_LICENSE ("GPLv3+");
static char *
trim_dev_name (char *name)
{
grub_size_t len = grub_strlen (name);
if (len && name[0] == '(' && name[len - 1] == ')')
{
name[len - 1] = '\0';
name = name + 1;
}
return name;
}
static grub_err_t
grub_cmd_gptrepair (grub_command_t cmd __attribute__ ((unused)),
int argc, char **args)
{
grub_device_t dev = NULL;
grub_gpt_t gpt = NULL;
char *dev_name;
if (argc != 1 || !grub_strlen(args[0]))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "device name required");
dev_name = trim_dev_name (args[0]);
dev = grub_device_open (dev_name);
if (!dev)
goto done;
if (!dev->disk)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "not a disk");
goto done;
}
gpt = grub_gpt_read (dev->disk);
if (!gpt)
goto done;
if (grub_gpt_both_valid (gpt))
{
grub_printf_ (N_("GPT already valid, %s unmodified.\n"), dev_name);
goto done;
}
if (!grub_gpt_primary_valid (gpt))
grub_printf_ (N_("Found invalid primary GPT on %s\n"), dev_name);
if (!grub_gpt_backup_valid (gpt))
grub_printf_ (N_("Found invalid backup GPT on %s\n"), dev_name);
if (grub_gpt_repair (dev->disk, gpt))
goto done;
if (grub_gpt_write (dev->disk, gpt))
goto done;
grub_printf_ (N_("Repaired GPT on %s\n"), dev_name);
done:
if (gpt)
grub_gpt_free (gpt);
if (dev)
grub_device_close (dev);
return grub_errno;
}
static grub_command_t cmd;
GRUB_MOD_INIT(gptrepair)
{
cmd = grub_register_command ("gptrepair", grub_cmd_gptrepair,
N_("DEVICE"),
N_("Verify and repair GPT on drive DEVICE."));
}
GRUB_MOD_FINI(gptrepair)
{
grub_unregister_command (cmd);
}

2
grub-core/commands/i386/cmostest.c
View file

@ -27,7 +27,7 @@ GRUB_MOD_LICENSE ("GPLv3+");
static grub_err_t static grub_err_t
parse_args (int argc, char *argv[], int *byte, int *bit) parse_args (int argc, char *argv[], int *byte, int *bit)
{ {
char *rest; const char *rest;
if (argc != 1) if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "address required"); return grub_error (GRUB_ERR_BAD_ARGUMENT, "address required");

2
grub-core/commands/i386/pc/play.c
View file

@ -132,7 +132,7 @@ grub_cmd_play (grub_command_t cmd __attribute__ ((unused)),
} }
else else
{ {
char *end; const char *end;
unsigned tempo; unsigned tempo;
struct note note; struct note note;
int i; int i;

12
grub-core/commands/i386/pc/smbios.c
View file

@ -1,7 +1,7 @@
/* smbios.c - get smbios tables. */ /* smbios.c - get smbios tables. */
/* /*
* GRUB -- GRand Unified Bootloader * GRUB -- GRand Unified Bootloader
* Copyright (C) 2015 Free Software Foundation, Inc. * Copyright (C) 2019 Free Software Foundation, Inc.
* *
* GRUB is free software: you can redistribute it and/or modify * GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
@ -27,11 +27,12 @@ grub_machine_smbios_get_eps (void)
grub_uint8_t *ptr; grub_uint8_t *ptr;
grub_dprintf ("smbios", "Looking for SMBIOS EPS. Scanning BIOS\n"); grub_dprintf ("smbios", "Looking for SMBIOS EPS. Scanning BIOS\n");
for (ptr = (grub_uint8_t *) 0xf0000; ptr < (grub_uint8_t *) 0x100000;
ptr += 16) for (ptr = (grub_uint8_t *) 0xf0000; ptr < (grub_uint8_t *) 0x100000; ptr += 16)
if (grub_memcmp (ptr, "_SM_", 4) == 0 if (grub_memcmp (ptr, "_SM_", 4) == 0
&& grub_byte_checksum (ptr, sizeof (struct grub_smbios_eps)) == 0) && grub_byte_checksum (ptr, sizeof (struct grub_smbios_eps)) == 0)
return (struct grub_smbios_eps *) ptr; return (struct grub_smbios_eps *) ptr;
return 0; return 0;
} }
@ -41,10 +42,11 @@ grub_machine_smbios_get_eps3 (void)
grub_uint8_t *ptr; grub_uint8_t *ptr;
grub_dprintf ("smbios", "Looking for SMBIOS3 EPS. Scanning BIOS\n"); grub_dprintf ("smbios", "Looking for SMBIOS3 EPS. Scanning BIOS\n");
for (ptr = (grub_uint8_t *) 0xf0000; ptr < (grub_uint8_t *) 0x100000;
ptr += 16) for (ptr = (grub_uint8_t *) 0xf0000; ptr < (grub_uint8_t *) 0x100000; ptr += 16)
if (grub_memcmp (ptr, "_SM3_", 5) == 0 if (grub_memcmp (ptr, "_SM3_", 5) == 0
&& grub_byte_checksum (ptr, sizeof (struct grub_smbios_eps3)) == 0) && grub_byte_checksum (ptr, sizeof (struct grub_smbios_eps3)) == 0)
return (struct grub_smbios_eps3 *) ptr; return (struct grub_smbios_eps3 *) ptr;
return 0; return 0;
} }

2
grub-core/commands/i386/rdmsr.c
View file

@ -44,7 +44,7 @@ grub_cmd_msr_read (grub_extcmd_context_t ctxt, int argc, char **argv)
{ {
grub_uint32_t manufacturer[3], max_cpuid, a, b, c, features, addr; grub_uint32_t manufacturer[3], max_cpuid, a, b, c, features, addr;
grub_uint64_t value; grub_uint64_t value;
char *ptr; const char *ptr;
char buf[sizeof("1122334455667788")]; char buf[sizeof("1122334455667788")];
/* /*

2
grub-core/commands/i386/wrmsr.c
View file

@ -37,7 +37,7 @@ grub_cmd_msr_write (grub_command_t cmd __attribute__ ((unused)), int argc, char
{ {
grub_uint32_t manufacturer[3], max_cpuid, a, b, c, features, addr; grub_uint32_t manufacturer[3], max_cpuid, a, b, c, features, addr;
grub_uint64_t value; grub_uint64_t value;
char *ptr; const char *ptr;
/* /*
* The CPUID instruction should be used to determine whether MSRs * The CPUID instruction should be used to determine whether MSRs

18
grub-core/commands/keystatus.c
View file

@ -35,24 +35,6 @@ static const struct grub_arg_option options[] =
{0, 0, 0, 0, 0, 0} {0, 0, 0, 0, 0, 0}
}; };
static int
grub_getkeystatus (void)
{
int status = 0;
grub_term_input_t term;
if (grub_term_poll_usb)
grub_term_poll_usb (0);
FOR_ACTIVE_TERM_INPUTS(term)
{
if (term->getkeystatus)
status |= term->getkeystatus (term);
}
return status;
}
static grub_err_t static grub_err_t
grub_cmd_keystatus (grub_extcmd_context_t ctxt, grub_cmd_keystatus (grub_extcmd_context_t ctxt,
int argc __attribute__ ((unused)), int argc __attribute__ ((unused)),

33
grub-core/commands/legacycfg.c
View file

@ -32,6 +32,7 @@
#include <grub/auth.h> #include <grub/auth.h>
#include <grub/disk.h> #include <grub/disk.h>
#include <grub/partition.h> #include <grub/partition.h>
#include <grub/safemath.h>
GRUB_MOD_LICENSE ("GPLv3+"); GRUB_MOD_LICENSE ("GPLv3+");
@ -104,13 +105,22 @@ legacy_file (const char *filename)
if (newsuffix) if (newsuffix)
{ {
char *t; char *t;
grub_size_t sz;
if (grub_add (grub_strlen (suffix), grub_strlen (newsuffix), &sz) ||
grub_add (sz, 1, &sz))
{
grub_errno = GRUB_ERR_OUT_OF_RANGE;
goto fail_0;
}
t = suffix; t = suffix;
suffix = grub_realloc (suffix, grub_strlen (suffix) suffix = grub_realloc (suffix, sz);
+ grub_strlen (newsuffix) + 1);
if (!suffix) if (!suffix)
{ {
grub_free (t); grub_free (t);
fail_0:
grub_free (entrysrc); grub_free (entrysrc);
grub_free (parsed); grub_free (parsed);
grub_free (newsuffix); grub_free (newsuffix);
@ -154,13 +164,22 @@ legacy_file (const char *filename)
else else
{ {
char *t; char *t;
grub_size_t sz;
if (grub_add (grub_strlen (entrysrc), grub_strlen (parsed), &sz) ||
grub_add (sz, 1, &sz))
{
grub_errno = GRUB_ERR_OUT_OF_RANGE;
goto fail_1;
}
t = entrysrc; t = entrysrc;
entrysrc = grub_realloc (entrysrc, grub_strlen (entrysrc) entrysrc = grub_realloc (entrysrc, sz);
+ grub_strlen (parsed) + 1);
if (!entrysrc) if (!entrysrc)
{ {
grub_free (t); grub_free (t);
fail_1:
grub_free (parsed); grub_free (parsed);
grub_free (suffix); grub_free (suffix);
return grub_errno; return grub_errno;
@ -314,7 +333,7 @@ grub_cmd_legacy_kernel (struct grub_command *mycmd __attribute__ ((unused)),
if (argc < 2) if (argc < 2)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected")); return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
cutargs = grub_malloc (sizeof (cutargs[0]) * (argc - 1)); cutargs = grub_calloc (argc - 1, sizeof (cutargs[0]));
if (!cutargs) if (!cutargs)
return grub_errno; return grub_errno;
cutargc = argc - 1; cutargc = argc - 1;
@ -436,7 +455,7 @@ grub_cmd_legacy_kernel (struct grub_command *mycmd __attribute__ ((unused)),
{ {
char rbuf[3] = "-r"; char rbuf[3] = "-r";
bsdargc = cutargc + 2; bsdargc = cutargc + 2;
bsdargs = grub_malloc (sizeof (bsdargs[0]) * bsdargc); bsdargs = grub_calloc (bsdargc, sizeof (bsdargs[0]));
if (!bsdargs) if (!bsdargs)
{ {
err = grub_errno; err = grub_errno;
@ -559,7 +578,7 @@ grub_cmd_legacy_initrdnounzip (struct grub_command *mycmd __attribute__ ((unused
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("can't find command `%s'"), return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("can't find command `%s'"),
"module"); "module");
newargs = grub_malloc ((argc + 1) * sizeof (newargs[0])); newargs = grub_calloc (argc + 1, sizeof (newargs[0]));
if (!newargs) if (!newargs)
return grub_errno; return grub_errno;
grub_memcpy (newargs + 1, args, argc * sizeof (newargs[0])); grub_memcpy (newargs + 1, args, argc * sizeof (newargs[0]));

2
grub-core/commands/menuentry.c
View file

@ -154,7 +154,7 @@ grub_normal_add_menu_entry (int argc, const char **args,
goto fail; goto fail;
/* Save argc, args to pass as parameters to block arg later. */ /* Save argc, args to pass as parameters to block arg later. */
menu_args = grub_malloc (sizeof (char*) * (argc + 1)); menu_args = grub_calloc (argc + 1, sizeof (char *));
if (! menu_args) if (! menu_args)
goto fail; goto fail;

2
grub-core/commands/nativedisk.c
View file

@ -195,7 +195,7 @@ grub_cmd_nativedisk (grub_command_t cmd __attribute__ ((unused)),
else else
path_prefix = prefix; path_prefix = prefix;
mods = grub_malloc (argc * sizeof (mods[0])); mods = grub_calloc (argc, sizeof (mods[0]));
if (!mods) if (!mods)
return grub_errno; return grub_errno;

12
grub-core/commands/parttool.c
View file

@ -59,7 +59,13 @@ grub_parttool_register(const char *part_name,
for (nargs = 0; args[nargs].name != 0; nargs++); for (nargs = 0; args[nargs].name != 0; nargs++);
cur->nargs = nargs; cur->nargs = nargs;
cur->args = (struct grub_parttool_argdesc *) cur->args = (struct grub_parttool_argdesc *)
grub_malloc ((nargs + 1) * sizeof (struct grub_parttool_argdesc)); grub_calloc (nargs + 1, sizeof (struct grub_parttool_argdesc));
if (!cur->args)
{
grub_free (cur);
curhandle--;
return -1;
}
grub_memcpy (cur->args, args, grub_memcpy (cur->args, args,
(nargs + 1) * sizeof (struct grub_parttool_argdesc)); (nargs + 1) * sizeof (struct grub_parttool_argdesc));
@ -257,7 +263,7 @@ grub_cmd_parttool (grub_command_t cmd __attribute__ ((unused)),
return err; return err;
} }
parsed = (int *) grub_zalloc (argc * sizeof (int)); parsed = (int *) grub_calloc (argc, sizeof (int));
for (i = 1; i < argc; i++) for (i = 1; i < argc; i++)
if (! parsed[i]) if (! parsed[i])
@ -290,7 +296,7 @@ grub_cmd_parttool (grub_command_t cmd __attribute__ ((unused)),
} }
ptool = cur; ptool = cur;
pargs = (struct grub_parttool_args *) pargs = (struct grub_parttool_args *)
grub_zalloc (ptool->nargs * sizeof (struct grub_parttool_args)); grub_calloc (ptool->nargs, sizeof (struct grub_parttool_args));
for (j = i; j < argc; j++) for (j = i; j < argc; j++)
if (! parsed[j]) if (! parsed[j])
{ {

2
grub-core/commands/password_pbkdf2.c
View file

@ -86,7 +86,7 @@ grub_cmd_password (grub_command_t cmd __attribute__ ((unused)),
int argc, char **args) int argc, char **args)
{ {
grub_err_t err; grub_err_t err;
char *ptr, *ptr2; const char *ptr, *ptr2;
grub_uint8_t *ptro; grub_uint8_t *ptro;
struct pbkdf2_password *pass; struct pbkdf2_password *pass;

11
grub-core/commands/pcidump.c
View file

@ -95,7 +95,7 @@ grub_cmd_pcidump (grub_extcmd_context_t ctxt,
if (ctxt->state[0].set) if (ctxt->state[0].set)
{ {
ptr = ctxt->state[0].arg; ptr = ctxt->state[0].arg;
ctx.pciid_check_value |= (grub_strtoul (ptr, (char **) &ptr, 16) & 0xffff); ctx.pciid_check_value |= (grub_strtoul (ptr, &ptr, 16) & 0xffff);
if (grub_errno == GRUB_ERR_BAD_NUMBER) if (grub_errno == GRUB_ERR_BAD_NUMBER)
{ {
grub_errno = GRUB_ERR_NONE; grub_errno = GRUB_ERR_NONE;
@ -108,8 +108,7 @@ grub_cmd_pcidump (grub_extcmd_context_t ctxt,
if (*ptr != ':') if (*ptr != ':')
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("missing `%c' symbol"), ':'); return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("missing `%c' symbol"), ':');
ptr++; ptr++;
ctx.pciid_check_value |= (grub_strtoul (ptr, (char **) &ptr, 16) & 0xffff) ctx.pciid_check_value |= (grub_strtoul (ptr, &ptr, 16) & 0xffff) << 16;
<< 16;
if (grub_errno == GRUB_ERR_BAD_NUMBER) if (grub_errno == GRUB_ERR_BAD_NUMBER)
grub_errno = GRUB_ERR_NONE; grub_errno = GRUB_ERR_NONE;
else else
@ -124,7 +123,7 @@ grub_cmd_pcidump (grub_extcmd_context_t ctxt,
ptr = ctxt->state[1].arg; ptr = ctxt->state[1].arg;
optr = ptr; optr = ptr;
ctx.bus = grub_strtoul (ptr, (char **) &ptr, 16); ctx.bus = grub_strtoul (ptr, &ptr, 16);
if (grub_errno == GRUB_ERR_BAD_NUMBER) if (grub_errno == GRUB_ERR_BAD_NUMBER)
{ {
grub_errno = GRUB_ERR_NONE; grub_errno = GRUB_ERR_NONE;
@ -138,7 +137,7 @@ grub_cmd_pcidump (grub_extcmd_context_t ctxt,
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("missing `%c' symbol"), ':'); return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("missing `%c' symbol"), ':');
ptr++; ptr++;
optr = ptr; optr = ptr;
ctx.device = grub_strtoul (ptr, (char **) &ptr, 16); ctx.device = grub_strtoul (ptr, &ptr, 16);
if (grub_errno == GRUB_ERR_BAD_NUMBER) if (grub_errno == GRUB_ERR_BAD_NUMBER)
{ {
grub_errno = GRUB_ERR_NONE; grub_errno = GRUB_ERR_NONE;
@ -149,7 +148,7 @@ grub_cmd_pcidump (grub_extcmd_context_t ctxt,
if (*ptr == '.') if (*ptr == '.')
{ {
ptr++; ptr++;
ctx.function = grub_strtoul (ptr, (char **) &ptr, 16); ctx.function = grub_strtoul (ptr, &ptr, 16);
if (grub_errno) if (grub_errno)
return grub_errno; return grub_errno;
ctx.check_function = 1; ctx.check_function = 1;

93
grub-core/commands/pgp.c
View file

@ -759,78 +759,6 @@ grub_cmd_trust (grub_extcmd_context_t ctxt,
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
} }
static grub_ssize_t
pseudo_read (struct grub_file *file, char *buf, grub_size_t len)
{
grub_memcpy (buf, (grub_uint8_t *) file->data + file->offset, len);
return len;
}
/* Filesystem descriptor. */
struct grub_fs pseudo_fs =
{
.name = "pseudo",
.fs_read = pseudo_read
};
static grub_err_t
grub_cmd_trust_var (grub_command_t cmd __attribute__ ((unused)),
int argc, char **args)
{
struct grub_file pseudo_file;
const char *var;
char *data;
struct grub_public_key *pk = NULL;
unsigned int i, idx0, idx1;
if (argc < 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
var = grub_env_get (args[0]);
if (!var)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("unknown variable"));
data = grub_zalloc (grub_strlen (var) / 2);
if (!data)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("can't allocate memory for key"));
/* For the want of sscanf() */
for (i = 0; i < grub_strlen (var); i += 2)
{
if (var[i] < 0x40)
idx0 = var[i] - 0x30;
else
idx0 = var[i] - 0x57;
if (var[i+1] < 0x40)
idx1 = var[i+1] - 0x30;
else
idx1 = var[i+1] - 0x57;
data[i/2] = ((idx0 << 4) & 0xf0) | (idx1 & 0x0f);
}
grub_memset (&pseudo_file, 0, sizeof (pseudo_file));
pseudo_file.fs = &pseudo_fs;
pseudo_file.size = grub_strlen (var) / 2;
pseudo_file.data = data;
pk = grub_load_public_key (&pseudo_file);
if (!pk)
{
grub_free(data);
return grub_errno;
}
pk->next = grub_pk_trusted;
grub_pk_trusted = pk;
grub_free(data);
return GRUB_ERR_NONE;
}
static grub_err_t static grub_err_t
grub_cmd_list (grub_command_t cmd __attribute__ ((unused)), grub_cmd_list (grub_command_t cmd __attribute__ ((unused)),
int argc __attribute__ ((unused)), int argc __attribute__ ((unused)),
@ -994,6 +922,21 @@ grub_env_write_sec (struct grub_env_var *var __attribute__ ((unused)),
return grub_strdup (sec ? "enforce" : "no"); return grub_strdup (sec ? "enforce" : "no");
} }
static grub_ssize_t
pseudo_read (struct grub_file *file, char *buf, grub_size_t len)
{
grub_memcpy (buf, (grub_uint8_t *) file->data + file->offset, len);
return len;
}
/* Filesystem descriptor. */
struct grub_fs pseudo_fs =
{
.name = "pseudo",
.fs_read = pseudo_read
};
struct grub_file_verifier grub_pubkey_verifier = struct grub_file_verifier grub_pubkey_verifier =
{ {
.name = "pgp", .name = "pgp",
@ -1004,7 +947,7 @@ struct grub_file_verifier grub_pubkey_verifier =
}; };
static grub_extcmd_t cmd, cmd_trust; static grub_extcmd_t cmd, cmd_trust;
static grub_command_t cmd_trust_var, cmd_distrust, cmd_list; static grub_command_t cmd_distrust, cmd_list;
GRUB_MOD_INIT(pgp) GRUB_MOD_INIT(pgp)
{ {
@ -1055,9 +998,6 @@ GRUB_MOD_INIT(pgp)
N_("[-s|--skip-sig] PUBKEY_FILE"), N_("[-s|--skip-sig] PUBKEY_FILE"),
N_("Add PUBKEY_FILE to trusted keys."), N_("Add PUBKEY_FILE to trusted keys."),
options); options);
cmd_trust_var = grub_register_command ("trust_var", grub_cmd_trust_var,
N_("PUBKEY_VAR"),
N_("Add the contents of PUBKEY_VAR to trusted keys."));
cmd_list = grub_register_command ("list_trusted", grub_cmd_list, cmd_list = grub_register_command ("list_trusted", grub_cmd_list,
0, 0,
N_("Show the list of trusted keys.")); N_("Show the list of trusted keys."));
@ -1073,7 +1013,6 @@ GRUB_MOD_FINI(pgp)
grub_verifier_unregister (&grub_pubkey_verifier); grub_verifier_unregister (&grub_pubkey_verifier);
grub_unregister_extcmd (cmd); grub_unregister_extcmd (cmd);
grub_unregister_extcmd (cmd_trust); grub_unregister_extcmd (cmd_trust);
grub_unregister_command (cmd_trust_var);
grub_unregister_command (cmd_list); grub_unregister_command (cmd_list);
grub_unregister_command (cmd_distrust); grub_unregister_command (cmd_distrust);
} }

49
grub-core/commands/probe.c
View file

@ -24,6 +24,7 @@
#include <grub/device.h> #include <grub/device.h>
#include <grub/disk.h> #include <grub/disk.h>
#include <grub/partition.h> #include <grub/partition.h>
#include <grub/gpt_partition.h>
#include <grub/net.h> #include <grub/net.h>
#include <grub/fs.h> #include <grub/fs.h>
#include <grub/file.h> #include <grub/file.h>
@ -31,6 +32,7 @@
#include <grub/env.h> #include <grub/env.h>
#include <grub/extcmd.h> #include <grub/extcmd.h>
#include <grub/i18n.h> #include <grub/i18n.h>
#include <grub/i386/pc/boot.h>
GRUB_MOD_LICENSE ("GPLv3+"); GRUB_MOD_LICENSE ("GPLv3+");
@ -45,6 +47,7 @@ static const struct grub_arg_option options[] =
{"fs", 'f', 0, N_("Determine filesystem type."), 0, 0}, {"fs", 'f', 0, N_("Determine filesystem type."), 0, 0},
{"fs-uuid", 'u', 0, N_("Determine filesystem UUID."), 0, 0}, {"fs-uuid", 'u', 0, N_("Determine filesystem UUID."), 0, 0},
{"label", 'l', 0, N_("Determine filesystem label."), 0, 0}, {"label", 'l', 0, N_("Determine filesystem label."), 0, 0},
{"part-uuid", 0, 0, N_("Determine partition UUID."), 0, 0},
{0, 0, 0, 0, 0, 0} {0, 0, 0, 0, 0, 0}
}; };
@ -98,6 +101,52 @@ grub_cmd_probe (grub_extcmd_context_t ctxt, int argc, char **args)
grub_device_close (dev); grub_device_close (dev);
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
} }
if (state[6].set)
{
/* AAAABBBB-CCCC-DDDD-EEEE-FFFFFFFFFFFF + null terminator */
char val[37] = "none";
if (dev->disk && dev->disk->partition)
{
struct grub_partition *p = dev->disk->partition;
grub_disk_t disk = grub_disk_open(dev->disk->name);
if (!disk)
return grub_errno;
if (grub_strcmp(dev->disk->partition->partmap->name, "gpt") == 0)
{
struct grub_gpt_partentry entry;
grub_gpt_part_guid_t *guid;
if (grub_disk_read(disk, p->offset, p->index, sizeof(entry), &entry))
return grub_errno;
guid = &entry.guid;
grub_snprintf (val, sizeof(val),
"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
grub_le_to_cpu32 (guid->data1),
grub_le_to_cpu16 (guid->data2),
grub_le_to_cpu16 (guid->data3),
guid->data4[0], guid->data4[1], guid->data4[2],
guid->data4[3], guid->data4[4], guid->data4[5],
guid->data4[6], guid->data4[7]);
}
else if (grub_strcmp(dev->disk->partition->partmap->name, "msdos") == 0)
{
grub_uint32_t nt_disk_sig;
if (grub_disk_read(disk, 0, GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC,
sizeof(nt_disk_sig), &nt_disk_sig) == 0)
grub_snprintf (val, sizeof(val), "%08x-%02x",
grub_le_to_cpu32(nt_disk_sig), 1 + p->number);
}
grub_disk_close(disk);
}
if (state[0].set)
grub_env_set (state[0].arg, val);
else
grub_printf ("%s", val);
grub_device_close (dev);
return GRUB_ERR_NONE;
}
fs = grub_fs_probe (dev); fs = grub_fs_probe (dev);
if (! fs) if (! fs)
return grub_errno; return grub_errno;

4
grub-core/commands/regexp.c
View file

@ -64,7 +64,7 @@ set_matches (char **varnames, char *str, grub_size_t nmatches,
{ {
int i; int i;
char *p; char *p;
char *q; const char * q;
grub_err_t err; grub_err_t err;
unsigned long j; unsigned long j;
@ -116,7 +116,7 @@ grub_cmd_regexp (grub_extcmd_context_t ctxt, int argc, char **args)
if (ret) if (ret)
goto fail; goto fail;
matches = grub_zalloc (sizeof (*matches) * (regex.re_nsub + 1)); matches = grub_calloc (regex.re_nsub + 1, sizeof (*matches));
if (! matches) if (! matches)
goto fail; goto fail;

75
grub-core/commands/search.c
View file

@ -30,10 +30,6 @@
#include <grub/i18n.h> #include <grub/i18n.h>
#include <grub/disk.h> #include <grub/disk.h>
#include <grub/partition.h> #include <grub/partition.h>
#if defined(DO_SEARCH_PART_UUID) || defined(DO_SEARCH_PART_LABEL) || \
defined(DO_SEARCH_DISK_UUID)
#include <grub/gpt_partition.h>
#endif
GRUB_MOD_LICENSE ("GPLv3+"); GRUB_MOD_LICENSE ("GPLv3+");
@ -70,7 +66,7 @@ iterate_device (const char *name, void *data)
name[0] == 'f' && name[1] == 'd' && name[2] >= '0' && name[2] <= '9') name[0] == 'f' && name[1] == 'd' && name[2] >= '0' && name[2] <= '9')
return 1; return 1;
#if defined(DO_SEARCH_FS_UUID) || defined(DO_SEARCH_DISK_UUID) #ifdef DO_SEARCH_FS_UUID
#define compare_fn grub_strcasecmp #define compare_fn grub_strcasecmp
#else #else
#define compare_fn grub_strcmp #define compare_fn grub_strcmp
@ -94,63 +90,6 @@ iterate_device (const char *name, void *data)
} }
grub_free (buf); grub_free (buf);
} }
#elif defined(DO_SEARCH_PART_UUID)
{
grub_device_t dev;
char *quid;
dev = grub_device_open (name);
if (dev)
{
if (grub_gpt_part_uuid (dev, &quid) == GRUB_ERR_NONE)
{
if (grub_strcasecmp (quid, ctx->key) == 0)
found = 1;
grub_free (quid);
}
grub_device_close (dev);
}
}
#elif defined(DO_SEARCH_PART_LABEL)
{
grub_device_t dev;
char *quid;
dev = grub_device_open (name);
if (dev)
{
if (grub_gpt_part_label (dev, &quid) == GRUB_ERR_NONE)
{
if (grub_strcmp (quid, ctx->key) == 0)
found = 1;
grub_free (quid);
}
grub_device_close (dev);
}
}
#elif defined(DO_SEARCH_DISK_UUID)
{
grub_device_t dev;
char *quid;
dev = grub_device_open (name);
if (dev)
{
if (grub_gpt_disk_uuid (dev, &quid) == GRUB_ERR_NONE)
{
if (grub_strcmp (quid, ctx->key) == 0)
found = 1;
grub_free (quid);
}
grub_device_close (dev);
}
}
#else #else
{ {
/* SEARCH_FS_UUID or SEARCH_LABEL */ /* SEARCH_FS_UUID or SEARCH_LABEL */
@ -374,14 +313,8 @@ static grub_command_t cmd;
#ifdef DO_SEARCH_FILE #ifdef DO_SEARCH_FILE
GRUB_MOD_INIT(search_fs_file) GRUB_MOD_INIT(search_fs_file)
#elif defined(DO_SEARCH_PART_UUID)
GRUB_MOD_INIT(search_part_uuid)
#elif defined(DO_SEARCH_PART_LABEL)
GRUB_MOD_INIT(search_part_label)
#elif defined (DO_SEARCH_FS_UUID) #elif defined (DO_SEARCH_FS_UUID)
GRUB_MOD_INIT(search_fs_uuid) GRUB_MOD_INIT(search_fs_uuid)
#elif defined (DO_SEARCH_DISK_UUID)
GRUB_MOD_INIT(search_disk_uuid)
#else #else
GRUB_MOD_INIT(search_label) GRUB_MOD_INIT(search_label)
#endif #endif
@ -394,14 +327,8 @@ GRUB_MOD_INIT(search_label)
#ifdef DO_SEARCH_FILE #ifdef DO_SEARCH_FILE
GRUB_MOD_FINI(search_fs_file) GRUB_MOD_FINI(search_fs_file)
#elif defined(DO_SEARCH_PART_UUID)
GRUB_MOD_FINI(search_part_uuid)
#elif defined(DO_SEARCH_PART_LABEL)
GRUB_MOD_FINI(search_part_label)
#elif defined (DO_SEARCH_FS_UUID) #elif defined (DO_SEARCH_FS_UUID)
GRUB_MOD_FINI(search_fs_uuid) GRUB_MOD_FINI(search_fs_uuid)
#elif defined (DO_SEARCH_DISK_UUID)
GRUB_MOD_FINI(search_disk_uuid)
#else #else
GRUB_MOD_FINI(search_label) GRUB_MOD_FINI(search_label)
#endif #endif

5
grub-core/commands/search_disk_uuid.c
View file

@ -1,5 +0,0 @@
#define DO_SEARCH_DISK_UUID 1
#define FUNC_NAME grub_search_disk_uuid
#define COMMAND_NAME "search.disk_uuid"
#define HELP_MESSAGE N_("Search devices by disk UUID. If VARIABLE is specified, the first device found is set to a variable.")
#include "search.c"

5
grub-core/commands/search_part_label.c
View file

@ -1,5 +0,0 @@
#define DO_SEARCH_PART_LABEL 1
#define FUNC_NAME grub_search_part_label
#define COMMAND_NAME "search.part_label"
#define HELP_MESSAGE N_("Search devices by partition label. If VARIABLE is specified, the first device found is set to a variable.")
#include "search.c"

5
grub-core/commands/search_part_uuid.c
View file

@ -1,5 +0,0 @@
#define DO_SEARCH_PART_UUID 1
#define FUNC_NAME grub_search_part_uuid
#define COMMAND_NAME "search.part_uuid"
#define HELP_MESSAGE N_("Search devices by partition UUID. If VARIABLE is specified, the first device found is set to a variable.")
#include "search.c"

20
grub-core/commands/search_wrap.c
View file

@ -36,12 +36,6 @@ static const struct grub_arg_option options[] =
0, 0}, 0, 0},
{"fs-uuid", 'u', 0, N_("Search devices by a filesystem UUID."), {"fs-uuid", 'u', 0, N_("Search devices by a filesystem UUID."),
0, 0}, 0, 0},
{"part-label", 'L', 0, N_("Search devices by a partition label."),
0, 0},
{"part-uuid", 'U', 0, N_("Search devices by a partition UUID."),
0, 0},
{"disk-uuid", 'U', 0, N_("Search devices by a disk UUID."),
0, 0},
{"set", 's', GRUB_ARG_OPTION_OPTIONAL, {"set", 's', GRUB_ARG_OPTION_OPTIONAL,
N_("Set a variable to the first device found."), N_("VARNAME"), N_("Set a variable to the first device found."), N_("VARNAME"),
ARG_TYPE_STRING}, ARG_TYPE_STRING},
@ -77,9 +71,6 @@ enum options
SEARCH_FILE, SEARCH_FILE,
SEARCH_LABEL, SEARCH_LABEL,
SEARCH_FS_UUID, SEARCH_FS_UUID,
SEARCH_PART_LABEL,
SEARCH_PART_UUID,
SEARCH_DISK_UUID,
SEARCH_SET, SEARCH_SET,
SEARCH_NO_FLOPPY, SEARCH_NO_FLOPPY,
SEARCH_HINT, SEARCH_HINT,
@ -131,7 +122,7 @@ grub_cmd_search (grub_extcmd_context_t ctxt, int argc, char **args)
for (i = 0; state[SEARCH_HINT_BAREMETAL].args[i]; i++) for (i = 0; state[SEARCH_HINT_BAREMETAL].args[i]; i++)
nhints++; nhints++;
hints = grub_malloc (sizeof (hints[0]) * nhints); hints = grub_calloc (nhints, sizeof (hints[0]));
if (!hints) if (!hints)
return grub_errno; return grub_errno;
j = 0; j = 0;
@ -195,15 +186,6 @@ grub_cmd_search (grub_extcmd_context_t ctxt, int argc, char **args)
else if (state[SEARCH_FS_UUID].set) else if (state[SEARCH_FS_UUID].set)
grub_search_fs_uuid (id, var, state[SEARCH_NO_FLOPPY].set, grub_search_fs_uuid (id, var, state[SEARCH_NO_FLOPPY].set,
hints, nhints); hints, nhints);
else if (state[SEARCH_PART_LABEL].set)
grub_search_part_label (id, var, state[SEARCH_NO_FLOPPY].set,
hints, nhints);
else if (state[SEARCH_PART_UUID].set)
grub_search_part_uuid (id, var, state[SEARCH_NO_FLOPPY].set,
hints, nhints);
else if (state[SEARCH_DISK_UUID].set)
grub_search_disk_uuid (id, var, state[SEARCH_NO_FLOPPY].set,
hints, nhints);
else if (state[SEARCH_FILE].set) else if (state[SEARCH_FILE].set)
grub_search_fs_file (id, var, state[SEARCH_NO_FLOPPY].set, grub_search_fs_file (id, var, state[SEARCH_NO_FLOPPY].set,
hints, nhints); hints, nhints);

19
grub-core/commands/setpci.c
View file

@ -169,7 +169,7 @@ grub_cmd_setpci (grub_extcmd_context_t ctxt, int argc, char **argv)
if (ctxt->state[0].set) if (ctxt->state[0].set)
{ {
ptr = ctxt->state[0].arg; ptr = ctxt->state[0].arg;
pciid_check_value |= (grub_strtoul (ptr, (char **) &ptr, 16) & 0xffff); pciid_check_value |= (grub_strtoul (ptr, &ptr, 16) & 0xffff);
if (grub_errno == GRUB_ERR_BAD_NUMBER) if (grub_errno == GRUB_ERR_BAD_NUMBER)
{ {
grub_errno = GRUB_ERR_NONE; grub_errno = GRUB_ERR_NONE;
@ -182,8 +182,7 @@ grub_cmd_setpci (grub_extcmd_context_t ctxt, int argc, char **argv)
if (*ptr != ':') if (*ptr != ':')
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("missing `%c' symbol"), ':'); return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("missing `%c' symbol"), ':');
ptr++; ptr++;
pciid_check_value |= (grub_strtoul (ptr, (char **) &ptr, 16) & 0xffff) pciid_check_value |= (grub_strtoul (ptr, &ptr, 16) & 0xffff) << 16;
<< 16;
if (grub_errno == GRUB_ERR_BAD_NUMBER) if (grub_errno == GRUB_ERR_BAD_NUMBER)
grub_errno = GRUB_ERR_NONE; grub_errno = GRUB_ERR_NONE;
else else
@ -200,7 +199,7 @@ grub_cmd_setpci (grub_extcmd_context_t ctxt, int argc, char **argv)
ptr = ctxt->state[1].arg; ptr = ctxt->state[1].arg;
optr = ptr; optr = ptr;
bus = grub_strtoul (ptr, (char **) &ptr, 16); bus = grub_strtoul (ptr, &ptr, 16);
if (grub_errno == GRUB_ERR_BAD_NUMBER) if (grub_errno == GRUB_ERR_BAD_NUMBER)
{ {
grub_errno = GRUB_ERR_NONE; grub_errno = GRUB_ERR_NONE;
@ -214,7 +213,7 @@ grub_cmd_setpci (grub_extcmd_context_t ctxt, int argc, char **argv)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("missing `%c' symbol"), ':'); return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("missing `%c' symbol"), ':');
ptr++; ptr++;
optr = ptr; optr = ptr;
device = grub_strtoul (ptr, (char **) &ptr, 16); device = grub_strtoul (ptr, &ptr, 16);
if (grub_errno == GRUB_ERR_BAD_NUMBER) if (grub_errno == GRUB_ERR_BAD_NUMBER)
{ {
grub_errno = GRUB_ERR_NONE; grub_errno = GRUB_ERR_NONE;
@ -225,7 +224,7 @@ grub_cmd_setpci (grub_extcmd_context_t ctxt, int argc, char **argv)
if (*ptr == '.') if (*ptr == '.')
{ {
ptr++; ptr++;
function = grub_strtoul (ptr, (char **) &ptr, 16); function = grub_strtoul (ptr, &ptr, 16);
if (grub_errno) if (grub_errno)
return grub_errno; return grub_errno;
check_function = 1; check_function = 1;
@ -253,7 +252,7 @@ grub_cmd_setpci (grub_extcmd_context_t ctxt, int argc, char **argv)
if (i == ARRAY_SIZE (pci_registers)) if (i == ARRAY_SIZE (pci_registers))
{ {
regsize = 0; regsize = 0;
regaddr = grub_strtoul (ptr, (char **) &ptr, 16); regaddr = grub_strtoul (ptr, &ptr, 16);
if (grub_errno) if (grub_errno)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "unknown register"); return grub_error (GRUB_ERR_BAD_ARGUMENT, "unknown register");
} }
@ -270,7 +269,7 @@ grub_cmd_setpci (grub_extcmd_context_t ctxt, int argc, char **argv)
if (*ptr == '+') if (*ptr == '+')
{ {
ptr++; ptr++;
regaddr += grub_strtoul (ptr, (char **) &ptr, 16); regaddr += grub_strtoul (ptr, &ptr, 16);
if (grub_errno) if (grub_errno)
return grub_errno; return grub_errno;
} }
@ -302,14 +301,14 @@ grub_cmd_setpci (grub_extcmd_context_t ctxt, int argc, char **argv)
if (*ptr == '=') if (*ptr == '=')
{ {
ptr++; ptr++;
regwrite = grub_strtoul (ptr, (char **) &ptr, 16); regwrite = grub_strtoul (ptr, &ptr, 16);
if (grub_errno) if (grub_errno)
return grub_errno; return grub_errno;
write_mask = 0xffffffff; write_mask = 0xffffffff;
if (*ptr == ':') if (*ptr == ':')
{ {
ptr++; ptr++;
write_mask = grub_strtoul (ptr, (char **) &ptr, 16); write_mask = grub_strtoul (ptr, &ptr, 16);
if (grub_errno) if (grub_errno)
return grub_errno; return grub_errno;
write_mask = 0xffffffff; write_mask = 0xffffffff;

2
grub-core/commands/sleep.c
View file

@ -55,7 +55,7 @@ grub_interruptible_millisleep (grub_uint32_t ms)
start = grub_get_time_ms (); start = grub_get_time_ms ();
while (grub_get_time_ms () - start < ms) while (grub_get_time_ms () - start < ms)
if (grub_getkey_noblock () == GRUB_TERM_ESC) if (grub_key_is_interrupt (grub_getkey_noblock ()))
return 1; return 1;
return 0; return 0;

120
grub-core/commands/smbios.c
View file

@ -1,7 +1,7 @@
/* smbios.c - retrieve smbios information. */ /* smbios.c - retrieve smbios information. */
/* /*
* GRUB -- GRand Unified Bootloader * GRUB -- GRand Unified Bootloader
* Copyright (C) 2013,2014,2015 Free Software Foundation, Inc. * Copyright (C) 2019 Free Software Foundation, Inc.
* *
* GRUB is free software: you can redistribute it and/or modify * GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
@ -27,86 +27,111 @@
GRUB_MOD_LICENSE ("GPLv3+"); GRUB_MOD_LICENSE ("GPLv3+");
/* Abstract useful values found in either the SMBIOS3 or SMBIOS EPS. */
static struct {
grub_addr_t start;
grub_addr_t end;
grub_uint16_t structures;
} table_desc;
static grub_extcmd_t cmd;
/* Locate the SMBIOS entry point structure depending on the hardware. */ /* Locate the SMBIOS entry point structure depending on the hardware. */
struct grub_smbios_eps * struct grub_smbios_eps *
grub_smbios_get_eps (void) grub_smbios_get_eps (void)
{ {
static struct grub_smbios_eps *eps = NULL; static struct grub_smbios_eps *eps = NULL;
if (eps != NULL) if (eps != NULL)
return eps; return eps;
eps = grub_machine_smbios_get_eps (); eps = grub_machine_smbios_get_eps ();
return eps; return eps;
} }
/* Locate the SMBIOS3 entry point structure depending on the hardware. */ /* Locate the SMBIOS3 entry point structure depending on the hardware. */
struct grub_smbios_eps3 * static struct grub_smbios_eps3 *
grub_smbios_get_eps3 (void) grub_smbios_get_eps3 (void)
{ {
static struct grub_smbios_eps3 *eps = NULL; static struct grub_smbios_eps3 *eps = NULL;
if (eps != NULL) if (eps != NULL)
return eps; return eps;
eps = grub_machine_smbios_get_eps3 (); eps = grub_machine_smbios_get_eps3 ();
return eps; return eps;
} }
/* Abstract useful values found in either the SMBIOS3 or SMBIOS EPS. */ static char *
static struct { linux_string (const char *value)
grub_addr_t start; {
grub_addr_t end; char *out = grub_malloc( grub_strlen (value) + 1);
grub_uint16_t structures; const char *src = value;
} table_desc = {0, 0, 0}; char *dst = out;
for (; *src; src++)
if (*src > ' ' && *src < 127 && *src != ':')
*dst++ = *src;
*dst = 0;
return out;
}
/* /*
* These functions convert values from the various SMBIOS structure field types * These functions convert values from the various SMBIOS structure field types
* into a string formatted to be returned to the user. They expect that the * into a string formatted to be returned to the user. They expect that the
* structure and offset were already validated. The given buffer stores the * structure and offset were already validated. When the requested data is
* newly formatted string if needed. When the requested data is successfully * successfully retrieved and formatted, the pointer to the string is returned;
* retrieved and formatted, the pointer to the string is returned; otherwise, * otherwise, NULL is returned on failure. Don't free the result.
* NULL is returned on failure.
*/ */
static const char * static const char *
grub_smbios_format_byte (char *buffer, grub_size_t size, grub_smbios_format_byte (const grub_uint8_t *structure, grub_uint8_t offset)
const grub_uint8_t *structure, grub_uint8_t offset)
{ {
grub_snprintf (buffer, size, "%u", structure[offset]); static char buffer[sizeof ("255")];
grub_snprintf (buffer, sizeof (buffer), "%u", structure[offset]);
return (const char *)buffer; return (const char *)buffer;
} }
static const char * static const char *
grub_smbios_format_word (char *buffer, grub_size_t size, grub_smbios_format_word (const grub_uint8_t *structure, grub_uint8_t offset)
const grub_uint8_t *structure, grub_uint8_t offset)
{ {
static char buffer[sizeof ("65535")];
grub_uint16_t value = grub_get_unaligned16 (structure + offset); grub_uint16_t value = grub_get_unaligned16 (structure + offset);
grub_snprintf (buffer, size, "%u", value); grub_snprintf (buffer, sizeof (buffer), "%u", value);
return (const char *)buffer; return (const char *)buffer;
} }
static const char * static const char *
grub_smbios_format_dword (char *buffer, grub_size_t size, grub_smbios_format_dword (const grub_uint8_t *structure, grub_uint8_t offset)
const grub_uint8_t *structure, grub_uint8_t offset)
{ {
static char buffer[sizeof ("4294967295")];
grub_uint32_t value = grub_get_unaligned32 (structure + offset); grub_uint32_t value = grub_get_unaligned32 (structure + offset);
grub_snprintf (buffer, size, "%" PRIuGRUB_UINT32_T, value); grub_snprintf (buffer, sizeof (buffer), "%" PRIuGRUB_UINT32_T, value);
return (const char *)buffer; return (const char *)buffer;
} }
static const char * static const char *
grub_smbios_format_qword (char *buffer, grub_size_t size, grub_smbios_format_qword (const grub_uint8_t *structure, grub_uint8_t offset)
const grub_uint8_t *structure, grub_uint8_t offset)
{ {
static char buffer[sizeof ("18446744073709551615")];
grub_uint64_t value = grub_get_unaligned64 (structure + offset); grub_uint64_t value = grub_get_unaligned64 (structure + offset);
grub_snprintf (buffer, size, "%" PRIuGRUB_UINT64_T, value); grub_snprintf (buffer, sizeof (buffer), "%" PRIuGRUB_UINT64_T, value);
return (const char *)buffer; return (const char *)buffer;
} }
/* The matching string pointer is returned directly to avoid extra copying. */
static const char * static const char *
grub_smbios_get_string (char *buffer __attribute__ ((unused)), grub_smbios_get_string (const grub_uint8_t *structure, grub_uint8_t offset)
grub_size_t size __attribute__ ((unused)),
const grub_uint8_t *structure, grub_uint8_t offset)
{ {
const grub_uint8_t *ptr = structure + structure[1]; const grub_uint8_t *ptr = structure + structure[1];
const grub_uint8_t *table_end = (const grub_uint8_t *)table_desc.end; const grub_uint8_t *table_end = (const grub_uint8_t *)table_desc.end;
@ -135,25 +160,24 @@ grub_smbios_get_string (char *buffer __attribute__ ((unused)),
} }
static const char * static const char *
grub_smbios_format_uuid (char *buffer, grub_size_t size, grub_smbios_format_uuid (const grub_uint8_t *structure, grub_uint8_t offset)
const grub_uint8_t *structure, grub_uint8_t offset)
{ {
static char buffer[sizeof ("ffffffff-ffff-ffff-ffff-ffffffffffff")];
const grub_uint8_t *f = structure + offset; /* little-endian fields */ const grub_uint8_t *f = structure + offset; /* little-endian fields */
const grub_uint8_t *g = f + 8; /* byte-by-byte fields */ const grub_uint8_t *g = f + 8; /* byte-by-byte fields */
grub_snprintf (buffer, size,
grub_snprintf (buffer, sizeof (buffer),
"%02x%02x%02x%02x-%02x%02x-%02x%02x-" "%02x%02x%02x%02x-%02x%02x-%02x%02x-"
"%02x%02x-%02x%02x%02x%02x%02x%02x", "%02x%02x-%02x%02x%02x%02x%02x%02x",
f[3], f[2], f[1], f[0], f[5], f[4], f[7], f[6], f[3], f[2], f[1], f[0], f[5], f[4], f[7], f[6],
g[0], g[1], g[2], g[3], g[4], g[5], g[6], g[7]); g[0], g[1], g[2], g[3], g[4], g[5], g[6], g[7]);
return (const char *)buffer; return (const char *)buffer;
} }
/* List the field formatting functions and the number of bytes they need. */ /* List the field formatting functions and the number of bytes they need. */
#define MAXIMUM_FORMAT_LENGTH (sizeof ("ffffffff-ffff-ffff-ffff-ffffffffffff"))
static const struct { static const struct {
const char *(*format) (char *buffer, grub_size_t size, const char *(*format) (const grub_uint8_t *structure, grub_uint8_t offset);
const grub_uint8_t *structure, grub_uint8_t offset);
grub_uint8_t field_length; grub_uint8_t field_length;
} field_extractors[] = { } field_extractors[] = {
{grub_smbios_format_byte, 1}, {grub_smbios_format_byte, 1},
@ -167,10 +191,12 @@ static const struct {
/* List command options, with structure field getters ordered as above. */ /* List command options, with structure field getters ordered as above. */
#define FIRST_GETTER_OPT (3) #define FIRST_GETTER_OPT (3)
#define SETTER_OPT (FIRST_GETTER_OPT + ARRAY_SIZE(field_extractors)) #define SETTER_OPT (FIRST_GETTER_OPT + ARRAY_SIZE(field_extractors))
#define LINUX_OPT (FIRST_GETTER_OPT + ARRAY_SIZE(field_extractors) + 1)
static const struct grub_arg_option options[] = { static const struct grub_arg_option options[] = {
{"type", 't', 0, N_("Match entries with the given type."), {"type", 't', 0, N_("Match structures with the given type."),
N_("type"), ARG_TYPE_INT}, N_("type"), ARG_TYPE_INT},
{"handle", 'h', 0, N_("Match entries with the given handle."), {"handle", 'h', 0, N_("Match structures with the given handle."),
N_("handle"), ARG_TYPE_INT}, N_("handle"), ARG_TYPE_INT},
{"match", 'm', 0, N_("Select a structure when several match."), {"match", 'm', 0, N_("Select a structure when several match."),
N_("match"), ARG_TYPE_INT}, N_("match"), ARG_TYPE_INT},
@ -188,10 +214,11 @@ static const struct grub_arg_option options[] = {
N_("offset"), ARG_TYPE_INT}, N_("offset"), ARG_TYPE_INT},
{"set", '\0', 0, N_("Store the value in the given variable name."), {"set", '\0', 0, N_("Store the value in the given variable name."),
N_("variable"), ARG_TYPE_STRING}, N_("variable"), ARG_TYPE_STRING},
{"linux", '\0', 0, N_("Filter the result like linux does."),
N_("variable"), ARG_TYPE_NONE},
{0, 0, 0, 0, 0, 0} {0, 0, 0, 0, 0, 0}
}; };
/* /*
* Return a matching SMBIOS structure. * Return a matching SMBIOS structure.
* *
@ -225,7 +252,6 @@ grub_smbios_match_structure (const grub_int16_t type,
&& (type < 0 || type == structure_type) && (type < 0 || type == structure_type)
&& (match == 0 || match == ++matches)) && (match == 0 || match == ++matches))
return ptr; return ptr;
else else
{ {
ptr += ptr[1]; ptr += ptr[1];
@ -239,7 +265,6 @@ grub_smbios_match_structure (const grub_int16_t type,
return NULL; return NULL;
} }
static grub_err_t static grub_err_t
grub_cmd_smbios (grub_extcmd_context_t ctxt, grub_cmd_smbios (grub_extcmd_context_t ctxt,
int argc __attribute__ ((unused)), int argc __attribute__ ((unused)),
@ -254,7 +279,7 @@ grub_cmd_smbios (grub_extcmd_context_t ctxt,
const grub_uint8_t *structure; const grub_uint8_t *structure;
const char *value; const char *value;
char buffer[MAXIMUM_FORMAT_LENGTH]; char *modified_value = NULL;
grub_int32_t option; grub_int32_t option;
grub_int8_t field_type = -1; grub_int8_t field_type = -1;
grub_uint8_t i; grub_uint8_t i;
@ -283,7 +308,7 @@ grub_cmd_smbios (grub_extcmd_context_t ctxt,
if (state[2].set) if (state[2].set)
{ {
option = grub_strtol (state[2].arg, NULL, 0); option = grub_strtol (state[2].arg, NULL, 0);
if (option <= 0) if (option <= 0 || option > 65535)
return grub_error (GRUB_ERR_BAD_ARGUMENT, return grub_error (GRUB_ERR_BAD_ARGUMENT,
N_("the match must be a positive integer")); N_("the match must be a positive integer"));
match = (grub_uint16_t)option; match = (grub_uint16_t)option;
@ -323,24 +348,25 @@ grub_cmd_smbios (grub_extcmd_context_t ctxt,
N_("the field ends outside the structure")); N_("the field ends outside the structure"));
/* Format the requested structure field into a readable string. */ /* Format the requested structure field into a readable string. */
value = field_extractors[field_type].format (buffer, sizeof (buffer), value = field_extractors[field_type].format (structure, offset);
structure, offset);
if (value == NULL) if (value == NULL)
return grub_error (GRUB_ERR_IO, return grub_error (GRUB_ERR_IO,
N_("failed to retrieve the structure field")); N_("failed to retrieve the structure field"));
if (state[LINUX_OPT].set)
value = modified_value = linux_string (value);
/* Store or print the formatted value. */ /* Store or print the formatted value. */
if (state[SETTER_OPT].set) if (state[SETTER_OPT].set)
grub_env_set (state[SETTER_OPT].arg, value); grub_env_set (state[SETTER_OPT].arg, value);
else else
grub_printf ("%s\n", value); grub_printf ("%s\n", value);
grub_free(modified_value);
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
} }
static grub_extcmd_t cmd;
GRUB_MOD_INIT(smbios) GRUB_MOD_INIT(smbios)
{ {
struct grub_smbios_eps3 *eps3; struct grub_smbios_eps3 *eps3;

2
grub-core/commands/test.c
View file

@ -31,7 +31,7 @@ GRUB_MOD_LICENSE ("GPLv3+");
/* A simple implementation for signed numbers. */ /* A simple implementation for signed numbers. */
static int static int
grub_strtosl (char *arg, char **end, int base) grub_strtosl (char *arg, const char ** const end, int base)
{ {
if (arg[0] == '-') if (arg[0] == '-')
return -grub_strtoul (arg + 1, end, base); return -grub_strtoul (arg + 1, end, base);

7
grub-core/commands/tpm.c
View file

@ -29,13 +29,6 @@
GRUB_MOD_LICENSE ("GPLv3+"); GRUB_MOD_LICENSE ("GPLv3+");
grub_err_t
grub_tpm_measure (unsigned char *buf, grub_size_t size, grub_uint8_t pcr,
const char *description)
{
return grub_tpm_log_event (buf, size, pcr, description);
}
static grub_err_t static grub_err_t
grub_tpm_verify_init (grub_file_t io, grub_tpm_verify_init (grub_file_t io,
enum grub_file_type type __attribute__ ((unused)), enum grub_file_type type __attribute__ ((unused)),

4
grub-core/commands/verifiers.c
View file

@ -196,6 +196,7 @@ grub_verifiers_open (grub_file_t io, enum grub_file_type type)
return ret; return ret;
fail: fail:
if (ver->close)
ver->close (context); ver->close (context);
fail_noclose: fail_noclose:
verified_free (verified); verified_free (verified);
@ -207,6 +208,9 @@ grub_err_t
grub_verify_string (char *str, enum grub_verify_string_type type) grub_verify_string (char *str, enum grub_verify_string_type type)
{ {
struct grub_file_verifier *ver; struct grub_file_verifier *ver;
grub_dprintf ("verify", "string: %s, type: %d\n", str, type);
FOR_LIST_ELEMENTS(ver, grub_file_verifiers) FOR_LIST_ELEMENTS(ver, grub_file_verifiers)
{ {
grub_err_t err; grub_err_t err;

2
grub-core/commands/videoinfo.c
View file

@ -136,7 +136,7 @@ grub_cmd_videoinfo (grub_command_t cmd __attribute__ ((unused)),
ctx.height = ctx.width = ctx.depth = 0; ctx.height = ctx.width = ctx.depth = 0;
if (argc) if (argc)
{ {
char *ptr; const char *ptr;
ptr = args[0]; ptr = args[0];
ctx.width = grub_strtoul (ptr, &ptr, 0); ctx.width = grub_strtoul (ptr, &ptr, 0);
if (grub_errno) if (grub_errno)

36
grub-core/commands/wildcard.c
View file

@ -23,6 +23,7 @@
#include <grub/file.h> #include <grub/file.h>
#include <grub/device.h> #include <grub/device.h>
#include <grub/script_sh.h> #include <grub/script_sh.h>
#include <grub/safemath.h>
#include <regex.h> #include <regex.h>
@ -48,6 +49,7 @@ merge (char **dest, char **ps)
int i; int i;
int j; int j;
char **p; char **p;
grub_size_t sz;
if (! dest) if (! dest)
return ps; return ps;
@ -60,7 +62,12 @@ merge (char **dest, char **ps)
for (j = 0; ps[j]; j++) for (j = 0; ps[j]; j++)
; ;
p = grub_realloc (dest, sizeof (char*) * (i + j + 1)); if (grub_add (i, j, &sz) ||
grub_add (sz, 1, &sz) ||
grub_mul (sz, sizeof (char *), &sz))
return dest;
p = grub_realloc (dest, sz);
if (! p) if (! p)
{ {
grub_free (dest); grub_free (dest);
@ -115,8 +122,15 @@ make_regex (const char *start, const char *end, regex_t *regexp)
char ch; char ch;
int i = 0; int i = 0;
unsigned len = end - start; unsigned len = end - start;
char *buffer = grub_malloc (len * 2 + 2 + 1); /* worst case size. */ char *buffer;
grub_size_t sz;
/* Worst case size is (len * 2 + 2 + 1). */
if (grub_mul (len, 2, &sz) ||
grub_add (sz, 3, &sz))
return 1;
buffer = grub_malloc (sz);
if (! buffer) if (! buffer)
return 1; return 1;
@ -226,6 +240,7 @@ match_devices_iter (const char *name, void *data)
struct match_devices_ctx *ctx = data; struct match_devices_ctx *ctx = data;
char **t; char **t;
char *buffer; char *buffer;
grub_size_t sz;
/* skip partitions if asked to. */ /* skip partitions if asked to. */
if (ctx->noparts && grub_strchr (name, ',')) if (ctx->noparts && grub_strchr (name, ','))
@ -239,11 +254,16 @@ match_devices_iter (const char *name, void *data)
if (regexec (ctx->regexp, buffer, 0, 0, 0)) if (regexec (ctx->regexp, buffer, 0, 0, 0))
{ {
grub_dprintf ("expand", "not matched\n"); grub_dprintf ("expand", "not matched\n");
fail:
grub_free (buffer); grub_free (buffer);
return 0; return 0;
} }
t = grub_realloc (ctx->devs, sizeof (char*) * (ctx->ndev + 2)); if (grub_add (ctx->ndev, 2, &sz) ||
grub_mul (sz, sizeof (char *), &sz))
goto fail;
t = grub_realloc (ctx->devs, sz);
if (! t) if (! t)
{ {
grub_free (buffer); grub_free (buffer);
@ -300,6 +320,7 @@ match_files_iter (const char *name,
struct match_files_ctx *ctx = data; struct match_files_ctx *ctx = data;
char **t; char **t;
char *buffer; char *buffer;
grub_size_t sz;
/* skip . and .. names */ /* skip . and .. names */
if (grub_strcmp(".", name) == 0 || grub_strcmp("..", name) == 0) if (grub_strcmp(".", name) == 0 || grub_strcmp("..", name) == 0)
@ -315,9 +336,14 @@ match_files_iter (const char *name,
if (! buffer) if (! buffer)
return 1; return 1;
t = grub_realloc (ctx->files, sizeof (char*) * (ctx->nfile + 2)); if (grub_add (ctx->nfile, 2, &sz) ||
if (! t) grub_mul (sz, sizeof (char *), &sz))
goto fail;
t = grub_realloc (ctx->files, sz);
if (!t)
{ {
fail:
grub_free (buffer); grub_free (buffer);
return 1; return 1;
} }

3
grub-core/disk/AFSplitter.c
View file

@ -21,9 +21,12 @@
*/ */
#include <grub/crypto.h> #include <grub/crypto.h>
#include <grub/dl.h>
#include <grub/mm.h> #include <grub/mm.h>
#include <grub/misc.h> #include <grub/misc.h>
GRUB_MOD_LICENSE ("GPLv2+");
gcry_err_code_t AF_merge (const gcry_md_spec_t * hash, grub_uint8_t * src, gcry_err_code_t AF_merge (const gcry_md_spec_t * hash, grub_uint8_t * src,
grub_uint8_t * dst, grub_size_t blocksize, grub_uint8_t * dst, grub_size_t blocksize,
grub_size_t blocknumbers); grub_size_t blocknumbers);

175
grub-core/disk/cryptodisk.c
View file

@ -1,6 +1,6 @@
/* /*
* GRUB -- GRand Unified Bootloader * GRUB -- GRand Unified Bootloader
* Copyright (C) 2003,2007,2010,2011 Free Software Foundation, Inc. * Copyright (C) 2003,2007,2010,2011,2019 Free Software Foundation, Inc.
* *
* GRUB is free software: you can redistribute it and/or modify * GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
@ -404,6 +404,167 @@ grub_cryptodisk_decrypt (struct grub_cryptodisk *dev,
return grub_cryptodisk_endecrypt (dev, data, len, sector, 0); return grub_cryptodisk_endecrypt (dev, data, len, sector, 0);
} }
grub_err_t
grub_cryptodisk_setcipher (grub_cryptodisk_t crypt, const char *ciphername, const char *ciphermode)
{
const char *cipheriv = NULL;
grub_crypto_cipher_handle_t cipher = NULL, secondary_cipher = NULL;
grub_crypto_cipher_handle_t essiv_cipher = NULL;
const gcry_md_spec_t *essiv_hash = NULL;
const struct gcry_cipher_spec *ciph;
grub_cryptodisk_mode_t mode;
grub_cryptodisk_mode_iv_t mode_iv = GRUB_CRYPTODISK_MODE_IV_PLAIN64;
int benbi_log = 0;
grub_err_t ret = GRUB_ERR_NONE;
ciph = grub_crypto_lookup_cipher_by_name (ciphername);
if (!ciph)
{
ret = grub_error (GRUB_ERR_FILE_NOT_FOUND, "Cipher %s isn't available",
ciphername);
goto err;
}
/* Configure the cipher used for the bulk data. */
cipher = grub_crypto_cipher_open (ciph);
if (!cipher)
{
ret = grub_error (GRUB_ERR_FILE_NOT_FOUND, "Cipher %s could not be initialized",
ciphername);
goto err;
}
/* Configure the cipher mode. */
if (grub_strcmp (ciphermode, "ecb") == 0)
{
mode = GRUB_CRYPTODISK_MODE_ECB;
mode_iv = GRUB_CRYPTODISK_MODE_IV_PLAIN;
cipheriv = NULL;
}
else if (grub_strcmp (ciphermode, "plain") == 0)
{
mode = GRUB_CRYPTODISK_MODE_CBC;
mode_iv = GRUB_CRYPTODISK_MODE_IV_PLAIN;
cipheriv = NULL;
}
else if (grub_memcmp (ciphermode, "cbc-", sizeof ("cbc-") - 1) == 0)
{
mode = GRUB_CRYPTODISK_MODE_CBC;
cipheriv = ciphermode + sizeof ("cbc-") - 1;
}
else if (grub_memcmp (ciphermode, "pcbc-", sizeof ("pcbc-") - 1) == 0)
{
mode = GRUB_CRYPTODISK_MODE_PCBC;
cipheriv = ciphermode + sizeof ("pcbc-") - 1;
}
else if (grub_memcmp (ciphermode, "xts-", sizeof ("xts-") - 1) == 0)
{
mode = GRUB_CRYPTODISK_MODE_XTS;
cipheriv = ciphermode + sizeof ("xts-") - 1;
secondary_cipher = grub_crypto_cipher_open (ciph);
if (!secondary_cipher)
{
ret = grub_error (GRUB_ERR_FILE_NOT_FOUND,
"Secondary cipher %s isn't available", ciphername);
goto err;
}
if (cipher->cipher->blocksize != GRUB_CRYPTODISK_GF_BYTES)
{
ret = grub_error (GRUB_ERR_BAD_ARGUMENT, "Unsupported XTS block size: %d",
cipher->cipher->blocksize);
goto err;
}
if (secondary_cipher->cipher->blocksize != GRUB_CRYPTODISK_GF_BYTES)
{
ret = grub_error (GRUB_ERR_BAD_ARGUMENT, "Unsupported XTS block size: %d",
secondary_cipher->cipher->blocksize);
goto err;
}
}
else if (grub_memcmp (ciphermode, "lrw-", sizeof ("lrw-") - 1) == 0)
{
mode = GRUB_CRYPTODISK_MODE_LRW;
cipheriv = ciphermode + sizeof ("lrw-") - 1;
if (cipher->cipher->blocksize != GRUB_CRYPTODISK_GF_BYTES)
{
ret = grub_error (GRUB_ERR_BAD_ARGUMENT, "Unsupported LRW block size: %d",
cipher->cipher->blocksize);
goto err;
}
}
else
{
ret = grub_error (GRUB_ERR_BAD_ARGUMENT, "Unknown cipher mode: %s",
ciphermode);
goto err;
}
if (cipheriv == NULL)
;
else if (grub_memcmp (cipheriv, "plain", sizeof ("plain") - 1) == 0)
mode_iv = GRUB_CRYPTODISK_MODE_IV_PLAIN;
else if (grub_memcmp (cipheriv, "plain64", sizeof ("plain64") - 1) == 0)
mode_iv = GRUB_CRYPTODISK_MODE_IV_PLAIN64;
else if (grub_memcmp (cipheriv, "benbi", sizeof ("benbi") - 1) == 0)
{
if (cipher->cipher->blocksize & (cipher->cipher->blocksize - 1)
|| cipher->cipher->blocksize == 0)
grub_error (GRUB_ERR_BAD_ARGUMENT, "Unsupported benbi blocksize: %d",
cipher->cipher->blocksize);
/* FIXME should we return an error here? */
for (benbi_log = 0;
(cipher->cipher->blocksize << benbi_log) < GRUB_DISK_SECTOR_SIZE;
benbi_log++);
mode_iv = GRUB_CRYPTODISK_MODE_IV_BENBI;
}
else if (grub_memcmp (cipheriv, "null", sizeof ("null") - 1) == 0)
mode_iv = GRUB_CRYPTODISK_MODE_IV_NULL;
else if (grub_memcmp (cipheriv, "essiv:", sizeof ("essiv:") - 1) == 0)
{
const char *hash_str = cipheriv + 6;
mode_iv = GRUB_CRYPTODISK_MODE_IV_ESSIV;
/* Configure the hash and cipher used for ESSIV. */
essiv_hash = grub_crypto_lookup_md_by_name (hash_str);
if (!essiv_hash)
{
ret = grub_error (GRUB_ERR_FILE_NOT_FOUND,
"Couldn't load %s hash", hash_str);
goto err;
}
essiv_cipher = grub_crypto_cipher_open (ciph);
if (!essiv_cipher)
{
ret = grub_error (GRUB_ERR_FILE_NOT_FOUND,
"Couldn't load %s cipher", ciphername);
goto err;
}
}
else
{
ret = grub_error (GRUB_ERR_BAD_ARGUMENT, "Unknown IV mode: %s",
cipheriv);
goto err;
}
crypt->cipher = cipher;
crypt->benbi_log = benbi_log;
crypt->mode = mode;
crypt->mode_iv = mode_iv;
crypt->secondary_cipher = secondary_cipher;
crypt->essiv_cipher = essiv_cipher;
crypt->essiv_hash = essiv_hash;
err:
if (ret)
{
grub_crypto_cipher_close (cipher);
grub_crypto_cipher_close (secondary_cipher);
}
return ret;
}
gcry_err_code_t gcry_err_code_t
grub_cryptodisk_setkey (grub_cryptodisk_t dev, grub_uint8_t *key, grub_size_t keysize) grub_cryptodisk_setkey (grub_cryptodisk_t dev, grub_uint8_t *key, grub_size_t keysize)
{ {
@ -596,9 +757,8 @@ grub_cryptodisk_read (grub_disk_t disk, grub_disk_addr_t sector,
size, sector, dev->offset); size, sector, dev->offset);
err = grub_disk_read (dev->source_disk, err = grub_disk_read (dev->source_disk,
(sector << (disk->log_sector_size grub_disk_from_native_sector (disk, sector + dev->offset),
- GRUB_DISK_SECTOR_BITS)) + dev->offset, 0, 0, size << disk->log_sector_size, buf);
size << disk->log_sector_size, buf);
if (err) if (err)
{ {
grub_dprintf ("cryptodisk", "grub_disk_read failed with error %d\n", err); grub_dprintf ("cryptodisk", "grub_disk_read failed with error %d\n", err);
@ -655,12 +815,10 @@ grub_cryptodisk_write (grub_disk_t disk, grub_disk_addr_t sector,
} }
/* Since ->write was called so disk.mod is loaded but be paranoid */ /* Since ->write was called so disk.mod is loaded but be paranoid */
sector = sector + dev->offset;
if (grub_disk_write_weak) if (grub_disk_write_weak)
err = grub_disk_write_weak (dev->source_disk, err = grub_disk_write_weak (dev->source_disk,
(sector << (disk->log_sector_size grub_disk_from_native_sector (disk, sector),
- GRUB_DISK_SECTOR_BITS))
+ dev->offset,
0, size << disk->log_sector_size, tmp); 0, size << disk->log_sector_size, tmp);
else else
err = grub_error (GRUB_ERR_BUG, "disk.mod not loaded"); err = grub_error (GRUB_ERR_BUG, "disk.mod not loaded");
@ -1150,5 +1308,6 @@ GRUB_MOD_FINI (cryptodisk)
{ {
grub_disk_dev_unregister (&grub_cryptodisk_dev); grub_disk_dev_unregister (&grub_cryptodisk_dev);
cryptodisk_cleanup (); cryptodisk_cleanup ();
grub_unregister_extcmd (cmd);
grub_procfs_unregister (&luks_script); grub_procfs_unregister (&luks_script);
} }

7
grub-core/disk/diskfilter.c
View file

@ -969,7 +969,8 @@ grub_diskfilter_vg_register (struct grub_diskfilter_vg *vg)
for (p = vgp->lvs; p; p = p->next) for (p = vgp->lvs; p; p = p->next)
{ {
int cur_num; int cur_num;
char *num, *end; char *num;
const char *end;
if (!p->fullname) if (!p->fullname)
continue; continue;
if (grub_strncmp (p->fullname, lv->fullname, len) != 0) if (grub_strncmp (p->fullname, lv->fullname, len) != 0)
@ -1134,7 +1135,7 @@ grub_diskfilter_make_raid (grub_size_t uuidlen, char *uuid, int nmemb,
array->lvs->segments->node_count = nmemb; array->lvs->segments->node_count = nmemb;
array->lvs->segments->raid_member_size = disk_size; array->lvs->segments->raid_member_size = disk_size;
array->lvs->segments->nodes array->lvs->segments->nodes
= grub_zalloc (nmemb * sizeof (array->lvs->segments->nodes[0])); = grub_calloc (nmemb, sizeof (array->lvs->segments->nodes[0]));
array->lvs->segments->stripe_size = stripe_size; array->lvs->segments->stripe_size = stripe_size;
for (i = 0; i < nmemb; i++) for (i = 0; i < nmemb; i++)
{ {
@ -1226,7 +1227,7 @@ insert_array (grub_disk_t disk, const struct grub_diskfilter_pv_id *id,
grub_partition_t p; grub_partition_t p;
for (p = disk->partition; p; p = p->parent) for (p = disk->partition; p; p = p->parent)
s++; s++;
pv->partmaps = xmalloc (s * sizeof (pv->partmaps[0])); pv->partmaps = xcalloc (s, sizeof (pv->partmaps[0]));
s = 0; s = 0;
for (p = disk->partition; p; p = p->parent) for (p = disk->partition; p; p = p->parent)
pv->partmaps[s++] = xstrdup (p->partmap->name); pv->partmaps[s++] = xstrdup (p->partmap->name);

25
grub-core/disk/i386/pc/biosdisk.c
View file

@ -278,14 +278,10 @@ grub_biosdisk_call_hook (grub_disk_dev_iterate_hook_t hook, void *hook_data,
char name[10]; char name[10];
if (cd_drive && drive == cd_drive) if (cd_drive && drive == cd_drive)
{
grub_dprintf ("biosdisk", "iterating cd\n");
return hook ("cd", hook_data); return hook ("cd", hook_data);
}
grub_snprintf (name, sizeof (name), grub_snprintf (name, sizeof (name),
(drive & 0x80) ? "hd%d" : "fd%d", drive & (~0x80)); (drive & 0x80) ? "hd%d" : "fd%d", drive & (~0x80));
grub_dprintf ("biosdisk", "iterating %s\n", name);
return hook (name, hook_data); return hook (name, hook_data);
} }
@ -305,7 +301,7 @@ grub_biosdisk_iterate (grub_disk_dev_iterate_hook_t hook, void *hook_data,
if (grub_biosdisk_rw_standard (0x02, drive, 0, 0, 1, 1, if (grub_biosdisk_rw_standard (0x02, drive, 0, 0, 1, 1,
GRUB_MEMORY_MACHINE_SCRATCH_SEG) != 0) GRUB_MEMORY_MACHINE_SCRATCH_SEG) != 0)
{ {
grub_dprintf ("biosdisk", "Read error when probing drive 0x%2x\n", drive); grub_dprintf ("disk", "Read error when probing drive 0x%2x\n", drive);
break; break;
} }
@ -340,8 +336,6 @@ grub_biosdisk_open (const char *name, grub_disk_t disk)
int drive; int drive;
struct grub_biosdisk_data *data; struct grub_biosdisk_data *data;
grub_dprintf ("biosdisk", "opening %s\n", name);
drive = grub_biosdisk_get_drive (name); drive = grub_biosdisk_get_drive (name);
if (drive < 0) if (drive < 0)
return grub_errno; return grub_errno;
@ -399,11 +393,6 @@ grub_biosdisk_open (const char *name, grub_disk_t disk)
(1 << disk->log_sector_size) < drp->bytes_per_sector; (1 << disk->log_sector_size) < drp->bytes_per_sector;
disk->log_sector_size++); disk->log_sector_size++);
} }
grub_dprintf ("biosdisk",
"LBA total = 0x%llx block size = 0x%lx\n",
(unsigned long long) total_sectors,
1L << disk->log_sector_size);
} }
} }
} }
@ -439,9 +428,6 @@ grub_biosdisk_open (const char *name, grub_disk_t disk)
if (! total_sectors) if (! total_sectors)
total_sectors = ((grub_uint64_t) data->cylinders) total_sectors = ((grub_uint64_t) data->cylinders)
* data->heads * data->sectors; * data->heads * data->sectors;
grub_dprintf ("biosdisk", "C/H/S %lu/%lu/%lu\n",
data->cylinders, data->heads, data->sectors);
} }
disk->total_sectors = total_sectors; disk->total_sectors = total_sectors;
@ -454,15 +440,12 @@ grub_biosdisk_open (const char *name, grub_disk_t disk)
disk->data = data; disk->data = data;
grub_dprintf ("biosdisk", "opening %s succeeded\n", name);
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
} }
static void static void
grub_biosdisk_close (grub_disk_t disk) grub_biosdisk_close (grub_disk_t disk)
{ {
grub_dprintf ("biosdisk", "closing %s\n", disk->name);
grub_free (disk->data); grub_free (disk->data);
} }
@ -594,9 +577,6 @@ static grub_err_t
grub_biosdisk_read (grub_disk_t disk, grub_disk_addr_t sector, grub_biosdisk_read (grub_disk_t disk, grub_disk_addr_t sector,
grub_size_t size, char *buf) grub_size_t size, char *buf)
{ {
grub_dprintf ("biosdisk", "reading 0x%lx sectors at 0x%llx from %s\n",
(unsigned long) size, (unsigned long long) sector, disk->name);
while (size) while (size)
{ {
grub_size_t len; grub_size_t len;
@ -627,9 +607,6 @@ grub_biosdisk_write (grub_disk_t disk, grub_disk_addr_t sector,
{ {
struct grub_biosdisk_data *data = disk->data; struct grub_biosdisk_data *data = disk->data;
grub_dprintf ("biosdisk", "writing 0x%lx sectors at 0x%llx to %s\n",
(unsigned long) size, (unsigned long long) sector, disk->name);
if (data->flags & GRUB_BIOSDISK_FLAG_CDROM) if (data->flags & GRUB_BIOSDISK_FLAG_CDROM)
return grub_error (GRUB_ERR_IO, N_("cannot write to CD-ROM")); return grub_error (GRUB_ERR_IO, N_("cannot write to CD-ROM"));

2
grub-core/disk/ieee1275/ofdisk.c
View file

@ -297,7 +297,7 @@ dev_iterate (const struct grub_ieee1275_devalias *alias)
/* Power machines documentation specify 672 as maximum SAS disks in /* Power machines documentation specify 672 as maximum SAS disks in
one system. Using a slightly larger value to be safe. */ one system. Using a slightly larger value to be safe. */
table_size = 768; table_size = 768;
table = grub_malloc (table_size * sizeof (grub_uint64_t)); table = grub_calloc (table_size, sizeof (grub_uint64_t));
if (!table) if (!table)
{ {

46
grub-core/disk/ldm.c
View file

@ -25,6 +25,7 @@
#include <grub/msdos_partition.h> #include <grub/msdos_partition.h>
#include <grub/gpt_partition.h> #include <grub/gpt_partition.h>
#include <grub/i18n.h> #include <grub/i18n.h>
#include <grub/safemath.h>
#ifdef GRUB_UTIL #ifdef GRUB_UTIL
#include <grub/emu/misc.h> #include <grub/emu/misc.h>
@ -289,6 +290,7 @@ make_vg (grub_disk_t disk,
struct grub_ldm_vblk vblk[GRUB_DISK_SECTOR_SIZE struct grub_ldm_vblk vblk[GRUB_DISK_SECTOR_SIZE
/ sizeof (struct grub_ldm_vblk)]; / sizeof (struct grub_ldm_vblk)];
unsigned i; unsigned i;
grub_size_t sz;
err = grub_disk_read (disk, cursec, 0, err = grub_disk_read (disk, cursec, 0,
sizeof(vblk), &vblk); sizeof(vblk), &vblk);
if (err) if (err)
@ -323,8 +325,8 @@ make_vg (grub_disk_t disk,
lv->segments->type = GRUB_DISKFILTER_MIRROR; lv->segments->type = GRUB_DISKFILTER_MIRROR;
lv->segments->node_count = 0; lv->segments->node_count = 0;
lv->segments->node_alloc = 8; lv->segments->node_alloc = 8;
lv->segments->nodes = grub_zalloc (sizeof (*lv->segments->nodes) lv->segments->nodes = grub_calloc (lv->segments->node_alloc,
* lv->segments->node_alloc); sizeof (*lv->segments->nodes));
if (!lv->segments->nodes) if (!lv->segments->nodes)
goto fail2; goto fail2;
ptr = vblk[i].dynamic; ptr = vblk[i].dynamic;
@ -350,7 +352,13 @@ make_vg (grub_disk_t disk,
grub_free (lv); grub_free (lv);
goto fail2; goto fail2;
} }
lv->name = grub_malloc (*ptr + 1); if (grub_add (*ptr, 1, &sz))
{
grub_free (lv->internal_id);
grub_free (lv);
goto fail2;
}
lv->name = grub_malloc (sz);
if (!lv->name) if (!lv->name)
{ {
grub_free (lv->internal_id); grub_free (lv->internal_id);
@ -543,8 +551,8 @@ make_vg (grub_disk_t disk,
{ {
comp->segment_alloc = 8; comp->segment_alloc = 8;
comp->segment_count = 0; comp->segment_count = 0;
comp->segments = grub_malloc (sizeof (*comp->segments) comp->segments = grub_calloc (comp->segment_alloc,
* comp->segment_alloc); sizeof (*comp->segments));
if (!comp->segments) if (!comp->segments)
goto fail2; goto fail2;
} }
@ -590,8 +598,8 @@ make_vg (grub_disk_t disk,
} }
comp->segments->node_count = read_int (ptr + 1, *ptr); comp->segments->node_count = read_int (ptr + 1, *ptr);
comp->segments->node_alloc = comp->segments->node_count; comp->segments->node_alloc = comp->segments->node_count;
comp->segments->nodes = grub_zalloc (sizeof (*comp->segments->nodes) comp->segments->nodes = grub_calloc (comp->segments->node_alloc,
* comp->segments->node_alloc); sizeof (*comp->segments->nodes));
if (!lv->segments->nodes) if (!lv->segments->nodes)
goto fail2; goto fail2;
} }
@ -599,10 +607,13 @@ make_vg (grub_disk_t disk,
if (lv->segments->node_alloc == lv->segments->node_count) if (lv->segments->node_alloc == lv->segments->node_count)
{ {
void *t; void *t;
lv->segments->node_alloc *= 2; grub_size_t sz;
t = grub_realloc (lv->segments->nodes,
sizeof (*lv->segments->nodes) if (grub_mul (lv->segments->node_alloc, 2, &lv->segments->node_alloc) ||
* lv->segments->node_alloc); grub_mul (lv->segments->node_alloc, sizeof (*lv->segments->nodes), &sz))
goto fail2;
t = grub_realloc (lv->segments->nodes, sz);
if (!t) if (!t)
goto fail2; goto fail2;
lv->segments->nodes = t; lv->segments->nodes = t;
@ -723,10 +734,13 @@ make_vg (grub_disk_t disk,
if (comp->segment_alloc == comp->segment_count) if (comp->segment_alloc == comp->segment_count)
{ {
void *t; void *t;
comp->segment_alloc *= 2; grub_size_t sz;
t = grub_realloc (comp->segments,
comp->segment_alloc if (grub_mul (comp->segment_alloc, 2, &comp->segment_alloc) ||
* sizeof (*comp->segments)); grub_mul (comp->segment_alloc, sizeof (*comp->segments), &sz))
goto fail2;
t = grub_realloc (comp->segments, sz);
if (!t) if (!t)
goto fail2; goto fail2;
comp->segments = t; comp->segments = t;
@ -1017,7 +1031,7 @@ grub_util_ldm_embed (struct grub_disk *disk, unsigned int *nsectors,
*nsectors = lv->size; *nsectors = lv->size;
if (*nsectors > max_nsectors) if (*nsectors > max_nsectors)
*nsectors = max_nsectors; *nsectors = max_nsectors;
*sectors = grub_malloc (*nsectors * sizeof (**sectors)); *sectors = grub_calloc (*nsectors, sizeof (**sectors));
if (!*sectors) if (!*sectors)
return grub_errno; return grub_errno;
for (i = 0; i < *nsectors; i++) for (i = 0; i < *nsectors; i++)

193
grub-core/disk/luks.c
View file

@ -1,6 +1,6 @@
/* /*
* GRUB -- GRand Unified Bootloader * GRUB -- GRand Unified Bootloader
* Copyright (C) 2003,2007,2010,2011 Free Software Foundation, Inc. * Copyright (C) 2003,2007,2010,2011,2019 Free Software Foundation, Inc.
* *
* GRUB is free software: you can redistribute it and/or modify * GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
@ -75,15 +75,7 @@ configure_ciphers (grub_disk_t disk, const char *check_uuid,
char uuid[sizeof (header.uuid) + 1]; char uuid[sizeof (header.uuid) + 1];
char ciphername[sizeof (header.cipherName) + 1]; char ciphername[sizeof (header.cipherName) + 1];
char ciphermode[sizeof (header.cipherMode) + 1]; char ciphermode[sizeof (header.cipherMode) + 1];
char *cipheriv = NULL;
char hashspec[sizeof (header.hashSpec) + 1]; char hashspec[sizeof (header.hashSpec) + 1];
grub_crypto_cipher_handle_t cipher = NULL, secondary_cipher = NULL;
grub_crypto_cipher_handle_t essiv_cipher = NULL;
const gcry_md_spec_t *hash = NULL, *essiv_hash = NULL;
const struct gcry_cipher_spec *ciph;
grub_cryptodisk_mode_t mode;
grub_cryptodisk_mode_iv_t mode_iv = GRUB_CRYPTODISK_MODE_IV_PLAIN64;
int benbi_log = 0;
grub_err_t err; grub_err_t err;
if (check_boot) if (check_boot)
@ -103,6 +95,7 @@ configure_ciphers (grub_disk_t disk, const char *check_uuid,
|| grub_be_to_cpu16 (header.version) != 1) || grub_be_to_cpu16 (header.version) != 1)
return NULL; return NULL;
grub_memset (uuid, 0, sizeof (uuid));
optr = uuid; optr = uuid;
for (iptr = header.uuid; iptr < &header.uuid[ARRAY_SIZE (header.uuid)]; for (iptr = header.uuid; iptr < &header.uuid[ARRAY_SIZE (header.uuid)];
iptr++) iptr++)
@ -126,183 +119,33 @@ configure_ciphers (grub_disk_t disk, const char *check_uuid,
grub_memcpy (hashspec, header.hashSpec, sizeof (header.hashSpec)); grub_memcpy (hashspec, header.hashSpec, sizeof (header.hashSpec));
hashspec[sizeof (header.hashSpec)] = 0; hashspec[sizeof (header.hashSpec)] = 0;
ciph = grub_crypto_lookup_cipher_by_name (ciphername); newdev = grub_zalloc (sizeof (struct grub_cryptodisk));
if (!ciph) if (!newdev)
{
grub_error (GRUB_ERR_FILE_NOT_FOUND, "Cipher %s isn't available",
ciphername);
return NULL; return NULL;
} newdev->offset = grub_be_to_cpu32 (header.payloadOffset);
newdev->source_disk = NULL;
/* Configure the cipher used for the bulk data. */ newdev->log_sector_size = 9;
cipher = grub_crypto_cipher_open (ciph); newdev->total_length = grub_disk_get_size (disk) - newdev->offset;
if (!cipher) grub_memcpy (newdev->uuid, uuid, sizeof (uuid));
return NULL; newdev->modname = "luks";
if (grub_be_to_cpu32 (header.keyBytes) > 1024)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid keysize %d",
grub_be_to_cpu32 (header.keyBytes));
grub_crypto_cipher_close (cipher);
return NULL;
}
/* Configure the cipher mode. */
if (grub_strcmp (ciphermode, "ecb") == 0)
{
mode = GRUB_CRYPTODISK_MODE_ECB;
mode_iv = GRUB_CRYPTODISK_MODE_IV_PLAIN;
cipheriv = NULL;
}
else if (grub_strcmp (ciphermode, "plain") == 0)
{
mode = GRUB_CRYPTODISK_MODE_CBC;
mode_iv = GRUB_CRYPTODISK_MODE_IV_PLAIN;
cipheriv = NULL;
}
else if (grub_memcmp (ciphermode, "cbc-", sizeof ("cbc-") - 1) == 0)
{
mode = GRUB_CRYPTODISK_MODE_CBC;
cipheriv = ciphermode + sizeof ("cbc-") - 1;
}
else if (grub_memcmp (ciphermode, "pcbc-", sizeof ("pcbc-") - 1) == 0)
{
mode = GRUB_CRYPTODISK_MODE_PCBC;
cipheriv = ciphermode + sizeof ("pcbc-") - 1;
}
else if (grub_memcmp (ciphermode, "xts-", sizeof ("xts-") - 1) == 0)
{
mode = GRUB_CRYPTODISK_MODE_XTS;
cipheriv = ciphermode + sizeof ("xts-") - 1;
secondary_cipher = grub_crypto_cipher_open (ciph);
if (!secondary_cipher)
{
grub_crypto_cipher_close (cipher);
return NULL;
}
if (cipher->cipher->blocksize != GRUB_CRYPTODISK_GF_BYTES)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "Unsupported XTS block size: %d",
cipher->cipher->blocksize);
grub_crypto_cipher_close (cipher);
grub_crypto_cipher_close (secondary_cipher);
return NULL;
}
if (secondary_cipher->cipher->blocksize != GRUB_CRYPTODISK_GF_BYTES)
{
grub_crypto_cipher_close (cipher);
grub_error (GRUB_ERR_BAD_ARGUMENT, "Unsupported XTS block size: %d",
secondary_cipher->cipher->blocksize);
grub_crypto_cipher_close (secondary_cipher);
return NULL;
}
}
else if (grub_memcmp (ciphermode, "lrw-", sizeof ("lrw-") - 1) == 0)
{
mode = GRUB_CRYPTODISK_MODE_LRW;
cipheriv = ciphermode + sizeof ("lrw-") - 1;
if (cipher->cipher->blocksize != GRUB_CRYPTODISK_GF_BYTES)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "Unsupported LRW block size: %d",
cipher->cipher->blocksize);
grub_crypto_cipher_close (cipher);
return NULL;
}
}
else
{
grub_crypto_cipher_close (cipher);
grub_error (GRUB_ERR_BAD_ARGUMENT, "Unknown cipher mode: %s",
ciphermode);
return NULL;
}
if (cipheriv == NULL);
else if (grub_memcmp (cipheriv, "plain", sizeof ("plain") - 1) == 0)
mode_iv = GRUB_CRYPTODISK_MODE_IV_PLAIN;
else if (grub_memcmp (cipheriv, "plain64", sizeof ("plain64") - 1) == 0)
mode_iv = GRUB_CRYPTODISK_MODE_IV_PLAIN64;
else if (grub_memcmp (cipheriv, "benbi", sizeof ("benbi") - 1) == 0)
{
if (cipher->cipher->blocksize & (cipher->cipher->blocksize - 1)
|| cipher->cipher->blocksize == 0)
grub_error (GRUB_ERR_BAD_ARGUMENT, "Unsupported benbi blocksize: %d",
cipher->cipher->blocksize);
/* FIXME should we return an error here? */
for (benbi_log = 0;
(cipher->cipher->blocksize << benbi_log) < GRUB_DISK_SECTOR_SIZE;
benbi_log++);
mode_iv = GRUB_CRYPTODISK_MODE_IV_BENBI;
}
else if (grub_memcmp (cipheriv, "null", sizeof ("null") - 1) == 0)
mode_iv = GRUB_CRYPTODISK_MODE_IV_NULL;
else if (grub_memcmp (cipheriv, "essiv:", sizeof ("essiv:") - 1) == 0)
{
char *hash_str = cipheriv + 6;
mode_iv = GRUB_CRYPTODISK_MODE_IV_ESSIV;
/* Configure the hash and cipher used for ESSIV. */
essiv_hash = grub_crypto_lookup_md_by_name (hash_str);
if (!essiv_hash)
{
grub_crypto_cipher_close (cipher);
grub_crypto_cipher_close (secondary_cipher);
grub_error (GRUB_ERR_FILE_NOT_FOUND,
"Couldn't load %s hash", hash_str);
return NULL;
}
essiv_cipher = grub_crypto_cipher_open (ciph);
if (!essiv_cipher)
{
grub_crypto_cipher_close (cipher);
grub_crypto_cipher_close (secondary_cipher);
return NULL;
}
}
else
{
grub_crypto_cipher_close (cipher);
grub_crypto_cipher_close (secondary_cipher);
grub_error (GRUB_ERR_BAD_ARGUMENT, "Unknown IV mode: %s",
cipheriv);
return NULL;
}
/* Configure the hash used for the AF splitter and HMAC. */ /* Configure the hash used for the AF splitter and HMAC. */
hash = grub_crypto_lookup_md_by_name (hashspec); newdev->hash = grub_crypto_lookup_md_by_name (hashspec);
if (!hash) if (!newdev->hash)
{ {
grub_crypto_cipher_close (cipher); grub_free (newdev);
grub_crypto_cipher_close (essiv_cipher);
grub_crypto_cipher_close (secondary_cipher);
grub_error (GRUB_ERR_FILE_NOT_FOUND, "Couldn't load %s hash", grub_error (GRUB_ERR_FILE_NOT_FOUND, "Couldn't load %s hash",
hashspec); hashspec);
return NULL; return NULL;
} }
newdev = grub_zalloc (sizeof (struct grub_cryptodisk)); err = grub_cryptodisk_setcipher (newdev, ciphername, ciphermode);
if (!newdev) if (err)
{ {
grub_crypto_cipher_close (cipher); grub_free (newdev);
grub_crypto_cipher_close (essiv_cipher);
grub_crypto_cipher_close (secondary_cipher);
return NULL; return NULL;
} }
newdev->cipher = cipher;
newdev->offset = grub_be_to_cpu32 (header.payloadOffset);
newdev->source_disk = NULL;
newdev->benbi_log = benbi_log;
newdev->mode = mode;
newdev->mode_iv = mode_iv;
newdev->secondary_cipher = secondary_cipher;
newdev->essiv_cipher = essiv_cipher;
newdev->essiv_hash = essiv_hash;
newdev->hash = hash;
newdev->log_sector_size = 9;
newdev->total_length = grub_disk_get_size (disk) - newdev->offset;
grub_memcpy (newdev->uuid, uuid, sizeof (newdev->uuid));
newdev->modname = "luks";
COMPILE_TIME_ASSERT (sizeof (newdev->uuid) >= sizeof (uuid)); COMPILE_TIME_ASSERT (sizeof (newdev->uuid) >= sizeof (uuid));
return newdev; return newdev;
} }
@ -336,7 +179,7 @@ luks_recover_key (grub_disk_t source,
&& grub_be_to_cpu32 (header.keyblock[i].stripes) > max_stripes) && grub_be_to_cpu32 (header.keyblock[i].stripes) > max_stripes)
max_stripes = grub_be_to_cpu32 (header.keyblock[i].stripes); max_stripes = grub_be_to_cpu32 (header.keyblock[i].stripes);
split_key = grub_malloc (keysize * max_stripes); split_key = grub_calloc (keysize, max_stripes);
if (!split_key) if (!split_key)
return grub_errno; return grub_errno;

687
grub-core/disk/luks2.c Normal file
View file

@ -0,0 +1,687 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2019 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/cryptodisk.h>
#include <grub/types.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/dl.h>
#include <grub/err.h>
#include <grub/disk.h>
#include <grub/crypto.h>
#include <grub/partition.h>
#include <grub/i18n.h>
#include <base64.h>
#include <json.h>
GRUB_MOD_LICENSE ("GPLv3+");
#define LUKS_MAGIC_1ST "LUKS\xBA\xBE"
#define LUKS_MAGIC_2ND "SKUL\xBA\xBE"
#define MAX_PASSPHRASE 256
enum grub_luks2_kdf_type
{
LUKS2_KDF_TYPE_ARGON2I,
LUKS2_KDF_TYPE_PBKDF2
};
typedef enum grub_luks2_kdf_type grub_luks2_kdf_type_t;
/* On disk LUKS header */
struct grub_luks2_header
{
char magic[6];
grub_uint16_t version;
grub_uint64_t hdr_size;
grub_uint64_t seqid;
char label[48];
char csum_alg[32];
grub_uint8_t salt[64];
char uuid[40];
char subsystem[48];
grub_uint64_t hdr_offset;
char _padding[184];
grub_uint8_t csum[64];
char _padding4096[7*512];
} GRUB_PACKED;
typedef struct grub_luks2_header grub_luks2_header_t;
struct grub_luks2_keyslot
{
grub_int64_t key_size;
grub_int64_t priority;
struct
{
const char *encryption;
grub_uint64_t offset;
grub_uint64_t size;
grub_int64_t key_size;
} area;
struct
{
const char *hash;
grub_int64_t stripes;
} af;
struct
{
grub_luks2_kdf_type_t type;
const char *salt;
union
{
struct
{
grub_int64_t time;
grub_int64_t memory;
grub_int64_t cpus;
} argon2i;
struct
{
const char *hash;
grub_int64_t iterations;
} pbkdf2;
} u;
} kdf;
};
typedef struct grub_luks2_keyslot grub_luks2_keyslot_t;
struct grub_luks2_segment
{
grub_uint64_t offset;
const char *size;
const char *encryption;
grub_int64_t sector_size;
};
typedef struct grub_luks2_segment grub_luks2_segment_t;
struct grub_luks2_digest
{
/* Both keyslots and segments are interpreted as bitfields here */
grub_uint64_t keyslots;
grub_uint64_t segments;
const char *salt;
const char *digest;
const char *hash;
grub_int64_t iterations;
};
typedef struct grub_luks2_digest grub_luks2_digest_t;
gcry_err_code_t AF_merge (const gcry_md_spec_t * hash, grub_uint8_t * src,
grub_uint8_t * dst, grub_size_t blocksize,
grub_size_t blocknumbers);
static grub_err_t
luks2_parse_keyslot (grub_luks2_keyslot_t *out, const grub_json_t *keyslot)
{
grub_json_t area, af, kdf;
const char *type;
if (grub_json_getstring (&type, keyslot, "type"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Missing or invalid keyslot");
else if (grub_strcmp (type, "luks2"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Unsupported keyslot type %s", type);
else if (grub_json_getint64 (&out->key_size, keyslot, "key_size"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Missing keyslot information");
if (grub_json_getint64 (&out->priority, keyslot, "priority"))
out->priority = 1;
if (grub_json_getvalue (&area, keyslot, "area") ||
grub_json_getstring (&type, &area, "type"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Missing or invalid key area");
else if (grub_strcmp (type, "raw"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Unsupported key area type: %s", type);
else if (grub_json_getuint64 (&out->area.offset, &area, "offset") ||
grub_json_getuint64 (&out->area.size, &area, "size") ||
grub_json_getstring (&out->area.encryption, &area, "encryption") ||
grub_json_getint64 (&out->area.key_size, &area, "key_size"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Missing key area information");
if (grub_json_getvalue (&kdf, keyslot, "kdf") ||
grub_json_getstring (&type, &kdf, "type") ||
grub_json_getstring (&out->kdf.salt, &kdf, "salt"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Missing or invalid KDF");
else if (!grub_strcmp (type, "argon2i") || !grub_strcmp (type, "argon2id"))
{
out->kdf.type = LUKS2_KDF_TYPE_ARGON2I;
if (grub_json_getint64 (&out->kdf.u.argon2i.time, &kdf, "time") ||
grub_json_getint64 (&out->kdf.u.argon2i.memory, &kdf, "memory") ||
grub_json_getint64 (&out->kdf.u.argon2i.cpus, &kdf, "cpus"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Missing Argon2i parameters");
}
else if (!grub_strcmp (type, "pbkdf2"))
{
out->kdf.type = LUKS2_KDF_TYPE_PBKDF2;
if (grub_json_getstring (&out->kdf.u.pbkdf2.hash, &kdf, "hash") ||
grub_json_getint64 (&out->kdf.u.pbkdf2.iterations, &kdf, "iterations"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Missing PBKDF2 parameters");
}
else
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Unsupported KDF type %s", type);
if (grub_json_getvalue (&af, keyslot, "af") ||
grub_json_getstring (&type, &af, "type"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "missing or invalid area");
if (grub_strcmp (type, "luks1"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Unsupported AF type %s", type);
if (grub_json_getint64 (&out->af.stripes, &af, "stripes") ||
grub_json_getstring (&out->af.hash, &af, "hash"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Missing AF parameters");
return GRUB_ERR_NONE;
}
static grub_err_t
luks2_parse_segment (grub_luks2_segment_t *out, const grub_json_t *segment)
{
const char *type;
if (grub_json_getstring (&type, segment, "type"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid segment type");
else if (grub_strcmp (type, "crypt"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Unsupported segment type %s", type);
if (grub_json_getuint64 (&out->offset, segment, "offset") ||
grub_json_getstring (&out->size, segment, "size") ||
grub_json_getstring (&out->encryption, segment, "encryption") ||
grub_json_getint64 (&out->sector_size, segment, "sector_size"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Missing segment parameters", type);
return GRUB_ERR_NONE;
}
static grub_err_t
luks2_parse_digest (grub_luks2_digest_t *out, const grub_json_t *digest)
{
grub_json_t segments, keyslots, o;
grub_size_t i, size;
grub_uint64_t bit;
const char *type;
if (grub_json_getstring (&type, digest, "type"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid digest type");
else if (grub_strcmp (type, "pbkdf2"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Unsupported digest type %s", type);
if (grub_json_getvalue (&segments, digest, "segments") ||
grub_json_getvalue (&keyslots, digest, "keyslots") ||
grub_json_getstring (&out->salt, digest, "salt") ||
grub_json_getstring (&out->digest, digest, "digest") ||
grub_json_getstring (&out->hash, digest, "hash") ||
grub_json_getint64 (&out->iterations, digest, "iterations"))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Missing digest parameters");
if (grub_json_getsize (&size, &segments))
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"Digest references no segments", type);
for (i = 0; i < size; i++)
{
if (grub_json_getchild (&o, &segments, i) ||
grub_json_getuint64 (&bit, &o, NULL))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid segment");
out->segments |= (1 << bit);
}
if (grub_json_getsize (&size, &keyslots))
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"Digest references no keyslots", type);
for (i = 0; i < size; i++)
{
if (grub_json_getchild (&o, &keyslots, i) ||
grub_json_getuint64 (&bit, &o, NULL))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid keyslot");
out->keyslots |= (1 << bit);
}
return GRUB_ERR_NONE;
}
static grub_err_t
luks2_get_keyslot (grub_luks2_keyslot_t *k, grub_luks2_digest_t *d, grub_luks2_segment_t *s,
const grub_json_t *root, grub_size_t i)
{
grub_json_t keyslots, keyslot, digests, digest, segments, segment;
grub_size_t j, size;
grub_uint64_t idx;
/* Get nth keyslot */
if (grub_json_getvalue (&keyslots, root, "keyslots") ||
grub_json_getchild (&keyslot, &keyslots, i) ||
grub_json_getuint64 (&idx, &keyslot, NULL) ||
grub_json_getchild (&keyslot, &keyslot, 0) ||
luks2_parse_keyslot (k, &keyslot))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Could not parse keyslot %"PRIuGRUB_SIZE, i);
/* Get digest that matches the keyslot. */
if (grub_json_getvalue (&digests, root, "digests") ||
grub_json_getsize (&size, &digests))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Could not get digests");
for (j = 0; j < size; j++)
{
if (grub_json_getchild (&digest, &digests, i) ||
grub_json_getchild (&digest, &digest, 0) ||
luks2_parse_digest (d, &digest))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Could not parse digest %"PRIuGRUB_SIZE, i);
if ((d->keyslots & (1 << idx)))
break;
}
if (j == size)
return grub_error (GRUB_ERR_FILE_NOT_FOUND, "No digest for keyslot %"PRIuGRUB_SIZE);
/* Get segment that matches the digest. */
if (grub_json_getvalue (&segments, root, "segments") ||
grub_json_getsize (&size, &segments))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Could not get segments");
for (j = 0; j < size; j++)
{
if (grub_json_getchild (&segment, &segments, i) ||
grub_json_getuint64 (&idx, &segment, NULL) ||
grub_json_getchild (&segment, &segment, 0) ||
luks2_parse_segment (s, &segment))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Could not parse segment %"PRIuGRUB_SIZE, i);
if ((d->segments & (1 << idx)))
break;
}
if (j == size)
return grub_error (GRUB_ERR_FILE_NOT_FOUND, "No segment for digest %"PRIuGRUB_SIZE);
return GRUB_ERR_NONE;
}
/* Determine whether to use primary or secondary header */
static grub_err_t
luks2_read_header (grub_disk_t disk, grub_luks2_header_t *outhdr)
{
grub_luks2_header_t primary, secondary, *header = &primary;
grub_err_t ret;
/* Read the primary LUKS header. */
ret = grub_disk_read (disk, 0, 0, sizeof (primary), &primary);
if (ret)
return ret;
/* Look for LUKS magic sequence. */
if (grub_memcmp (primary.magic, LUKS_MAGIC_1ST, sizeof (primary.magic)) ||
grub_be_to_cpu16 (primary.version) != 2)
return GRUB_ERR_BAD_SIGNATURE;
/* Read the secondary header. */
ret = grub_disk_read (disk, 0, grub_be_to_cpu64 (primary.hdr_size), sizeof (secondary), &secondary);
if (ret)
return ret;
/* Look for LUKS magic sequence. */
if (grub_memcmp (secondary.magic, LUKS_MAGIC_2ND, sizeof (secondary.magic)) ||
grub_be_to_cpu16 (secondary.version) != 2)
return GRUB_ERR_BAD_SIGNATURE;
if (grub_be_to_cpu64 (primary.seqid) < grub_be_to_cpu64 (secondary.seqid))
header = &secondary;
grub_memcpy (outhdr, header, sizeof (*header));
return GRUB_ERR_NONE;
}
static grub_cryptodisk_t
luks2_scan (grub_disk_t disk, const char *check_uuid, int check_boot)
{
grub_cryptodisk_t cryptodisk;
grub_luks2_header_t header;
char uuid[sizeof (header.uuid) + 1];
grub_size_t i, j;
if (check_boot)
return NULL;
if (luks2_read_header (disk, &header))
{
grub_errno = GRUB_ERR_NONE;
return NULL;
}
for (i = 0, j = 0; i < sizeof (header.uuid); i++)
if (header.uuid[i] != '-')
uuid[j++] = header.uuid[i];
uuid[j] = '\0';
if (check_uuid && grub_strcasecmp (check_uuid, uuid) != 0)
return NULL;
cryptodisk = grub_zalloc (sizeof (*cryptodisk));
if (!cryptodisk)
return NULL;
COMPILE_TIME_ASSERT (sizeof (cryptodisk->uuid) >= sizeof (uuid));
grub_memcpy (cryptodisk->uuid, uuid, sizeof (uuid));
cryptodisk->modname = "luks2";
return cryptodisk;
}
static grub_err_t
luks2_verify_key (grub_luks2_digest_t *d, grub_uint8_t *candidate_key,
grub_size_t candidate_key_len)
{
grub_uint8_t candidate_digest[GRUB_CRYPTODISK_MAX_KEYLEN];
grub_uint8_t digest[GRUB_CRYPTODISK_MAX_KEYLEN], salt[GRUB_CRYPTODISK_MAX_KEYLEN];
grub_size_t saltlen = sizeof (salt), digestlen = sizeof (digest);
const gcry_md_spec_t *hash;
gcry_err_code_t gcry_ret;
/* Decode both digest and salt */
if (!base64_decode (d->digest, grub_strlen (d->digest), (char *)digest, &digestlen))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid digest");
if (!base64_decode (d->salt, grub_strlen (d->salt), (char *)salt, &saltlen))
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid digest salt");
/* Configure the hash used for the digest. */
hash = grub_crypto_lookup_md_by_name (d->hash);
if (!hash)
return grub_error (GRUB_ERR_FILE_NOT_FOUND, "Couldn't load %s hash", d->hash);
/* Calculate the candidate key's digest */
gcry_ret = grub_crypto_pbkdf2 (hash,
candidate_key, candidate_key_len,
salt, saltlen,
d->iterations,
candidate_digest, digestlen);
if (gcry_ret)
return grub_crypto_gcry_error (gcry_ret);
if (grub_memcmp (candidate_digest, digest, digestlen) != 0)
return grub_error (GRUB_ERR_ACCESS_DENIED, "Mismatching digests");
return GRUB_ERR_NONE;
}
static grub_err_t
luks2_decrypt_key (grub_uint8_t *out_key,
grub_disk_t disk, grub_cryptodisk_t crypt,
grub_luks2_keyslot_t *k,
const grub_uint8_t *passphrase, grub_size_t passphraselen)
{
grub_uint8_t area_key[GRUB_CRYPTODISK_MAX_KEYLEN];
grub_uint8_t salt[GRUB_CRYPTODISK_MAX_KEYLEN];
grub_uint8_t *split_key = NULL;
grub_size_t saltlen = sizeof (salt);
char cipher[32], *p;;
const gcry_md_spec_t *hash;
gcry_err_code_t gcry_ret;
grub_err_t ret;
if (!base64_decode (k->kdf.salt, grub_strlen (k->kdf.salt),
(char *)salt, &saltlen))
{
ret = grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid keyslot salt");
goto err;
}
/* Calculate the binary area key of the user supplied passphrase. */
switch (k->kdf.type)
{
case LUKS2_KDF_TYPE_ARGON2I:
ret = grub_error (GRUB_ERR_BAD_ARGUMENT, "Argon2 not supported");
goto err;
case LUKS2_KDF_TYPE_PBKDF2:
hash = grub_crypto_lookup_md_by_name (k->kdf.u.pbkdf2.hash);
if (!hash)
{
ret = grub_error (GRUB_ERR_FILE_NOT_FOUND, "Couldn't load %s hash",
k->kdf.u.pbkdf2.hash);
goto err;
}
gcry_ret = grub_crypto_pbkdf2 (hash, (grub_uint8_t *) passphrase,
passphraselen,
salt, saltlen,
k->kdf.u.pbkdf2.iterations,
area_key, k->area.key_size);
if (gcry_ret)
{
ret = grub_crypto_gcry_error (gcry_ret);
goto err;
}
break;
}
/* Set up disk encryption parameters for the key area */
grub_strncpy (cipher, k->area.encryption, sizeof (cipher));
p = grub_memchr (cipher, '-', grub_strlen (cipher));
if (!p)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid encryption");
*p = '\0';
ret = grub_cryptodisk_setcipher (crypt, cipher, p + 1);
if (ret)
return ret;
gcry_ret = grub_cryptodisk_setkey (crypt, area_key, k->area.key_size);
if (gcry_ret)
{
ret = grub_crypto_gcry_error (gcry_ret);
goto err;
}
/* Read and decrypt the binary key area with the area key. */
split_key = grub_malloc (k->area.size);
if (!split_key)
{
ret = grub_errno;
goto err;
}
grub_errno = GRUB_ERR_NONE;
ret = grub_disk_read (disk, 0, k->area.offset, k->area.size, split_key);
if (ret)
{
grub_error (GRUB_ERR_IO, "Read error: %s\n", grub_errmsg);
goto err;
}
gcry_ret = grub_cryptodisk_decrypt (crypt, split_key, k->area.size, 0);
if (gcry_ret)
{
ret = grub_crypto_gcry_error (gcry_ret);
goto err;
}
/* Configure the hash used for anti-forensic merging. */
hash = grub_crypto_lookup_md_by_name (k->af.hash);
if (!hash)
{
ret = grub_error (GRUB_ERR_FILE_NOT_FOUND, "Couldn't load %s hash",
k->af.hash);
goto err;
}
/* Merge the decrypted key material to get the candidate master key. */
gcry_ret = AF_merge (hash, split_key, out_key, k->key_size, k->af.stripes);
if (gcry_ret)
{
ret = grub_crypto_gcry_error (gcry_ret);
goto err;
}
grub_dprintf ("luks2", "Candidate key recovered\n");
err:
grub_free (split_key);
return ret;
}
static grub_err_t
luks2_recover_key (grub_disk_t disk,
grub_cryptodisk_t crypt)
{
grub_uint8_t candidate_key[GRUB_CRYPTODISK_MAX_KEYLEN];
char passphrase[MAX_PASSPHRASE], cipher[32];
char *json_header = NULL, *part = NULL, *ptr;
grub_size_t candidate_key_len = 0, i, size;
grub_luks2_header_t header;
grub_luks2_keyslot_t keyslot;
grub_luks2_digest_t digest;
grub_luks2_segment_t segment;
gcry_err_code_t gcry_ret;
grub_json_t *json = NULL, keyslots;
grub_err_t ret;
ret = luks2_read_header (disk, &header);
if (ret)
return ret;
json_header = grub_zalloc (grub_be_to_cpu64 (header.hdr_size) - sizeof (header));
if (!json_header)
return GRUB_ERR_OUT_OF_MEMORY;
/* Read the JSON area. */
ret = grub_disk_read (disk, 0, grub_be_to_cpu64 (header.hdr_offset) + sizeof (header),
grub_be_to_cpu64 (header.hdr_size) - sizeof (header), json_header);
if (ret)
goto err;
ptr = grub_memchr (json_header, 0, grub_be_to_cpu64 (header.hdr_size) - sizeof (header));
if (!ptr)
goto err;
ret = grub_json_parse (&json, json_header, grub_be_to_cpu64 (header.hdr_size));
if (ret)
{
ret = grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid LUKS2 JSON header");
goto err;
}
/* Get the passphrase from the user. */
if (disk->partition)
part = grub_partition_get_name (disk->partition);
grub_printf_ (N_("Enter passphrase for %s%s%s (%s): "), disk->name,
disk->partition ? "," : "", part ? : "",
crypt->uuid);
if (!grub_password_get (passphrase, MAX_PASSPHRASE))
{
ret = grub_error (GRUB_ERR_BAD_ARGUMENT, "Passphrase not supplied");
goto err;
}
if (grub_json_getvalue (&keyslots, json, "keyslots") ||
grub_json_getsize (&size, &keyslots))
{
ret = grub_error (GRUB_ERR_BAD_ARGUMENT, "Could not get keyslots");
goto err;
}
/* Try all keyslot */
for (i = 0; i < size; i++)
{
ret = luks2_get_keyslot (&keyslot, &digest, &segment, json, i);
if (ret)
goto err;
if (keyslot.priority == 0)
{
grub_dprintf ("luks2", "Ignoring keyslot %"PRIuGRUB_SIZE" due to priority\n", i);
continue;
}
grub_dprintf ("luks2", "Trying keyslot %"PRIuGRUB_SIZE"\n", i);
/* Set up disk according to keyslot's segment. */
crypt->offset = grub_divmod64 (segment.offset, segment.sector_size, NULL);
crypt->log_sector_size = sizeof (unsigned int) * 8
- __builtin_clz ((unsigned int) segment.sector_size) - 1;
if (grub_strcmp (segment.size, "dynamic") == 0)
crypt->total_length = grub_disk_get_size (disk) - crypt->offset;
else
crypt->total_length = grub_strtoull (segment.size, NULL, 10);
ret = luks2_decrypt_key (candidate_key, disk, crypt, &keyslot,
(const grub_uint8_t *) passphrase, grub_strlen (passphrase));
if (ret)
{
grub_dprintf ("luks2", "Decryption with keyslot %"PRIuGRUB_SIZE" failed: %s\n",
i, grub_errmsg);
continue;
}
ret = luks2_verify_key (&digest, candidate_key, keyslot.key_size);
if (ret)
{
grub_dprintf ("luks2", "Could not open keyslot %"PRIuGRUB_SIZE": %s\n",
i, grub_errmsg);
continue;
}
/*
* TRANSLATORS: It's a cryptographic key slot: one element of an array
* where each element is either empty or holds a key.
*/
grub_printf_ (N_("Slot %"PRIuGRUB_SIZE" opened\n"), i);
candidate_key_len = keyslot.key_size;
break;
}
if (candidate_key_len == 0)
{
ret = grub_error (GRUB_ERR_ACCESS_DENIED, "Invalid passphrase");
goto err;
}
/* Set up disk cipher. */
grub_strncpy (cipher, segment.encryption, sizeof (cipher));
ptr = grub_memchr (cipher, '-', grub_strlen (cipher));
if (!ptr)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid encryption");
*ptr = '\0';
ret = grub_cryptodisk_setcipher (crypt, cipher, ptr + 1);
if (ret)
goto err;
/* Set the master key. */
gcry_ret = grub_cryptodisk_setkey (crypt, candidate_key, candidate_key_len);
if (gcry_ret)
{
ret = grub_crypto_gcry_error (gcry_ret);
goto err;
}
err:
grub_free (part);
grub_free (json_header);
grub_json_free (json);
return ret;
}
static struct grub_cryptodisk_dev luks2_crypto = {
.scan = luks2_scan,
.recover_key = luks2_recover_key
};
GRUB_MOD_INIT (luks2)
{
grub_cryptodisk_dev_register (&luks2_crypto);
}
GRUB_MOD_FINI (luks2)
{
grub_cryptodisk_dev_unregister (&luks2_crypto);
}

253
grub-core/disk/lvm.c
View file

@ -25,6 +25,7 @@
#include <grub/lvm.h> #include <grub/lvm.h>
#include <grub/partition.h> #include <grub/partition.h>
#include <grub/i18n.h> #include <grub/i18n.h>
#include <grub/safemath.h>
#ifdef GRUB_UTIL #ifdef GRUB_UTIL
#include <grub/emu/misc.h> #include <grub/emu/misc.h>
@ -33,12 +34,20 @@
GRUB_MOD_LICENSE ("GPLv3+"); GRUB_MOD_LICENSE ("GPLv3+");
struct cache_lv
{
struct grub_diskfilter_lv *lv;
char *cache_pool;
char *origin;
struct cache_lv *next;
};
/* Go the string STR and return the number after STR. *P will point /* Go the string STR and return the number after STR. *P will point
at the number. In case STR is not found, *P will be NULL and the at the number. In case STR is not found, *P will be NULL and the
return value will be 0. */ return value will be 0. */
static grub_uint64_t static grub_uint64_t
grub_lvm_getvalue (char **p, const char *str) grub_lvm_getvalue (const char ** const p, const char *str)
{ {
*p = grub_strstr (*p, str); *p = grub_strstr (*p, str);
if (! *p) if (! *p)
@ -63,12 +72,12 @@ grub_lvm_checkvalue (char **p, char *str, char *tmpl)
#endif #endif
static int static int
grub_lvm_check_flag (char *p, const char *str, const char *flag) grub_lvm_check_flag (const char *p, const char *str, const char *flag)
{ {
grub_size_t len_str = grub_strlen (str), len_flag = grub_strlen (flag); grub_size_t len_str = grub_strlen (str), len_flag = grub_strlen (flag);
while (1) while (1)
{ {
char *q; const char *q;
p = grub_strstr (p, str); p = grub_strstr (p, str);
if (! p) if (! p)
return 0; return 0;
@ -95,6 +104,34 @@ grub_lvm_check_flag (char *p, const char *str, const char *flag)
} }
} }
static void
grub_lvm_free_cache_lvs (struct cache_lv *cache_lvs)
{
struct cache_lv *cache;
while ((cache = cache_lvs))
{
cache_lvs = cache_lvs->next;
if (cache->lv)
{
unsigned int i;
for (i = 0; i < cache->lv->segment_count; ++i)
if (cache->lv->segments)
grub_free (cache->lv->segments[i].nodes);
grub_free (cache->lv->segments);
grub_free (cache->lv->fullname);
grub_free (cache->lv->idname);
grub_free (cache->lv->name);
}
grub_free (cache->lv);
grub_free (cache->origin);
grub_free (cache->cache_pool);
grub_free (cache);
}
}
static struct grub_diskfilter_vg * static struct grub_diskfilter_vg *
grub_lvm_detect (grub_disk_t disk, grub_lvm_detect (grub_disk_t disk,
struct grub_diskfilter_pv_id *id, struct grub_diskfilter_pv_id *id,
@ -102,10 +139,12 @@ grub_lvm_detect (grub_disk_t disk,
{ {
grub_err_t err; grub_err_t err;
grub_uint64_t mda_offset, mda_size; grub_uint64_t mda_offset, mda_size;
grub_size_t ptr;
char buf[GRUB_LVM_LABEL_SIZE]; char buf[GRUB_LVM_LABEL_SIZE];
char vg_id[GRUB_LVM_ID_STRLEN+1]; char vg_id[GRUB_LVM_ID_STRLEN+1];
char pv_id[GRUB_LVM_ID_STRLEN+1]; char pv_id[GRUB_LVM_ID_STRLEN+1];
char *metadatabuf, *p, *q, *vgname; char *metadatabuf, *mda_end, *vgname;
const char *p, *q;
struct grub_lvm_label_header *lh = (struct grub_lvm_label_header *) buf; struct grub_lvm_label_header *lh = (struct grub_lvm_label_header *) buf;
struct grub_lvm_pv_header *pvh; struct grub_lvm_pv_header *pvh;
struct grub_lvm_disk_locn *dlocn; struct grub_lvm_disk_locn *dlocn;
@ -173,7 +212,7 @@ grub_lvm_detect (grub_disk_t disk,
first one. */ first one. */
/* Allocate buffer space for the circular worst-case scenario. */ /* Allocate buffer space for the circular worst-case scenario. */
metadatabuf = grub_malloc (2 * mda_size); metadatabuf = grub_calloc (2, mda_size);
if (! metadatabuf) if (! metadatabuf)
goto fail; goto fail;
@ -205,19 +244,31 @@ grub_lvm_detect (grub_disk_t disk,
grub_le_to_cpu64 (rlocn->size) - grub_le_to_cpu64 (rlocn->size) -
grub_le_to_cpu64 (mdah->size)); grub_le_to_cpu64 (mdah->size));
} }
p = q = metadatabuf + grub_le_to_cpu64 (rlocn->offset);
while (*q != ' ' && q < metadatabuf + mda_size) if (grub_add ((grub_size_t)metadatabuf,
q++; (grub_size_t)grub_le_to_cpu64 (rlocn->offset),
&ptr))
if (q == metadatabuf + mda_size)
{ {
error_parsing_metadata:
#ifdef GRUB_UTIL #ifdef GRUB_UTIL
grub_util_info ("error parsing metadata"); grub_util_info ("error parsing metadata");
#endif #endif
goto fail2; goto fail2;
} }
p = q = (char *)ptr;
if (grub_add ((grub_size_t)metadatabuf, (grub_size_t)mda_size, &ptr))
goto error_parsing_metadata;
mda_end = (char *)ptr;
while (*q != ' ' && q < mda_end)
q++;
if (q == mda_end)
goto error_parsing_metadata;
vgname_len = q - p; vgname_len = q - p;
vgname = grub_malloc (vgname_len + 1); vgname = grub_malloc (vgname_len + 1);
if (!vgname) if (!vgname)
@ -242,6 +293,8 @@ grub_lvm_detect (grub_disk_t disk,
if (! vg) if (! vg)
{ {
struct cache_lv *cache_lvs = NULL;
/* First time we see this volume group. We've to create the /* First time we see this volume group. We've to create the
whole volume group structure. */ whole volume group structure. */
vg = grub_malloc (sizeof (*vg)); vg = grub_malloc (sizeof (*vg));
@ -367,8 +420,26 @@ grub_lvm_detect (grub_disk_t disk,
{ {
const char *iptr; const char *iptr;
char *optr; char *optr;
lv->fullname = grub_malloc (sizeof ("lvm/") - 1 + 2 * vgname_len
+ 1 + 2 * s + 1); /*
* This is kind of hard to read with our safe (but rather
* baroque) math primatives, but it boils down to:
*
* sz0 = vgname_len * 2 + 1 +
* s * 2 + 1 +
* sizeof ("lvm/") - 1;
*/
grub_size_t sz0 = vgname_len, sz1 = s;
if (grub_mul (sz0, 2, &sz0) ||
grub_add (sz0, 1, &sz0) ||
grub_mul (sz1, 2, &sz1) ||
grub_add (sz1, 1, &sz1) ||
grub_add (sz0, sz1, &sz0) ||
grub_add (sz0, sizeof ("lvm/") - 1, &sz0))
goto lvs_fail;
lv->fullname = grub_malloc (sz0);
if (!lv->fullname) if (!lv->fullname)
goto lvs_fail; goto lvs_fail;
@ -426,7 +497,7 @@ grub_lvm_detect (grub_disk_t disk,
#endif #endif
goto lvs_fail; goto lvs_fail;
} }
lv->segments = grub_zalloc (sizeof (*seg) * lv->segment_count); lv->segments = grub_calloc (lv->segment_count, sizeof (*seg));
seg = lv->segments; seg = lv->segments;
for (i = 0; i < lv->segment_count; i++) for (i = 0; i < lv->segment_count; i++)
@ -483,8 +554,8 @@ grub_lvm_detect (grub_disk_t disk,
if (seg->node_count != 1) if (seg->node_count != 1)
seg->stripe_size = grub_lvm_getvalue (&p, "stripe_size = "); seg->stripe_size = grub_lvm_getvalue (&p, "stripe_size = ");
seg->nodes = grub_zalloc (sizeof (*stripe) seg->nodes = grub_calloc (seg->node_count,
* seg->node_count); sizeof (*stripe));
stripe = seg->nodes; stripe = seg->nodes;
p = grub_strstr (p, "stripes = ["); p = grub_strstr (p, "stripes = [");
@ -671,6 +742,106 @@ grub_lvm_detect (grub_disk_t disk,
seg->nodes[seg->node_count - 1].name = tmp; seg->nodes[seg->node_count - 1].name = tmp;
} }
} }
else if (grub_memcmp (p, "cache\"",
sizeof ("cache\"") - 1) == 0)
{
struct cache_lv *cache = NULL;
char *p2, *p3;
grub_size_t sz;
cache = grub_zalloc (sizeof (*cache));
if (!cache)
goto cache_lv_fail;
cache->lv = grub_zalloc (sizeof (*cache->lv));
if (!cache->lv)
goto cache_lv_fail;
grub_memcpy (cache->lv, lv, sizeof (*cache->lv));
if (lv->fullname)
{
cache->lv->fullname = grub_strdup (lv->fullname);
if (!cache->lv->fullname)
goto cache_lv_fail;
}
if (lv->idname)
{
cache->lv->idname = grub_strdup (lv->idname);
if (!cache->lv->idname)
goto cache_lv_fail;
}
if (lv->name)
{
cache->lv->name = grub_strdup (lv->name);
if (!cache->lv->name)
goto cache_lv_fail;
}
skip_lv = 1;
p2 = grub_strstr (p, "cache_pool = \"");
if (!p2)
goto cache_lv_fail;
p2 = grub_strchr (p2, '"');
if (!p2)
goto cache_lv_fail;
p3 = ++p2;
p3 = grub_strchr (p3, '"');
if (!p3)
goto cache_lv_fail;
sz = p3 - p2;
cache->cache_pool = grub_malloc (sz + 1);
if (!cache->cache_pool)
goto cache_lv_fail;
grub_memcpy (cache->cache_pool, p2, sz);
cache->cache_pool[sz] = '\0';
p2 = grub_strstr (p, "origin = \"");
if (!p2)
goto cache_lv_fail;
p2 = grub_strchr (p2, '"');
if (!p2)
goto cache_lv_fail;
p3 = ++p2;
p3 = grub_strchr (p3, '"');
if (!p3)
goto cache_lv_fail;
sz = p3 - p2;
cache->origin = grub_malloc (sz + 1);
if (!cache->origin)
goto cache_lv_fail;
grub_memcpy (cache->origin, p2, sz);
cache->origin[sz] = '\0';
cache->next = cache_lvs;
cache_lvs = cache;
break;
cache_lv_fail:
if (cache)
{
grub_free (cache->origin);
grub_free (cache->cache_pool);
if (cache->lv)
{
grub_free (cache->lv->fullname);
grub_free (cache->lv->idname);
grub_free (cache->lv->name);
}
grub_free (cache->lv);
grub_free (cache);
}
grub_lvm_free_cache_lvs (cache_lvs);
goto fail4;
}
else else
{ {
#ifdef GRUB_UTIL #ifdef GRUB_UTIL
@ -747,6 +918,58 @@ grub_lvm_detect (grub_disk_t disk,
} }
} }
{
struct cache_lv *cache;
for (cache = cache_lvs; cache; cache = cache->next)
{
struct grub_diskfilter_lv *lv;
for (lv = vg->lvs; lv; lv = lv->next)
if (grub_strcmp (lv->name, cache->origin) == 0)
break;
if (lv)
{
cache->lv->segments = grub_calloc (lv->segment_count, sizeof (*lv->segments));
if (!cache->lv->segments)
{
grub_lvm_free_cache_lvs (cache_lvs);
goto fail4;
}
grub_memcpy (cache->lv->segments, lv->segments, lv->segment_count * sizeof (*lv->segments));
for (i = 0; i < lv->segment_count; ++i)
{
struct grub_diskfilter_node *nodes = lv->segments[i].nodes;
grub_size_t node_count = lv->segments[i].node_count;
cache->lv->segments[i].nodes = grub_calloc (node_count, sizeof (*nodes));
if (!cache->lv->segments[i].nodes)
{
for (j = 0; j < i; ++j)
grub_free (cache->lv->segments[j].nodes);
grub_free (cache->lv->segments);
cache->lv->segments = NULL;
grub_lvm_free_cache_lvs (cache_lvs);
goto fail4;
}
grub_memcpy (cache->lv->segments[i].nodes, nodes, node_count * sizeof (*nodes));
}
if (cache->lv->segments)
{
cache->lv->segment_count = lv->segment_count;
cache->lv->vg = vg;
cache->lv->next = vg->lvs;
vg->lvs = cache->lv;
cache->lv = NULL;
}
}
}
}
grub_lvm_free_cache_lvs (cache_lvs);
if (grub_diskfilter_vg_register (vg)) if (grub_diskfilter_vg_register (vg))
goto fail4; goto fail4;
} }

2
grub-core/disk/mdraid1x_linux.c
View file

@ -178,7 +178,7 @@ grub_mdraid_detect (grub_disk_t disk,
return NULL; return NULL;
if (grub_disk_read (disk, sector, if (grub_disk_read (disk, sector,
(char *) &sb.dev_roles[grub_le_to_cpu32 (sb.dev_number)] (char *) (sb.dev_roles + grub_le_to_cpu32 (sb.dev_number))
- (char *) &sb, - (char *) &sb,
sizeof (role), &role)) sizeof (role), &role))
return NULL; return NULL;

2
grub-core/disk/xen/xendisk.c
View file

@ -426,7 +426,7 @@ grub_xendisk_init (void)
if (!ctr) if (!ctr)
return; return;
virtdisks = grub_malloc (ctr * sizeof (virtdisks[0])); virtdisks = grub_calloc (ctr, sizeof (virtdisks[0]));
if (!virtdisks) if (!virtdisks)
return; return;
if (grub_xenstore_dir ("device/vbd", fill, &ctr)) if (grub_xenstore_dir ("device/vbd", fill, &ctr))

25
grub-core/efiemu/i386/pc/cfgtables.c
View file

@ -30,14 +30,10 @@ grub_machine_efiemu_init_tables (void)
void *table; void *table;
grub_err_t err; grub_err_t err;
grub_efi_guid_t smbios = GRUB_EFI_SMBIOS_TABLE_GUID; grub_efi_guid_t smbios = GRUB_EFI_SMBIOS_TABLE_GUID;
grub_efi_guid_t smbios3 = GRUB_EFI_SMBIOS3_TABLE_GUID;
grub_efi_guid_t acpi20 = GRUB_EFI_ACPI_20_TABLE_GUID; grub_efi_guid_t acpi20 = GRUB_EFI_ACPI_20_TABLE_GUID;
grub_efi_guid_t acpi = GRUB_EFI_ACPI_TABLE_GUID; grub_efi_guid_t acpi = GRUB_EFI_ACPI_TABLE_GUID;
err = grub_efiemu_unregister_configuration_table (smbios); err = grub_efiemu_unregister_configuration_table (smbios);
if (err)
return err;
err = grub_efiemu_unregister_configuration_table (smbios3);
if (err) if (err)
return err; return err;
err = grub_efiemu_unregister_configuration_table (acpi); err = grub_efiemu_unregister_configuration_table (acpi);
@ -47,20 +43,6 @@ grub_machine_efiemu_init_tables (void)
if (err) if (err)
return err; return err;
table = grub_smbios_get_eps ();
if (table)
{
err = grub_efiemu_register_configuration_table (smbios, 0, 0, table);
if (err)
return err;
}
table = grub_smbios_get_eps3 ();
if (table)
{
err = grub_efiemu_register_configuration_table (smbios3, 0, 0, table);
if (err)
return err;
}
table = grub_acpi_get_rsdpv1 (); table = grub_acpi_get_rsdpv1 ();
if (table) if (table)
{ {
@ -75,6 +57,13 @@ grub_machine_efiemu_init_tables (void)
if (err) if (err)
return err; return err;
} }
table = grub_smbios_get_eps ();
if (table)
{
err = grub_efiemu_register_configuration_table (smbios, 0, 0, table);
if (err)
return err;
}
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
} }

2
grub-core/efiemu/loadcore.c
View file

@ -201,7 +201,7 @@ grub_efiemu_count_symbols (const Elf_Ehdr *e)
grub_efiemu_nelfsyms = (unsigned) s->sh_size / (unsigned) s->sh_entsize; grub_efiemu_nelfsyms = (unsigned) s->sh_size / (unsigned) s->sh_entsize;
grub_efiemu_elfsyms = (struct grub_efiemu_elf_sym *) grub_efiemu_elfsyms = (struct grub_efiemu_elf_sym *)
grub_malloc (sizeof (struct grub_efiemu_elf_sym) * grub_efiemu_nelfsyms); grub_calloc (grub_efiemu_nelfsyms, sizeof (struct grub_efiemu_elf_sym));
/* Relocators */ /* Relocators */
for (i = 0, s = (Elf_Shdr *) ((char *) e + e->e_shoff); for (i = 0, s = (Elf_Shdr *) ((char *) e + e->e_shoff);

6
grub-core/efiemu/mm.c
View file

@ -554,11 +554,11 @@ grub_efiemu_mmap_sort_and_uniq (void)
/* Initialize variables*/ /* Initialize variables*/
grub_memset (present, 0, sizeof (int) * GRUB_EFI_MAX_MEMORY_TYPE); grub_memset (present, 0, sizeof (int) * GRUB_EFI_MAX_MEMORY_TYPE);
scanline_events = (struct grub_efiemu_mmap_scan *) scanline_events = (struct grub_efiemu_mmap_scan *)
grub_malloc (sizeof (struct grub_efiemu_mmap_scan) * 2 * mmap_num); grub_calloc (mmap_num, sizeof (struct grub_efiemu_mmap_scan) * 2);
/* Number of chunks can't increase more than by factor of 2 */ /* Number of chunks can't increase more than by factor of 2 */
result = (grub_efi_memory_descriptor_t *) result = (grub_efi_memory_descriptor_t *)
grub_malloc (sizeof (grub_efi_memory_descriptor_t) * 2 * mmap_num); grub_calloc (mmap_num, sizeof (grub_efi_memory_descriptor_t) * 2);
if (!result || !scanline_events) if (!result || !scanline_events)
{ {
grub_free (result); grub_free (result);
@ -660,7 +660,7 @@ grub_efiemu_mm_do_alloc (void)
/* Preallocate mmap */ /* Preallocate mmap */
efiemu_mmap = (grub_efi_memory_descriptor_t *) efiemu_mmap = (grub_efi_memory_descriptor_t *)
grub_malloc (mmap_reserved_size * sizeof (grub_efi_memory_descriptor_t)); grub_calloc (mmap_reserved_size, sizeof (grub_efi_memory_descriptor_t));
if (!efiemu_mmap) if (!efiemu_mmap)
{ {
grub_efiemu_unload (); grub_efiemu_unload ();

5
grub-core/efiemu/pnvram.c
View file

@ -39,7 +39,7 @@ static grub_size_t nvramsize;
/* Parse signed value */ /* Parse signed value */
static int static int
grub_strtosl (const char *arg, char **end, int base) grub_strtosl (const char *arg, const char ** const end, int base)
{ {
if (arg[0] == '-') if (arg[0] == '-')
return -grub_strtoul (arg + 1, end, base); return -grub_strtoul (arg + 1, end, base);
@ -120,7 +120,8 @@ nvram_set (void * data __attribute__ ((unused)))
grub_memset (nvram, 0, nvramsize); grub_memset (nvram, 0, nvramsize);
FOR_SORTED_ENV (var) FOR_SORTED_ENV (var)
{ {
char *guid, *attr, *name, *varname; const char *guid;
char *attr, *name, *varname;
struct efi_variable *efivar; struct efi_variable *efivar;
int len = 0; int len = 0;
int i; int i;

16
grub-core/font/font.c
View file

@ -30,6 +30,7 @@
#include <grub/unicode.h> #include <grub/unicode.h>
#include <grub/fontformat.h> #include <grub/fontformat.h>
#include <grub/env.h> #include <grub/env.h>
#include <grub/safemath.h>
GRUB_MOD_LICENSE ("GPLv3+"); GRUB_MOD_LICENSE ("GPLv3+");
@ -293,8 +294,7 @@ load_font_index (grub_file_t file, grub_uint32_t sect_length, struct
font->num_chars = sect_length / FONT_CHAR_INDEX_ENTRY_SIZE; font->num_chars = sect_length / FONT_CHAR_INDEX_ENTRY_SIZE;
/* Allocate the character index array. */ /* Allocate the character index array. */
font->char_index = grub_malloc (font->num_chars font->char_index = grub_calloc (font->num_chars, sizeof (struct char_index_entry));
* sizeof (struct char_index_entry));
if (!font->char_index) if (!font->char_index)
return 1; return 1;
font->bmp_idx = grub_malloc (0x10000 * sizeof (grub_uint16_t)); font->bmp_idx = grub_malloc (0x10000 * sizeof (grub_uint16_t));
@ -361,9 +361,13 @@ static char *
read_section_as_string (struct font_file_section *section) read_section_as_string (struct font_file_section *section)
{ {
char *str; char *str;
grub_size_t sz;
grub_ssize_t ret; grub_ssize_t ret;
str = grub_malloc (section->length + 1); if (grub_add (section->length, 1, &sz))
return NULL;
str = grub_malloc (sz);
if (!str) if (!str)
return 0; return 0;
@ -528,6 +532,12 @@ grub_font_load (const char *filename)
if (grub_memcmp (section.name, FONT_FORMAT_SECTION_NAMES_FONT_NAME, if (grub_memcmp (section.name, FONT_FORMAT_SECTION_NAMES_FONT_NAME,
sizeof (FONT_FORMAT_SECTION_NAMES_FONT_NAME) - 1) == 0) sizeof (FONT_FORMAT_SECTION_NAMES_FONT_NAME) - 1) == 0)
{ {
if (font->name != NULL)
{
grub_error (GRUB_ERR_BAD_FONT, "invalid font file: too many NAME sections");
goto fail;
}
font->name = read_section_as_string (&section); font->name = read_section_as_string (&section);
if (!font->name) if (!font->name)
goto fail; goto fail;

6
grub-core/fs/affs.c
View file

@ -301,7 +301,7 @@ grub_affs_read_symlink (grub_fshelp_node_t node)
return 0; return 0;
} }
latin1[symlink_size] = 0; latin1[symlink_size] = 0;
utf8 = grub_malloc (symlink_size * GRUB_MAX_UTF8_PER_LATIN1 + 1); utf8 = grub_calloc (GRUB_MAX_UTF8_PER_LATIN1 + 1, symlink_size);
if (!utf8) if (!utf8)
{ {
grub_free (latin1); grub_free (latin1);
@ -422,7 +422,7 @@ grub_affs_iterate_dir (grub_fshelp_node_t dir,
return 1; return 1;
} }
hashtable = grub_zalloc (data->htsize * sizeof (*hashtable)); hashtable = grub_calloc (data->htsize, sizeof (*hashtable));
if (!hashtable) if (!hashtable)
return 1; return 1;
@ -628,7 +628,7 @@ grub_affs_label (grub_device_t device, char **label)
len = file.namelen; len = file.namelen;
if (len > sizeof (file.name)) if (len > sizeof (file.name))
len = sizeof (file.name); len = sizeof (file.name);
*label = grub_malloc (len * GRUB_MAX_UTF8_PER_LATIN1 + 1); *label = grub_calloc (GRUB_MAX_UTF8_PER_LATIN1 + 1, len);
if (*label) if (*label)
*grub_latin1_to_utf8 ((grub_uint8_t *) *label, file.name, len) = '\0'; *grub_latin1_to_utf8 ((grub_uint8_t *) *label, file.name, len) = '\0';
} }

45
grub-core/fs/btrfs.c
View file

@ -40,6 +40,7 @@
#include <grub/btrfs.h> #include <grub/btrfs.h>
#include <grub/crypto.h> #include <grub/crypto.h>
#include <grub/diskfilter.h> #include <grub/diskfilter.h>
#include <grub/safemath.h>
GRUB_MOD_LICENSE ("GPLv3+"); GRUB_MOD_LICENSE ("GPLv3+");
@ -136,6 +137,8 @@ struct grub_btrfs_chunk_item
#define GRUB_BTRFS_CHUNK_TYPE_RAID10 0x40 #define GRUB_BTRFS_CHUNK_TYPE_RAID10 0x40
#define GRUB_BTRFS_CHUNK_TYPE_RAID5 0x80 #define GRUB_BTRFS_CHUNK_TYPE_RAID5 0x80
#define GRUB_BTRFS_CHUNK_TYPE_RAID6 0x100 #define GRUB_BTRFS_CHUNK_TYPE_RAID6 0x100
#define GRUB_BTRFS_CHUNK_TYPE_RAID1C3 0x200
#define GRUB_BTRFS_CHUNK_TYPE_RAID1C4 0x400
grub_uint8_t dummy2[0xc]; grub_uint8_t dummy2[0xc];
grub_uint16_t nstripes; grub_uint16_t nstripes;
grub_uint16_t nsubstripes; grub_uint16_t nsubstripes;
@ -329,9 +332,13 @@ save_ref (struct grub_btrfs_leaf_descriptor *desc,
if (desc->allocated < desc->depth) if (desc->allocated < desc->depth)
{ {
void *newdata; void *newdata;
desc->allocated *= 2; grub_size_t sz;
newdata = grub_realloc (desc->data, sizeof (desc->data[0])
* desc->allocated); if (grub_mul (desc->allocated, 2, &desc->allocated) ||
grub_mul (desc->allocated, sizeof (desc->data[0]), &sz))
return GRUB_ERR_OUT_OF_RANGE;
newdata = grub_realloc (desc->data, sz);
if (!newdata) if (!newdata)
return grub_errno; return grub_errno;
desc->data = newdata; desc->data = newdata;
@ -413,7 +420,7 @@ lower_bound (struct grub_btrfs_data *data,
{ {
desc->allocated = 16; desc->allocated = 16;
desc->depth = 0; desc->depth = 0;
desc->data = grub_malloc (sizeof (desc->data[0]) * desc->allocated); desc->data = grub_calloc (desc->allocated, sizeof (desc->data[0]));
if (!desc->data) if (!desc->data)
return grub_errno; return grub_errno;
} }
@ -622,16 +629,21 @@ find_device (struct grub_btrfs_data *data, grub_uint64_t id)
if (data->n_devices_attached > data->n_devices_allocated) if (data->n_devices_attached > data->n_devices_allocated)
{ {
void *tmp; void *tmp;
data->n_devices_allocated = 2 * data->n_devices_attached + 1; grub_size_t sz;
data->devices_attached
= grub_realloc (tmp = data->devices_attached, if (grub_mul (data->n_devices_attached, 2, &data->n_devices_allocated) ||
data->n_devices_allocated grub_add (data->n_devices_allocated, 1, &data->n_devices_allocated) ||
* sizeof (data->devices_attached[0])); grub_mul (data->n_devices_allocated, sizeof (data->devices_attached[0]), &sz))
goto fail;
data->devices_attached = grub_realloc (tmp = data->devices_attached, sz);
if (!data->devices_attached) if (!data->devices_attached)
{ {
data->devices_attached = tmp;
fail:
if (ctx.dev_found) if (ctx.dev_found)
grub_device_close (ctx.dev_found); grub_device_close (ctx.dev_found);
data->devices_attached = tmp;
return NULL; return NULL;
} }
} }
@ -752,7 +764,7 @@ raid56_read_retry (struct grub_btrfs_data *data,
grub_err_t ret = GRUB_ERR_OUT_OF_MEMORY; grub_err_t ret = GRUB_ERR_OUT_OF_MEMORY;
grub_uint64_t i, failed_devices; grub_uint64_t i, failed_devices;
buffers = grub_zalloc (sizeof(*buffers) * nstripes); buffers = grub_calloc (nstripes, sizeof (*buffers));
if (!buffers) if (!buffers)
goto cleanup; goto cleanup;
@ -964,14 +976,19 @@ grub_btrfs_read_logical (struct grub_btrfs_data *data, grub_disk_addr_t addr,
csize = (stripen + 1) * stripe_length - off; csize = (stripen + 1) * stripe_length - off;
break; break;
} }
case GRUB_BTRFS_CHUNK_TYPE_RAID1C4:
redundancy++;
/* fall through */
case GRUB_BTRFS_CHUNK_TYPE_RAID1C3:
redundancy++;
/* fall through */
case GRUB_BTRFS_CHUNK_TYPE_DUPLICATED: case GRUB_BTRFS_CHUNK_TYPE_DUPLICATED:
case GRUB_BTRFS_CHUNK_TYPE_RAID1: case GRUB_BTRFS_CHUNK_TYPE_RAID1:
{ {
grub_dprintf ("btrfs", "RAID1\n"); grub_dprintf ("btrfs", "RAID1 (copies: %d)\n", ++redundancy);
stripen = 0; stripen = 0;
stripe_offset = off; stripe_offset = off;
csize = grub_le_to_cpu64 (chunk->size) - off; csize = grub_le_to_cpu64 (chunk->size) - off;
redundancy = 2;
break; break;
} }
case GRUB_BTRFS_CHUNK_TYPE_RAID0: case GRUB_BTRFS_CHUNK_TYPE_RAID0:
@ -2160,7 +2177,7 @@ grub_btrfs_embed (grub_device_t device __attribute__ ((unused)),
*nsectors = 64 * 2 - 1; *nsectors = 64 * 2 - 1;
if (*nsectors > max_nsectors) if (*nsectors > max_nsectors)
*nsectors = max_nsectors; *nsectors = max_nsectors;
*sectors = grub_malloc (*nsectors * sizeof (**sectors)); *sectors = grub_calloc (*nsectors, sizeof (**sectors));
if (!*sectors) if (!*sectors)
return grub_errno; return grub_errno;
for (i = 0; i < *nsectors; i++) for (i = 0; i < *nsectors; i++)

10
grub-core/fs/ext2.c
View file

@ -46,6 +46,7 @@
#include <grub/dl.h> #include <grub/dl.h>
#include <grub/types.h> #include <grub/types.h>
#include <grub/fshelp.h> #include <grub/fshelp.h>
#include <grub/safemath.h>
GRUB_MOD_LICENSE ("GPLv3+"); GRUB_MOD_LICENSE ("GPLv3+");
@ -703,6 +704,7 @@ grub_ext2_read_symlink (grub_fshelp_node_t node)
{ {
char *symlink; char *symlink;
struct grub_fshelp_node *diro = node; struct grub_fshelp_node *diro = node;
grub_size_t sz;
if (! diro->inode_read) if (! diro->inode_read)
{ {
@ -717,7 +719,13 @@ grub_ext2_read_symlink (grub_fshelp_node_t node)
} }
} }
symlink = grub_malloc (grub_le_to_cpu32 (diro->inode.size) + 1); if (grub_add (grub_le_to_cpu32 (diro->inode.size), 1, &sz))
{
grub_error (GRUB_ERR_OUT_OF_RANGE, N_("overflow is detected"));
return NULL;
}
symlink = grub_malloc (sz);
if (! symlink) if (! symlink)
return 0; return 0;

91
grub-core/fs/fat.c
View file

@ -26,6 +26,7 @@
#include <grub/err.h> #include <grub/err.h>
#include <grub/dl.h> #include <grub/dl.h>
#include <grub/charset.h> #include <grub/charset.h>
#include <grub/datetime.h>
#ifndef MODE_EXFAT #ifndef MODE_EXFAT
#include <grub/fat.h> #include <grub/fat.h>
#else #else
@ -596,6 +597,7 @@ struct grub_fat_iterate_context
{ {
#ifdef MODE_EXFAT #ifdef MODE_EXFAT
struct grub_fat_dir_node dir; struct grub_fat_dir_node dir;
struct grub_fat_dir_entry entry;
#else #else
struct grub_fat_dir_entry dir; struct grub_fat_dir_entry dir;
#endif #endif
@ -642,27 +644,27 @@ grub_fat_iterate_dir_next (grub_fshelp_node_t node,
grub_memset (&ctxt->dir, 0, sizeof (ctxt->dir)); grub_memset (&ctxt->dir, 0, sizeof (ctxt->dir));
while (1) while (1)
{ {
struct grub_fat_dir_entry dir; struct grub_fat_dir_entry *dir = &ctxt->entry;
ctxt->offset += sizeof (dir); ctxt->offset += sizeof (*dir);
if (grub_fat_read_data (node->disk, node, 0, 0, ctxt->offset, sizeof (dir), if (grub_fat_read_data (node->disk, node, 0, 0, ctxt->offset, sizeof (*dir),
(char *) &dir) (char *) dir)
!= sizeof (dir)) != sizeof (*dir))
break; break;
if (dir.entry_type == 0) if (dir->entry_type == 0)
break; break;
if (!(dir.entry_type & 0x80)) if (!(dir->entry_type & 0x80))
continue; continue;
if (dir.entry_type == 0x85) if (dir->entry_type == 0x85)
{ {
unsigned i, nsec, slots = 0; unsigned i, nsec, slots = 0;
nsec = dir.type_specific.file.secondary_count; nsec = dir->type_specific.file.secondary_count;
ctxt->dir.attr = grub_cpu_to_le16 (dir.type_specific.file.attr); ctxt->dir.attr = grub_cpu_to_le16 (dir->type_specific.file.attr);
ctxt->dir.have_stream = 0; ctxt->dir.have_stream = 0;
for (i = 0; i < nsec; i++) for (i = 0; i < nsec; i++)
{ {
@ -705,7 +707,7 @@ grub_fat_iterate_dir_next (grub_fshelp_node_t node,
if (i != nsec) if (i != nsec)
{ {
ctxt->offset -= sizeof (dir); ctxt->offset -= sizeof (*dir);
continue; continue;
} }
@ -715,20 +717,47 @@ grub_fat_iterate_dir_next (grub_fshelp_node_t node,
return 0; return 0;
} }
/* Allocation bitmap. */ /* Allocation bitmap. */
if (dir.entry_type == 0x81) if (dir->entry_type == 0x81)
continue; continue;
/* Upcase table. */ /* Upcase table. */
if (dir.entry_type == 0x82) if (dir->entry_type == 0x82)
continue; continue;
/* Volume label. */ /* Volume label. */
if (dir.entry_type == 0x83) if (dir->entry_type == 0x83)
continue; continue;
grub_dprintf ("exfat", "unknown primary type 0x%02x\n", grub_dprintf ("exfat", "unknown primary type 0x%02x\n",
dir.entry_type); dir->entry_type);
} }
return grub_errno ? : GRUB_ERR_EOF; return grub_errno ? : GRUB_ERR_EOF;
} }
/*
* Convert a timestamp in exFAT format to seconds since the UNIX epoch
* according to sections 7.4.8 and 7.4.9 in the exFAT specification.
* https://docs.microsoft.com/en-us/windows/win32/fileio/exfat-specification
*/
static int
grub_exfat_timestamp (grub_uint32_t field, grub_uint8_t msec, grub_int32_t *nix) {
struct grub_datetime datetime = {
.year = (field >> 25) + 1980,
.month = (field & 0x01E00000) >> 21,
.day = (field & 0x001F0000) >> 16,
.hour = (field & 0x0000F800) >> 11,
.minute = (field & 0x000007E0) >> 5,
.second = (field & 0x0000001F) * 2 + (msec >= 100 ? 1 : 0),
};
/* The conversion below allows seconds=60, so don't trust its validation. */
if ((field & 0x1F) > 29)
return 0;
/* Validate the 10-msec field even though it is rounded down to seconds. */
if (msec > 199)
return 0;
return grub_datetime2unixtime (&datetime, nix);
}
#else #else
static grub_err_t static grub_err_t
@ -856,6 +885,29 @@ grub_fat_iterate_dir_next (grub_fshelp_node_t node,
return grub_errno ? : GRUB_ERR_EOF; return grub_errno ? : GRUB_ERR_EOF;
} }
/*
* Convert a date and time in FAT format to seconds since the UNIX epoch
* according to sections 11.3.5 and 11.3.6 in ECMA-107.
* https://www.ecma-international.org/publications/files/ECMA-ST/Ecma-107.pdf
*/
static int
grub_fat_timestamp (grub_uint16_t time, grub_uint16_t date, grub_int32_t *nix) {
struct grub_datetime datetime = {
.year = (date >> 9) + 1980,
.month = (date & 0x01E0) >> 5,
.day = (date & 0x001F),
.hour = (time >> 11),
.minute = (time & 0x07E0) >> 5,
.second = (time & 0x001F) * 2,
};
/* The conversion below allows seconds=60, so don't trust its validation. */
if ((time & 0x1F) > 29)
return 0;
return grub_datetime2unixtime (&datetime, nix);
}
#endif #endif
static grub_err_t lookup_file (grub_fshelp_node_t node, static grub_err_t lookup_file (grub_fshelp_node_t node,
@ -965,10 +1017,19 @@ grub_fat_dir (grub_device_t device, const char *path, grub_fs_dir_hook_t hook,
#ifdef MODE_EXFAT #ifdef MODE_EXFAT
if (!ctxt.dir.have_stream) if (!ctxt.dir.have_stream)
continue; continue;
info.mtimeset = grub_exfat_timestamp (grub_le_to_cpu32 (ctxt.entry.type_specific.file.m_time),
ctxt.entry.type_specific.file.m_time_tenth,
&info.mtime);
#else #else
if (ctxt.dir.attr & GRUB_FAT_ATTR_VOLUME_ID) if (ctxt.dir.attr & GRUB_FAT_ATTR_VOLUME_ID)
continue; continue;
info.mtimeset = grub_fat_timestamp (grub_le_to_cpu16 (ctxt.dir.w_time),
grub_le_to_cpu16 (ctxt.dir.w_date),
&info.mtime);
#endif #endif
if (info.mtimeset == 0)
grub_error (GRUB_ERR_OUT_OF_RANGE,
"invalid modification timestamp for %s", path);
if (hook (ctxt.filename, &info, hook_data)) if (hook (ctxt.filename, &info, hook_data))
break; break;

2
grub-core/fs/hfs.c
View file

@ -1360,7 +1360,7 @@ grub_hfs_label (grub_device_t device, char **label)
grub_size_t len = data->sblock.volname[0]; grub_size_t len = data->sblock.volname[0];
if (len > sizeof (data->sblock.volname) - 1) if (len > sizeof (data->sblock.volname) - 1)
len = sizeof (data->sblock.volname) - 1; len = sizeof (data->sblock.volname) - 1;
*label = grub_malloc (len * MAX_UTF8_PER_MAC_ROMAN + 1); *label = grub_calloc (MAX_UTF8_PER_MAC_ROMAN + 1, len);
if (*label) if (*label)
macroman_to_utf8 (*label, data->sblock.volname + 1, macroman_to_utf8 (*label, data->sblock.volname + 1,
len + 1, 0); len + 1, 0);

17
grub-core/fs/hfsplus.c
View file

@ -31,6 +31,7 @@
#include <grub/hfs.h> #include <grub/hfs.h>
#include <grub/charset.h> #include <grub/charset.h>
#include <grub/hfsplus.h> #include <grub/hfsplus.h>
#include <grub/safemath.h>
GRUB_MOD_LICENSE ("GPLv3+"); GRUB_MOD_LICENSE ("GPLv3+");
@ -475,8 +476,12 @@ grub_hfsplus_read_symlink (grub_fshelp_node_t node)
{ {
char *symlink; char *symlink;
grub_ssize_t numread; grub_ssize_t numread;
grub_size_t sz = node->size;
symlink = grub_malloc (node->size + 1); if (grub_add (sz, 1, &sz))
return NULL;
symlink = grub_malloc (sz);
if (!symlink) if (!symlink)
return 0; return 0;
@ -715,12 +720,12 @@ list_nodes (void *record, void *hook_arg)
if (type == GRUB_FSHELP_UNKNOWN) if (type == GRUB_FSHELP_UNKNOWN)
return 0; return 0;
filename = grub_malloc (grub_be_to_cpu16 (catkey->namelen) filename = grub_calloc (grub_be_to_cpu16 (catkey->namelen),
* GRUB_MAX_UTF8_PER_UTF16 + 1); GRUB_MAX_UTF8_PER_UTF16 + 1);
if (! filename) if (! filename)
return 0; return 0;
keyname = grub_malloc (grub_be_to_cpu16 (catkey->namelen) * sizeof (*keyname)); keyname = grub_calloc (grub_be_to_cpu16 (catkey->namelen), sizeof (*keyname));
if (!keyname) if (!keyname)
{ {
grub_free (filename); grub_free (filename);
@ -1007,7 +1012,7 @@ grub_hfsplus_label (grub_device_t device, char **label)
grub_hfsplus_btree_recptr (&data->catalog_tree, node, ptr); grub_hfsplus_btree_recptr (&data->catalog_tree, node, ptr);
label_len = grub_be_to_cpu16 (catkey->namelen); label_len = grub_be_to_cpu16 (catkey->namelen);
label_name = grub_malloc (label_len * sizeof (*label_name)); label_name = grub_calloc (label_len, sizeof (*label_name));
if (!label_name) if (!label_name)
{ {
grub_free (node); grub_free (node);
@ -1029,7 +1034,7 @@ grub_hfsplus_label (grub_device_t device, char **label)
} }
} }
*label = grub_malloc (label_len * GRUB_MAX_UTF8_PER_UTF16 + 1); *label = grub_calloc (label_len, GRUB_MAX_UTF8_PER_UTF16 + 1);
if (! *label) if (! *label)
{ {
grub_free (label_name); grub_free (label_name);

71
grub-core/fs/iso9660.c
View file

@ -28,6 +28,7 @@
#include <grub/fshelp.h> #include <grub/fshelp.h>
#include <grub/charset.h> #include <grub/charset.h>
#include <grub/datetime.h> #include <grub/datetime.h>
#include <grub/safemath.h>
GRUB_MOD_LICENSE ("GPLv3+"); GRUB_MOD_LICENSE ("GPLv3+");
@ -331,7 +332,7 @@ grub_iso9660_convert_string (grub_uint8_t *us, int len)
int i; int i;
grub_uint16_t t[MAX_NAMELEN / 2 + 1]; grub_uint16_t t[MAX_NAMELEN / 2 + 1];
p = grub_malloc (len * GRUB_MAX_UTF8_PER_UTF16 + 1); p = grub_calloc (len, GRUB_MAX_UTF8_PER_UTF16 + 1);
if (! p) if (! p)
return NULL; return NULL;
@ -531,11 +532,22 @@ add_part (struct iterate_dir_ctx *ctx,
int len2) int len2)
{ {
int size = ctx->symlink ? grub_strlen (ctx->symlink) : 0; int size = ctx->symlink ? grub_strlen (ctx->symlink) : 0;
grub_size_t sz;
char *new;
ctx->symlink = grub_realloc (ctx->symlink, size + len2 + 1); if (grub_add (size, len2, &sz) ||
if (! ctx->symlink) grub_add (sz, 1, &sz))
return; return;
new = grub_realloc (ctx->symlink, sz);
if (!new)
{
grub_free (ctx->symlink);
ctx->symlink = NULL;
return;
}
ctx->symlink = new;
grub_memcpy (ctx->symlink + size, part, len2); grub_memcpy (ctx->symlink + size, part, len2);
ctx->symlink[size + len2] = 0; ctx->symlink[size + len2] = 0;
} }
@ -560,17 +572,24 @@ susp_iterate_dir (struct grub_iso9660_susp_entry *entry,
{ {
grub_size_t off = 0, csize = 1; grub_size_t off = 0, csize = 1;
char *old; char *old;
grub_size_t sz;
csize = entry->len - 5; csize = entry->len - 5;
old = ctx->filename; old = ctx->filename;
if (ctx->filename_alloc) if (ctx->filename_alloc)
{ {
off = grub_strlen (ctx->filename); off = grub_strlen (ctx->filename);
ctx->filename = grub_realloc (ctx->filename, csize + off + 1); if (grub_add (csize, off, &sz) ||
grub_add (sz, 1, &sz))
return GRUB_ERR_OUT_OF_RANGE;
ctx->filename = grub_realloc (ctx->filename, sz);
} }
else else
{ {
off = 0; off = 0;
ctx->filename = grub_zalloc (csize + 1); if (grub_add (csize, 1, &sz))
return GRUB_ERR_OUT_OF_RANGE;
ctx->filename = grub_zalloc (sz);
} }
if (!ctx->filename) if (!ctx->filename)
{ {
@ -621,7 +640,12 @@ susp_iterate_dir (struct grub_iso9660_susp_entry *entry,
is the length. Both are part of the `Component is the length. Both are part of the `Component
Record'. */ Record'. */
if (ctx->symlink && !ctx->was_continue) if (ctx->symlink && !ctx->was_continue)
{
add_part (ctx, "/", 1); add_part (ctx, "/", 1);
if (grub_errno)
return grub_errno;
}
add_part (ctx, (char *) &entry->data[pos + 2], add_part (ctx, (char *) &entry->data[pos + 2],
entry->data[pos + 1]); entry->data[pos + 1]);
ctx->was_continue = (entry->data[pos] & 1); ctx->was_continue = (entry->data[pos] & 1);
@ -640,6 +664,11 @@ susp_iterate_dir (struct grub_iso9660_susp_entry *entry,
add_part (ctx, "/", 1); add_part (ctx, "/", 1);
break; break;
} }
/* Check if grub_realloc() failed in add_part(). */
if (grub_errno)
return grub_errno;
/* In pos + 1 the length of the `Component Record' is /* In pos + 1 the length of the `Component Record' is
stored. */ stored. */
pos += entry->data[pos + 1] + 2; pos += entry->data[pos + 1] + 2;
@ -776,14 +805,18 @@ grub_iso9660_iterate_dir (grub_fshelp_node_t dir,
if (node->have_dirents >= node->alloc_dirents) if (node->have_dirents >= node->alloc_dirents)
{ {
struct grub_fshelp_node *new_node; struct grub_fshelp_node *new_node;
node->alloc_dirents *= 2; grub_size_t sz;
new_node = grub_realloc (node,
sizeof (struct grub_fshelp_node) if (grub_mul (node->alloc_dirents, 2, &node->alloc_dirents) ||
+ ((node->alloc_dirents grub_sub (node->alloc_dirents, ARRAY_SIZE (node->dirents), &sz) ||
- ARRAY_SIZE (node->dirents)) grub_mul (sz, sizeof (node->dirents[0]), &sz) ||
* sizeof (node->dirents[0]))); grub_add (sz, sizeof (struct grub_fshelp_node), &sz))
goto fail_0;
new_node = grub_realloc (node, sz);
if (!new_node) if (!new_node)
{ {
fail_0:
if (ctx.filename_alloc) if (ctx.filename_alloc)
grub_free (ctx.filename); grub_free (ctx.filename);
grub_free (node); grub_free (node);
@ -799,14 +832,18 @@ grub_iso9660_iterate_dir (grub_fshelp_node_t dir,
* sizeof (node->dirents[0]) < grub_strlen (ctx.symlink) + 1) * sizeof (node->dirents[0]) < grub_strlen (ctx.symlink) + 1)
{ {
struct grub_fshelp_node *new_node; struct grub_fshelp_node *new_node;
new_node = grub_realloc (node, grub_size_t sz;
sizeof (struct grub_fshelp_node)
+ ((node->alloc_dirents if (grub_sub (node->alloc_dirents, ARRAY_SIZE (node->dirents), &sz) ||
- ARRAY_SIZE (node->dirents)) grub_mul (sz, sizeof (node->dirents[0]), &sz) ||
* sizeof (node->dirents[0])) grub_add (sz, sizeof (struct grub_fshelp_node) + 1, &sz) ||
+ grub_strlen (ctx.symlink) + 1); grub_add (sz, grub_strlen (ctx.symlink), &sz))
goto fail_1;
new_node = grub_realloc (node, sz);
if (!new_node) if (!new_node)
{ {
fail_1:
if (ctx.filename_alloc) if (ctx.filename_alloc)
grub_free (ctx.filename); grub_free (ctx.filename);
grub_free (node); grub_free (node);

4
grub-core/fs/ntfs.c
View file

@ -556,8 +556,8 @@ get_utf8 (grub_uint8_t *in, grub_size_t len)
grub_uint16_t *tmp; grub_uint16_t *tmp;
grub_size_t i; grub_size_t i;
buf = grub_malloc (len * GRUB_MAX_UTF8_PER_UTF16 + 1); buf = grub_calloc (len, GRUB_MAX_UTF8_PER_UTF16 + 1);
tmp = grub_malloc (len * sizeof (tmp[0])); tmp = grub_calloc (len, sizeof (tmp[0]));
if (!buf || !tmp) if (!buf || !tmp)
{ {
grub_free (buf); grub_free (buf);

29
grub-core/fs/sfs.c
View file

@ -26,6 +26,7 @@
#include <grub/types.h> #include <grub/types.h>
#include <grub/fshelp.h> #include <grub/fshelp.h>
#include <grub/charset.h> #include <grub/charset.h>
#include <grub/safemath.h>
GRUB_MOD_LICENSE ("GPLv3+"); GRUB_MOD_LICENSE ("GPLv3+");
@ -266,7 +267,7 @@ grub_sfs_read_block (grub_fshelp_node_t node, grub_disk_addr_t fileblock)
node->next_extent = node->block; node->next_extent = node->block;
node->cache_size = 0; node->cache_size = 0;
node->cache = grub_malloc (sizeof (node->cache[0]) * cache_size); node->cache = grub_calloc (cache_size, sizeof (node->cache[0]));
if (!node->cache) if (!node->cache)
{ {
grub_errno = 0; grub_errno = 0;
@ -307,10 +308,15 @@ grub_sfs_read_block (grub_fshelp_node_t node, grub_disk_addr_t fileblock)
if (node->cache && node->cache_size >= node->cache_allocated) if (node->cache && node->cache_size >= node->cache_allocated)
{ {
struct cache_entry *e = node->cache; struct cache_entry *e = node->cache;
e = grub_realloc (node->cache,node->cache_allocated * 2 grub_size_t sz;
* sizeof (e[0]));
if (grub_mul (node->cache_allocated, 2 * sizeof (e[0]), &sz))
goto fail;
e = grub_realloc (node->cache, sz);
if (!e) if (!e)
{ {
fail:
grub_errno = 0; grub_errno = 0;
grub_free (node->cache); grub_free (node->cache);
node->cache = 0; node->cache = 0;
@ -477,10 +483,16 @@ grub_sfs_create_node (struct grub_fshelp_node **node,
grub_size_t len = grub_strlen (name); grub_size_t len = grub_strlen (name);
grub_uint8_t *name_u8; grub_uint8_t *name_u8;
int ret; int ret;
grub_size_t sz;
if (grub_mul (len, GRUB_MAX_UTF8_PER_LATIN1, &sz) ||
grub_add (sz, 1, &sz))
return 1;
*node = grub_malloc (sizeof (**node)); *node = grub_malloc (sizeof (**node));
if (!*node) if (!*node)
return 1; return 1;
name_u8 = grub_malloc (len * GRUB_MAX_UTF8_PER_LATIN1 + 1); name_u8 = grub_malloc (sz);
if (!name_u8) if (!name_u8)
{ {
grub_free (*node); grub_free (*node);
@ -724,8 +736,13 @@ grub_sfs_label (grub_device_t device, char **label)
data = grub_sfs_mount (disk); data = grub_sfs_mount (disk);
if (data) if (data)
{ {
grub_size_t len = grub_strlen (data->label); grub_size_t sz, len = grub_strlen (data->label);
*label = grub_malloc (len * GRUB_MAX_UTF8_PER_LATIN1 + 1);
if (grub_mul (len, GRUB_MAX_UTF8_PER_LATIN1, &sz) ||
grub_add (sz, 1, &sz))
return GRUB_ERR_OUT_OF_RANGE;
*label = grub_malloc (sz);
if (*label) if (*label)
*grub_latin1_to_utf8 ((grub_uint8_t *) *label, *grub_latin1_to_utf8 ((grub_uint8_t *) *label,
(const grub_uint8_t *) data->label, (const grub_uint8_t *) data->label,

47
grub-core/fs/squash4.c
View file

@ -26,6 +26,7 @@
#include <grub/types.h> #include <grub/types.h>
#include <grub/fshelp.h> #include <grub/fshelp.h>
#include <grub/deflate.h> #include <grub/deflate.h>
#include <grub/safemath.h>
#include <minilzo.h> #include <minilzo.h>
#include "xz.h" #include "xz.h"
@ -459,7 +460,17 @@ grub_squash_read_symlink (grub_fshelp_node_t node)
{ {
char *ret; char *ret;
grub_err_t err; grub_err_t err;
ret = grub_malloc (grub_le_to_cpu32 (node->ino.symlink.namelen) + 1); grub_size_t sz;
if (grub_add (grub_le_to_cpu32 (node->ino.symlink.namelen), 1, &sz))
{
grub_error (GRUB_ERR_OUT_OF_RANGE, N_("overflow is detected"));
return NULL;
}
ret = grub_malloc (sz);
if (!ret)
return NULL;
err = read_chunk (node->data, ret, err = read_chunk (node->data, ret,
grub_le_to_cpu32 (node->ino.symlink.namelen), grub_le_to_cpu32 (node->ino.symlink.namelen),
@ -506,11 +517,16 @@ grub_squash_iterate_dir (grub_fshelp_node_t dir,
{ {
grub_fshelp_node_t node; grub_fshelp_node_t node;
node = grub_malloc (sizeof (*node) + dir->stsize * sizeof (dir->stack[0])); grub_size_t sz;
if (grub_mul (dir->stsize, sizeof (dir->stack[0]), &sz) ||
grub_add (sz, sizeof (*node), &sz))
return 0;
node = grub_malloc (sz);
if (!node) if (!node)
return 0; return 0;
grub_memcpy (node, dir, grub_memcpy (node, dir, sz);
sizeof (*node) + dir->stsize * sizeof (dir->stack[0]));
if (hook (".", GRUB_FSHELP_DIR, node, hook_data)) if (hook (".", GRUB_FSHELP_DIR, node, hook_data))
return 1; return 1;
@ -518,12 +534,15 @@ grub_squash_iterate_dir (grub_fshelp_node_t dir,
{ {
grub_err_t err; grub_err_t err;
node = grub_malloc (sizeof (*node) + dir->stsize * sizeof (dir->stack[0])); if (grub_mul (dir->stsize, sizeof (dir->stack[0]), &sz) ||
grub_add (sz, sizeof (*node), &sz))
return 0;
node = grub_malloc (sz);
if (!node) if (!node)
return 0; return 0;
grub_memcpy (node, dir, grub_memcpy (node, dir, sz);
sizeof (*node) + dir->stsize * sizeof (dir->stack[0]));
node->stsize--; node->stsize--;
err = read_chunk (dir->data, &node->ino, sizeof (node->ino), err = read_chunk (dir->data, &node->ino, sizeof (node->ino),
@ -557,6 +576,7 @@ grub_squash_iterate_dir (grub_fshelp_node_t dir,
enum grub_fshelp_filetype filetype = GRUB_FSHELP_REG; enum grub_fshelp_filetype filetype = GRUB_FSHELP_REG;
struct grub_squash_dirent di; struct grub_squash_dirent di;
struct grub_squash_inode ino; struct grub_squash_inode ino;
grub_size_t sz;
err = read_chunk (dir->data, &di, sizeof (di), err = read_chunk (dir->data, &di, sizeof (di),
grub_le_to_cpu64 (dir->data->sb.diroffset) grub_le_to_cpu64 (dir->data->sb.diroffset)
@ -589,13 +609,16 @@ grub_squash_iterate_dir (grub_fshelp_node_t dir,
if (grub_le_to_cpu16 (di.type) == SQUASH_TYPE_SYMLINK) if (grub_le_to_cpu16 (di.type) == SQUASH_TYPE_SYMLINK)
filetype = GRUB_FSHELP_SYMLINK; filetype = GRUB_FSHELP_SYMLINK;
node = grub_malloc (sizeof (*node) if (grub_add (dir->stsize, 1, &sz) ||
+ (dir->stsize + 1) * sizeof (dir->stack[0])); grub_mul (sz, sizeof (dir->stack[0]), &sz) ||
grub_add (sz, sizeof (*node), &sz))
return 0;
node = grub_malloc (sz);
if (! node) if (! node)
return 0; return 0;
grub_memcpy (node, dir, grub_memcpy (node, dir, sz - sizeof(dir->stack[0]));
sizeof (*node) + dir->stsize * sizeof (dir->stack[0]));
node->ino = ino; node->ino = ino;
node->stack[node->stsize].ino_chunk = grub_le_to_cpu32 (dh.ino_chunk); node->stack[node->stsize].ino_chunk = grub_le_to_cpu32 (dh.ino_chunk);
@ -746,7 +769,7 @@ direct_read (struct grub_squash_data *data,
struct grub_squash_cache_inode *ino, struct grub_squash_cache_inode *ino,
grub_off_t off, char *buf, grub_size_t len) grub_off_t off, char *buf, grub_size_t len)
{ {
grub_err_t err; grub_err_t err = GRUB_ERR_NONE;
grub_off_t cumulated_uncompressed_size = 0; grub_off_t cumulated_uncompressed_size = 0;
grub_uint64_t a = 0; grub_uint64_t a = 0;
grub_size_t i; grub_size_t i;

2
grub-core/fs/tar.c
View file

@ -120,7 +120,7 @@ grub_cpio_find_file (struct grub_archelp_data *data, char **name,
if (data->linkname_alloc < linksize + 1) if (data->linkname_alloc < linksize + 1)
{ {
char *n; char *n;
n = grub_malloc (2 * (linksize + 1)); n = grub_calloc (2, linksize + 1);
if (!n) if (!n)
return grub_errno; return grub_errno;
grub_free (data->linkname); grub_free (data->linkname);

56
grub-core/fs/udf.c
View file

@ -28,6 +28,7 @@
#include <grub/charset.h> #include <grub/charset.h>
#include <grub/datetime.h> #include <grub/datetime.h>
#include <grub/udf.h> #include <grub/udf.h>
#include <grub/safemath.h>
GRUB_MOD_LICENSE ("GPLv3+"); GRUB_MOD_LICENSE ("GPLv3+");
@ -873,7 +874,7 @@ read_string (const grub_uint8_t *raw, grub_size_t sz, char *outbuf)
{ {
unsigned i; unsigned i;
utf16len = sz - 1; utf16len = sz - 1;
utf16 = grub_malloc (utf16len * sizeof (utf16[0])); utf16 = grub_calloc (utf16len, sizeof (utf16[0]));
if (!utf16) if (!utf16)
return NULL; return NULL;
for (i = 0; i < utf16len; i++) for (i = 0; i < utf16len; i++)
@ -883,16 +884,26 @@ read_string (const grub_uint8_t *raw, grub_size_t sz, char *outbuf)
{ {
unsigned i; unsigned i;
utf16len = (sz - 1) / 2; utf16len = (sz - 1) / 2;
utf16 = grub_malloc (utf16len * sizeof (utf16[0])); utf16 = grub_calloc (utf16len, sizeof (utf16[0]));
if (!utf16) if (!utf16)
return NULL; return NULL;
for (i = 0; i < utf16len; i++) for (i = 0; i < utf16len; i++)
utf16[i] = (raw[2 * i + 1] << 8) | raw[2*i + 2]; utf16[i] = (raw[2 * i + 1] << 8) | raw[2*i + 2];
} }
if (!outbuf) if (!outbuf)
outbuf = grub_malloc (utf16len * GRUB_MAX_UTF8_PER_UTF16 + 1); {
grub_size_t size;
if (grub_mul (utf16len, GRUB_MAX_UTF8_PER_UTF16, &size) ||
grub_add (size, 1, &size))
goto fail;
outbuf = grub_malloc (size);
}
if (outbuf) if (outbuf)
*grub_utf16_to_utf8 ((grub_uint8_t *) outbuf, utf16, utf16len) = '\0'; *grub_utf16_to_utf8 ((grub_uint8_t *) outbuf, utf16, utf16len) = '\0';
fail:
grub_free (utf16); grub_free (utf16);
return outbuf; return outbuf;
} }
@ -954,8 +965,10 @@ grub_udf_iterate_dir (grub_fshelp_node_t dir,
return 0; return 0;
if (grub_udf_read_icb (dir->data, &dirent.icb, child)) if (grub_udf_read_icb (dir->data, &dirent.icb, child))
{
grub_free (child);
return 0; return 0;
}
if (dirent.characteristics & GRUB_UDF_FID_CHAR_PARENT) if (dirent.characteristics & GRUB_UDF_FID_CHAR_PARENT)
{ {
/* This is the parent directory. */ /* This is the parent directory. */
@ -977,11 +990,18 @@ grub_udf_iterate_dir (grub_fshelp_node_t dir,
dirent.file_ident_length, dirent.file_ident_length,
(char *) raw)) (char *) raw))
!= dirent.file_ident_length) != dirent.file_ident_length)
{
grub_free (child);
return 0; return 0;
}
filename = read_string (raw, dirent.file_ident_length, 0); filename = read_string (raw, dirent.file_ident_length, 0);
if (!filename) if (!filename)
{
/* As the hook won't get called. */
grub_free (child);
grub_print_error (); grub_print_error ();
}
if (filename && hook (filename, type, child, hook_data)) if (filename && hook (filename, type, child, hook_data))
{ {
@ -1005,7 +1025,7 @@ grub_udf_read_symlink (grub_fshelp_node_t node)
grub_size_t sz = U64 (node->block.fe.file_size); grub_size_t sz = U64 (node->block.fe.file_size);
grub_uint8_t *raw; grub_uint8_t *raw;
const grub_uint8_t *ptr; const grub_uint8_t *ptr;
char *out, *optr; char *out = NULL, *optr;
if (sz < 4) if (sz < 4)
return NULL; return NULL;
@ -1013,14 +1033,16 @@ grub_udf_read_symlink (grub_fshelp_node_t node)
if (!raw) if (!raw)
return NULL; return NULL;
if (grub_udf_read_file (node, NULL, NULL, 0, sz, (char *) raw) < 0) if (grub_udf_read_file (node, NULL, NULL, 0, sz, (char *) raw) < 0)
{ goto fail_1;
grub_free (raw);
return NULL;
}
out = grub_malloc (sz * 2 + 1); if (grub_mul (sz, 2, &sz) ||
grub_add (sz, 1, &sz))
goto fail_0;
out = grub_malloc (sz);
if (!out) if (!out)
{ {
fail_0:
grub_free (raw); grub_free (raw);
return NULL; return NULL;
} }
@ -1031,17 +1053,17 @@ grub_udf_read_symlink (grub_fshelp_node_t node)
{ {
grub_size_t s; grub_size_t s;
if ((grub_size_t) (ptr - raw + 4) > sz) if ((grub_size_t) (ptr - raw + 4) > sz)
goto fail; goto fail_1;
if (!(ptr[2] == 0 && ptr[3] == 0)) if (!(ptr[2] == 0 && ptr[3] == 0))
goto fail; goto fail_1;
s = 4 + ptr[1]; s = 4 + ptr[1];
if ((grub_size_t) (ptr - raw + s) > sz) if ((grub_size_t) (ptr - raw + s) > sz)
goto fail; goto fail_1;
switch (*ptr) switch (*ptr)
{ {
case 1: case 1:
if (ptr[1]) if (ptr[1])
goto fail; goto fail_1;
/* Fallthrough. */ /* Fallthrough. */
case 2: case 2:
/* in 4 bytes. out: 1 byte. */ /* in 4 bytes. out: 1 byte. */
@ -1066,11 +1088,11 @@ grub_udf_read_symlink (grub_fshelp_node_t node)
if (optr != out) if (optr != out)
*optr++ = '/'; *optr++ = '/';
if (!read_string (ptr + 4, s - 4, optr)) if (!read_string (ptr + 4, s - 4, optr))
goto fail; goto fail_1;
optr += grub_strlen (optr); optr += grub_strlen (optr);
break; break;
default: default:
goto fail; goto fail_1;
} }
ptr += s; ptr += s;
} }
@ -1078,7 +1100,7 @@ grub_udf_read_symlink (grub_fshelp_node_t node)
grub_free (raw); grub_free (raw);
return out; return out;
fail: fail_1:
grub_free (raw); grub_free (raw);
grub_free (out); grub_free (out);
grub_error (GRUB_ERR_BAD_FS, "invalid symlink"); grub_error (GRUB_ERR_BAD_FS, "invalid symlink");

11
grub-core/fs/xfs.c
View file

@ -25,6 +25,7 @@
#include <grub/dl.h> #include <grub/dl.h>
#include <grub/types.h> #include <grub/types.h>
#include <grub/fshelp.h> #include <grub/fshelp.h>
#include <grub/safemath.h>
GRUB_MOD_LICENSE ("GPLv3+"); GRUB_MOD_LICENSE ("GPLv3+");
@ -899,6 +900,7 @@ static struct grub_xfs_data *
grub_xfs_mount (grub_disk_t disk) grub_xfs_mount (grub_disk_t disk)
{ {
struct grub_xfs_data *data = 0; struct grub_xfs_data *data = 0;
grub_size_t sz;
data = grub_zalloc (sizeof (struct grub_xfs_data)); data = grub_zalloc (sizeof (struct grub_xfs_data));
if (!data) if (!data)
@ -913,10 +915,11 @@ grub_xfs_mount (grub_disk_t disk)
if (!grub_xfs_sb_valid(data)) if (!grub_xfs_sb_valid(data))
goto fail; goto fail;
data = grub_realloc (data, if (grub_add (grub_xfs_inode_size (data),
sizeof (struct grub_xfs_data) sizeof (struct grub_xfs_data) - sizeof (struct grub_xfs_inode) + 1, &sz))
- sizeof (struct grub_xfs_inode) goto fail;
+ grub_xfs_inode_size(data) + 1);
data = grub_realloc (data, sz);
if (! data) if (! data)
goto fail; goto fail;

31
grub-core/fs/zfs/zfs.c
View file

@ -55,6 +55,7 @@
#include <grub/deflate.h> #include <grub/deflate.h>
#include <grub/crypto.h> #include <grub/crypto.h>
#include <grub/i18n.h> #include <grub/i18n.h>
#include <grub/safemath.h>
GRUB_MOD_LICENSE ("GPLv3+"); GRUB_MOD_LICENSE ("GPLv3+");
@ -141,7 +142,10 @@ ZAP_LEAF_NUMCHUNKS (int bs)
static inline zap_leaf_chunk_t * static inline zap_leaf_chunk_t *
ZAP_LEAF_CHUNK (zap_leaf_phys_t *l, int bs, int idx) ZAP_LEAF_CHUNK (zap_leaf_phys_t *l, int bs, int idx)
{ {
return &((zap_leaf_chunk_t *) (l->l_entries grub_properly_aligned_t *l_entries;
l_entries = (grub_properly_aligned_t *) ALIGN_UP((grub_addr_t)l->l_hash, sizeof (grub_properly_aligned_t));
return &((zap_leaf_chunk_t *) (l_entries
+ (ZAP_LEAF_HASH_NUMENTRIES(bs) * 2) + (ZAP_LEAF_HASH_NUMENTRIES(bs) * 2)
/ sizeof (grub_properly_aligned_t)))[idx]; / sizeof (grub_properly_aligned_t)))[idx];
} }
@ -773,11 +777,14 @@ fill_vdev_info (struct grub_zfs_data *data,
if (data->n_devices_attached > data->n_devices_allocated) if (data->n_devices_attached > data->n_devices_allocated)
{ {
void *tmp; void *tmp;
data->n_devices_allocated = 2 * data->n_devices_attached + 1; grub_size_t sz;
data->devices_attached
= grub_realloc (tmp = data->devices_attached, if (grub_mul (data->n_devices_attached, 2, &data->n_devices_allocated) ||
data->n_devices_allocated grub_add (data->n_devices_allocated, 1, &data->n_devices_allocated) ||
* sizeof (data->devices_attached[0])); grub_mul (data->n_devices_allocated, sizeof (data->devices_attached[0]), &sz))
return GRUB_ERR_OUT_OF_RANGE;
data->devices_attached = grub_realloc (tmp = data->devices_attached, sz);
if (!data->devices_attached) if (!data->devices_attached)
{ {
data->devices_attached = tmp; data->devices_attached = tmp;
@ -3325,7 +3332,7 @@ dnode_get_fullpath (const char *fullpath, struct subvolume *subvol,
} }
subvol->nkeys = 0; subvol->nkeys = 0;
zap_iterate (&keychain_dn, 8, count_zap_keys, &ctx, data); zap_iterate (&keychain_dn, 8, count_zap_keys, &ctx, data);
subvol->keyring = grub_zalloc (subvol->nkeys * sizeof (subvol->keyring[0])); subvol->keyring = grub_calloc (subvol->nkeys, sizeof (subvol->keyring[0]));
if (!subvol->keyring) if (!subvol->keyring)
{ {
grub_free (fsname); grub_free (fsname);
@ -3468,14 +3475,18 @@ grub_zfs_nvlist_lookup_nvlist (const char *nvlist, const char *name)
{ {
char *nvpair; char *nvpair;
char *ret; char *ret;
grub_size_t size; grub_size_t size, sz;
int found; int found;
found = nvlist_find_value (nvlist, name, DATA_TYPE_NVLIST, &nvpair, found = nvlist_find_value (nvlist, name, DATA_TYPE_NVLIST, &nvpair,
&size, 0); &size, 0);
if (!found) if (!found)
return 0; return 0;
ret = grub_zalloc (size + 3 * sizeof (grub_uint32_t));
if (grub_add (size, 3 * sizeof (grub_uint32_t), &sz))
return 0;
ret = grub_zalloc (sz);
if (!ret) if (!ret)
return 0; return 0;
grub_memcpy (ret, nvlist, sizeof (grub_uint32_t)); grub_memcpy (ret, nvlist, sizeof (grub_uint32_t));
@ -4336,7 +4347,7 @@ grub_zfs_embed (grub_device_t device __attribute__ ((unused)),
*nsectors = (VDEV_BOOT_SIZE >> GRUB_DISK_SECTOR_BITS); *nsectors = (VDEV_BOOT_SIZE >> GRUB_DISK_SECTOR_BITS);
if (*nsectors > max_nsectors) if (*nsectors > max_nsectors)
*nsectors = max_nsectors; *nsectors = max_nsectors;
*sectors = grub_malloc (*nsectors * sizeof (**sectors)); *sectors = grub_calloc (*nsectors, sizeof (**sectors));
if (!*sectors) if (!*sectors)
return grub_errno; return grub_errno;
for (i = 0; i < *nsectors; i++) for (i = 0; i < *nsectors; i++)

7
grub-core/fs/zfs/zfscrypt.c
View file

@ -22,6 +22,7 @@
#include <grub/misc.h> #include <grub/misc.h>
#include <grub/disk.h> #include <grub/disk.h>
#include <grub/partition.h> #include <grub/partition.h>
#include <grub/safemath.h>
#include <grub/dl.h> #include <grub/dl.h>
#include <grub/types.h> #include <grub/types.h>
#include <grub/zfs/zfs.h> #include <grub/zfs/zfs.h>
@ -82,9 +83,13 @@ grub_zfs_add_key (grub_uint8_t *key_in,
int passphrase) int passphrase)
{ {
struct grub_zfs_wrap_key *key; struct grub_zfs_wrap_key *key;
grub_size_t sz;
if (!passphrase && keylen > 32) if (!passphrase && keylen > 32)
keylen = 32; keylen = 32;
key = grub_malloc (sizeof (*key) + keylen); if (grub_add (sizeof (*key), keylen, &sz))
return GRUB_ERR_OUT_OF_RANGE;
key = grub_malloc (sz);
if (!key) if (!key)
return grub_errno; return grub_errno;
key->is_passphrase = passphrase; key->is_passphrase = passphrase;

2
grub-core/gfxmenu/gui_circular_progress.c
View file

@ -230,7 +230,7 @@ circprog_set_state (void *vself, int visible, int start,
static int static int
parse_angle (const char *value) parse_angle (const char *value)
{ {
char *ptr; const char *ptr;
int angle; int angle;
angle = grub_strtol (value, &ptr, 10); angle = grub_strtol (value, &ptr, 10);

3
grub-core/gfxmenu/gui_image.c
View file

@ -195,7 +195,10 @@ load_image (grub_gui_image_t self, const char *path)
return grub_errno; return grub_errno;
if (self->bitmap && (self->bitmap != self->raw_bitmap)) if (self->bitmap && (self->bitmap != self->raw_bitmap))
{
grub_video_bitmap_destroy (self->bitmap); grub_video_bitmap_destroy (self->bitmap);
self->bitmap = 0;
}
if (self->raw_bitmap) if (self->raw_bitmap)
grub_video_bitmap_destroy (self->raw_bitmap); grub_video_bitmap_destroy (self->raw_bitmap);

2
grub-core/gfxmenu/gui_string_util.c
View file

@ -55,7 +55,7 @@ canonicalize_path (const char *path)
if (*p == '/') if (*p == '/')
components++; components++;
char **path_array = grub_malloc (components * sizeof (*path_array)); char **path_array = grub_calloc (components, sizeof (*path_array));
if (! path_array) if (! path_array)
return 0; return 0;

2
grub-core/gfxmenu/theme_loader.c
View file

@ -484,7 +484,7 @@ parse_proportional_spec (const char *value, signed *abs, grub_fixed_signed_t *pr
ptr++; ptr++;
} }
num = grub_strtoul (ptr, (char **) &ptr, 0); num = grub_strtoul (ptr, &ptr, 0);
if (grub_errno) if (grub_errno)
return grub_errno; return grub_errno;
if (sig) if (sig)

4
grub-core/gfxmenu/widget-box.c
View file

@ -303,10 +303,10 @@ grub_gfxmenu_create_box (const char *pixmaps_prefix,
box->content_height = 0; box->content_height = 0;
box->raw_pixmaps = box->raw_pixmaps =
(struct grub_video_bitmap **) (struct grub_video_bitmap **)
grub_malloc (BOX_NUM_PIXMAPS * sizeof (struct grub_video_bitmap *)); grub_calloc (BOX_NUM_PIXMAPS, sizeof (struct grub_video_bitmap *));
box->scaled_pixmaps = box->scaled_pixmaps =
(struct grub_video_bitmap **) (struct grub_video_bitmap **)
grub_malloc (BOX_NUM_PIXMAPS * sizeof (struct grub_video_bitmap *)); grub_calloc (BOX_NUM_PIXMAPS, sizeof (struct grub_video_bitmap *));
/* Initialize all pixmap pointers to NULL so that proper destruction can /* Initialize all pixmap pointers to NULL so that proper destruction can
be performed if an error is encountered partway through construction. */ be performed if an error is encountered partway through construction. */

2
grub-core/io/gzio.c
View file

@ -554,7 +554,7 @@ huft_build (unsigned *b, /* code lengths in bits (all assumed <= BMAX) */
z = 1 << j; /* table entries for j-bit table */ z = 1 << j; /* table entries for j-bit table */
/* allocate and link in new table */ /* allocate and link in new table */
q = (struct huft *) grub_zalloc ((z + 1) * sizeof (struct huft)); q = (struct huft *) grub_calloc (z + 1, sizeof (struct huft));
if (! q) if (! q)
{ {
if (h) if (h)

11
grub-core/kern/arm/cache.c
View file

@ -93,13 +93,16 @@ probe_caches (void)
grub_arch_cache_ilinesz = 8 << (cache_type & 3); grub_arch_cache_ilinesz = 8 << (cache_type & 3);
type = ARCH_ARMV6; type = ARCH_ARMV6;
break; break;
case 0x80 ... 0x8f: default:
/*
* The CTR register is pretty much unchanged from v7 onwards,
* and is guaranteed to be backward compatible (the IDC/DIC bits
* allow certain CMOs to be elided, but performing them is never
* wrong), hence handling it like its AArch64 equivalent.
*/
grub_arch_cache_dlinesz = 4 << ((cache_type >> 16) & 0xf); grub_arch_cache_dlinesz = 4 << ((cache_type >> 16) & 0xf);
grub_arch_cache_ilinesz = 4 << (cache_type & 0xf); grub_arch_cache_ilinesz = 4 << (cache_type & 0xf);
type = ARCH_ARMV7; type = ARCH_ARMV7;
break;
default:
grub_fatal ("Unsupported cache type 0x%x", cache_type);
} }
if (grub_arch_cache_dlinesz > grub_arch_cache_ilinesz) if (grub_arch_cache_dlinesz > grub_arch_cache_ilinesz)
grub_arch_cache_max_linesz = grub_arch_cache_dlinesz; grub_arch_cache_max_linesz = grub_arch_cache_dlinesz;

3
grub-core/kern/arm/efi/init.c
View file

@ -71,4 +71,7 @@ grub_machine_fini (int flags)
efi_call_1 (b->close_event, tmr_evt); efi_call_1 (b->close_event, tmr_evt);
grub_efi_fini (); grub_efi_fini ();
if (!(flags & GRUB_LOADER_FLAG_EFI_KEEP_ALLOCATED_MEMORY))
grub_efi_memory_fini ();
} }

3
grub-core/kern/arm64/efi/init.c
View file

@ -57,4 +57,7 @@ grub_machine_fini (int flags)
return; return;
grub_efi_fini (); grub_efi_fini ();
if (!(flags & GRUB_LOADER_FLAG_EFI_KEEP_ALLOCATED_MEMORY))
grub_efi_memory_fini ();
} }

21
grub-core/kern/dl.c
View file

@ -32,21 +32,12 @@
#include <grub/env.h> #include <grub/env.h>
#include <grub/cache.h> #include <grub/cache.h>
#include <grub/i18n.h> #include <grub/i18n.h>
#include <grub/tpm.h>
/* Platforms where modules are in a readonly area of memory. */ /* Platforms where modules are in a readonly area of memory. */
#if defined(GRUB_MACHINE_QEMU) #if defined(GRUB_MACHINE_QEMU)
#define GRUB_MODULES_MACHINE_READONLY #define GRUB_MODULES_MACHINE_READONLY
#endif #endif
#ifdef GRUB_MACHINE_EMU
#include <sys/mman.h>
#endif
#ifdef GRUB_MACHINE_EFI
#include <grub/efi/efi.h>
#endif
#pragma GCC diagnostic ignored "-Wcast-align" #pragma GCC diagnostic ignored "-Wcast-align"
@ -695,15 +686,6 @@ grub_dl_load_file (const char *filename)
void *core = 0; void *core = 0;
grub_dl_t mod = 0; grub_dl_t mod = 0;
#ifdef GRUB_MACHINE_EFI
if (grub_efi_secure_boot ())
{
grub_error (GRUB_ERR_ACCESS_DENIED,
"Secure Boot forbids loading module from %s", filename);
return 0;
}
#endif
grub_boot_time ("Loading module %s", filename); grub_boot_time ("Loading module %s", filename);
file = grub_file_open (filename, GRUB_FILE_TYPE_GRUB_MODULE); file = grub_file_open (filename, GRUB_FILE_TYPE_GRUB_MODULE);
@ -730,9 +712,6 @@ grub_dl_load_file (const char *filename)
opens of the same device. */ opens of the same device. */
grub_file_close (file); grub_file_close (file);
grub_tpm_measure(core, size, GRUB_BINARY_PCR, filename);
grub_print_error();
mod = grub_dl_load_core (core, size); mod = grub_dl_load_core (core, size);
grub_free (core); grub_free (core);
if (! mod) if (! mod)

113
grub-core/kern/efi/efi.c
View file

@ -157,7 +157,8 @@ grub_efi_get_loaded_image (grub_efi_handle_t image_handle)
void void
grub_reboot (void) grub_reboot (void)
{ {
grub_machine_fini (GRUB_LOADER_FLAG_NORETURN); grub_machine_fini (GRUB_LOADER_FLAG_NORETURN |
GRUB_LOADER_FLAG_EFI_KEEP_ALLOCATED_MEMORY);
efi_call_4 (grub_efi_system_table->runtime_services->reset_system, efi_call_4 (grub_efi_system_table->runtime_services->reset_system,
GRUB_EFI_RESET_COLD, GRUB_EFI_SUCCESS, 0, NULL); GRUB_EFI_RESET_COLD, GRUB_EFI_SUCCESS, 0, NULL);
for (;;) ; for (;;) ;
@ -202,7 +203,7 @@ grub_efi_set_variable(const char *var, const grub_efi_guid_t *guid,
len = grub_strlen (var); len = grub_strlen (var);
len16 = len * GRUB_MAX_UTF16_PER_UTF8; len16 = len * GRUB_MAX_UTF16_PER_UTF8;
var16 = grub_malloc ((len16 + 1) * sizeof (var16[0])); var16 = grub_calloc (len16 + 1, sizeof (var16[0]));
if (!var16) if (!var16)
return grub_errno; return grub_errno;
len16 = grub_utf8_to_utf16 (var16, len16, (grub_uint8_t *) var, len, NULL); len16 = grub_utf8_to_utf16 (var16, len16, (grub_uint8_t *) var, len, NULL);
@ -237,7 +238,7 @@ grub_efi_get_variable (const char *var, const grub_efi_guid_t *guid,
len = grub_strlen (var); len = grub_strlen (var);
len16 = len * GRUB_MAX_UTF16_PER_UTF8; len16 = len * GRUB_MAX_UTF16_PER_UTF8;
var16 = grub_malloc ((len16 + 1) * sizeof (var16[0])); var16 = grub_calloc (len16 + 1, sizeof (var16[0]));
if (!var16) if (!var16)
return NULL; return NULL;
len16 = grub_utf8_to_utf16 (var16, len16, (grub_uint8_t *) var, len, NULL); len16 = grub_utf8_to_utf16 (var16, len16, (grub_uint8_t *) var, len, NULL);
@ -273,34 +274,6 @@ grub_efi_get_variable (const char *var, const grub_efi_guid_t *guid,
return NULL; return NULL;
} }
grub_efi_boolean_t
grub_efi_secure_boot (void)
{
grub_efi_guid_t efi_var_guid = GRUB_EFI_GLOBAL_VARIABLE_GUID;
grub_size_t datasize;
char *secure_boot = NULL;
char *setup_mode = NULL;
grub_efi_boolean_t ret = 0;
secure_boot = grub_efi_get_variable("SecureBoot", &efi_var_guid, &datasize);
if (datasize != 1 || !secure_boot)
goto out;
setup_mode = grub_efi_get_variable("SetupMode", &efi_var_guid, &datasize);
if (datasize != 1 || !setup_mode)
goto out;
if (*secure_boot && !*setup_mode)
ret = 1;
out:
grub_free (secure_boot);
grub_free (setup_mode);
return ret;
}
#pragma GCC diagnostic ignored "-Wcast-align" #pragma GCC diagnostic ignored "-Wcast-align"
/* Search the mods section from the PE32/PE32+ image. This code uses /* Search the mods section from the PE32/PE32+ image. This code uses
@ -336,13 +309,23 @@ grub_efi_modules_addr (void)
} }
if (i == coff_header->num_sections) if (i == coff_header->num_sections)
{
grub_dprintf("sections", "section %d is last section; invalid.\n", i);
return 0; return 0;
}
info = (struct grub_module_info *) ((char *) image->image_base info = (struct grub_module_info *) ((char *) image->image_base
+ section->virtual_address); + section->virtual_address);
if (info->magic != GRUB_MODULE_MAGIC) if (section->name[0] != '.' && info->magic != GRUB_MODULE_MAGIC)
{
grub_dprintf("sections",
"section %d has bad magic %08x, should be %08x\n",
i, info->magic, GRUB_MODULE_MAGIC);
return 0; return 0;
}
grub_dprintf("sections", "returning section info for section %d: \"%s\"\n",
i, section->name);
return (grub_addr_t) info; return (grub_addr_t) info;
} }
@ -360,7 +343,7 @@ grub_efi_get_filename (grub_efi_device_path_t *dp0)
dp = dp0; dp = dp0;
while (1) while (dp)
{ {
grub_efi_uint8_t type = GRUB_EFI_DEVICE_PATH_TYPE (dp); grub_efi_uint8_t type = GRUB_EFI_DEVICE_PATH_TYPE (dp);
grub_efi_uint8_t subtype = GRUB_EFI_DEVICE_PATH_SUBTYPE (dp); grub_efi_uint8_t subtype = GRUB_EFI_DEVICE_PATH_SUBTYPE (dp);
@ -370,9 +353,15 @@ grub_efi_get_filename (grub_efi_device_path_t *dp0)
if (type == GRUB_EFI_MEDIA_DEVICE_PATH_TYPE if (type == GRUB_EFI_MEDIA_DEVICE_PATH_TYPE
&& subtype == GRUB_EFI_FILE_PATH_DEVICE_PATH_SUBTYPE) && subtype == GRUB_EFI_FILE_PATH_DEVICE_PATH_SUBTYPE)
{ {
grub_efi_uint16_t len; grub_efi_uint16_t len = GRUB_EFI_DEVICE_PATH_LENGTH (dp);
len = ((GRUB_EFI_DEVICE_PATH_LENGTH (dp) - 4)
/ sizeof (grub_efi_char16_t)); if (len < 4)
{
grub_error (GRUB_ERR_OUT_OF_RANGE,
"malformed EFI Device Path node has length=%d", len);
return NULL;
}
len = (len - 4) / sizeof (grub_efi_char16_t);
filesize += GRUB_MAX_UTF8_PER_UTF16 * len + 2; filesize += GRUB_MAX_UTF8_PER_UTF16 * len + 2;
} }
@ -388,7 +377,7 @@ grub_efi_get_filename (grub_efi_device_path_t *dp0)
if (!name) if (!name)
return NULL; return NULL;
while (1) while (dp)
{ {
grub_efi_uint8_t type = GRUB_EFI_DEVICE_PATH_TYPE (dp); grub_efi_uint8_t type = GRUB_EFI_DEVICE_PATH_TYPE (dp);
grub_efi_uint8_t subtype = GRUB_EFI_DEVICE_PATH_SUBTYPE (dp); grub_efi_uint8_t subtype = GRUB_EFI_DEVICE_PATH_SUBTYPE (dp);
@ -404,14 +393,21 @@ grub_efi_get_filename (grub_efi_device_path_t *dp0)
*p++ = '/'; *p++ = '/';
len = ((GRUB_EFI_DEVICE_PATH_LENGTH (dp) - 4) len = GRUB_EFI_DEVICE_PATH_LENGTH (dp);
/ sizeof (grub_efi_char16_t)); if (len < 4)
{
grub_error (GRUB_ERR_OUT_OF_RANGE,
"malformed EFI Device Path node has length=%d", len);
return NULL;
}
len = (len - 4) / sizeof (grub_efi_char16_t);
fp = (grub_efi_file_path_device_path_t *) dp; fp = (grub_efi_file_path_device_path_t *) dp;
/* According to EFI spec Path Name is NULL terminated */ /* According to EFI spec Path Name is NULL terminated */
while (len > 0 && fp->path_name[len - 1] == 0) while (len > 0 && fp->path_name[len - 1] == 0)
len--; len--;
dup_name = grub_malloc (len * sizeof (*dup_name)); dup_name = grub_calloc (len, sizeof (*dup_name));
if (!dup_name) if (!dup_name)
{ {
grub_free (name); grub_free (name);
@ -480,7 +476,26 @@ grub_efi_duplicate_device_path (const grub_efi_device_path_t *dp)
; ;
p = GRUB_EFI_NEXT_DEVICE_PATH (p)) p = GRUB_EFI_NEXT_DEVICE_PATH (p))
{ {
total_size += GRUB_EFI_DEVICE_PATH_LENGTH (p); grub_size_t len = GRUB_EFI_DEVICE_PATH_LENGTH (p);
/*
* In the event that we find a node that's completely garbage, for
* example if we get to 0x7f 0x01 0x02 0x00 ... (EndInstance with a size
* of 2), GRUB_EFI_END_ENTIRE_DEVICE_PATH() will be true and
* GRUB_EFI_NEXT_DEVICE_PATH() will return NULL, so we won't continue,
* and neither should our consumers, but there won't be any error raised
* even though the device path is junk.
*
* This keeps us from passing junk down back to our caller.
*/
if (len < 4)
{
grub_error (GRUB_ERR_OUT_OF_RANGE,
"malformed EFI Device Path node has length=%d", len);
return NULL;
}
total_size += len;
if (GRUB_EFI_END_ENTIRE_DEVICE_PATH (p)) if (GRUB_EFI_END_ENTIRE_DEVICE_PATH (p))
break; break;
} }
@ -525,7 +540,7 @@ dump_vendor_path (const char *type, grub_efi_vendor_device_path_t *vendor)
void void
grub_efi_print_device_path (grub_efi_device_path_t *dp) grub_efi_print_device_path (grub_efi_device_path_t *dp)
{ {
while (1) while (GRUB_EFI_DEVICE_PATH_VALID (dp))
{ {
grub_efi_uint8_t type = GRUB_EFI_DEVICE_PATH_TYPE (dp); grub_efi_uint8_t type = GRUB_EFI_DEVICE_PATH_TYPE (dp);
grub_efi_uint8_t subtype = GRUB_EFI_DEVICE_PATH_SUBTYPE (dp); grub_efi_uint8_t subtype = GRUB_EFI_DEVICE_PATH_SUBTYPE (dp);
@ -937,7 +952,10 @@ grub_efi_compare_device_paths (const grub_efi_device_path_t *dp1,
/* Return non-zero. */ /* Return non-zero. */
return 1; return 1;
while (1) if (dp1 == dp2)
return 0;
while (GRUB_EFI_DEVICE_PATH_VALID (dp1) && GRUB_EFI_DEVICE_PATH_VALID (dp2))
{ {
grub_efi_uint8_t type1, type2; grub_efi_uint8_t type1, type2;
grub_efi_uint8_t subtype1, subtype2; grub_efi_uint8_t subtype1, subtype2;
@ -973,5 +991,14 @@ grub_efi_compare_device_paths (const grub_efi_device_path_t *dp1,
dp2 = (grub_efi_device_path_t *) ((char *) dp2 + len2); dp2 = (grub_efi_device_path_t *) ((char *) dp2 + len2);
} }
/*
* There's no "right" answer here, but we probably don't want to call a valid
* dp and an invalid dp equal, so pick one way or the other.
*/
if (GRUB_EFI_DEVICE_PATH_VALID (dp1) && !GRUB_EFI_DEVICE_PATH_VALID (dp2))
return 1;
else if (!GRUB_EFI_DEVICE_PATH_VALID (dp1) && GRUB_EFI_DEVICE_PATH_VALID (dp2))
return -1;
return 0; return 0;
} }

1
grub-core/kern/efi/init.c
View file

@ -80,5 +80,4 @@ grub_efi_fini (void)
{ {
grub_efidisk_fini (); grub_efidisk_fini ();
grub_console_fini (); grub_console_fini ();
grub_efi_memory_fini ();
} }

49
grub-core/kern/efi/mm.c
View file

@ -49,38 +49,6 @@ static grub_efi_uintn_t finish_desc_size;
static grub_efi_uint32_t finish_desc_version; static grub_efi_uint32_t finish_desc_version;
int grub_efi_is_finished = 0; int grub_efi_is_finished = 0;
/* Allocate pages below a specified address */
void *
grub_efi_allocate_pages_max (grub_efi_physical_address_t max,
grub_efi_uintn_t pages)
{
grub_efi_status_t status;
grub_efi_boot_services_t *b;
grub_efi_physical_address_t address = max;
if (max > 0xffffffff)
return 0;
b = grub_efi_system_table->boot_services;
status = efi_call_4 (b->allocate_pages, GRUB_EFI_ALLOCATE_MAX_ADDRESS, GRUB_EFI_LOADER_DATA, pages, &address);
if (status != GRUB_EFI_SUCCESS)
return 0;
if (address == 0)
{
/* Uggh, the address 0 was allocated... This is too annoying,
so reallocate another one. */
address = max;
status = efi_call_4 (b->allocate_pages, GRUB_EFI_ALLOCATE_MAX_ADDRESS, GRUB_EFI_LOADER_DATA, pages, &address);
grub_efi_free_pages (0, pages);
if (status != GRUB_EFI_SUCCESS)
return 0;
}
return (void *) ((grub_addr_t) address);
}
/* /*
* We need to roll back EFI allocations on exit. Remember allocations that * We need to roll back EFI allocations on exit. Remember allocations that
* we'll free on exit. * we'll free on exit.
@ -157,12 +125,20 @@ grub_efi_allocate_pages_real (grub_efi_physical_address_t address,
/* Limit the memory access to less than 4GB for 32-bit platforms. */ /* Limit the memory access to less than 4GB for 32-bit platforms. */
if (address > GRUB_EFI_MAX_USABLE_ADDRESS) if (address > GRUB_EFI_MAX_USABLE_ADDRESS)
return 0; {
grub_error (GRUB_ERR_BAD_ARGUMENT,
N_("invalid memory address (0x%llx > 0x%llx)"),
address, GRUB_EFI_MAX_USABLE_ADDRESS);
return NULL;
}
b = grub_efi_system_table->boot_services; b = grub_efi_system_table->boot_services;
status = efi_call_4 (b->allocate_pages, alloctype, memtype, pages, &address); status = efi_call_4 (b->allocate_pages, alloctype, memtype, pages, &address);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
return 0; {
grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
return NULL;
}
if (address == 0) if (address == 0)
{ {
@ -172,7 +148,10 @@ grub_efi_allocate_pages_real (grub_efi_physical_address_t address,
status = efi_call_4 (b->allocate_pages, alloctype, memtype, pages, &address); status = efi_call_4 (b->allocate_pages, alloctype, memtype, pages, &address);
grub_efi_free_pages (0, pages); grub_efi_free_pages (0, pages);
if (status != GRUB_EFI_SUCCESS) if (status != GRUB_EFI_SUCCESS)
return 0; {
grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
return NULL;
}
} }
grub_efi_store_alloc (address, pages); grub_efi_store_alloc (address, pages);

273
grub-core/kern/efi/tpm.c
View file

@ -1,273 +0,0 @@
#include <grub/err.h>
#include <grub/i18n.h>
#include <grub/efi/api.h>
#include <grub/efi/efi.h>
#include <grub/efi/tpm.h>
#include <grub/mm.h>
#include <grub/tpm.h>
#include <grub/term.h>
static grub_efi_guid_t tpm_guid = EFI_TPM_GUID;
static grub_efi_guid_t tpm2_guid = EFI_TPM2_GUID;
static grub_efi_boolean_t grub_tpm_present(grub_efi_tpm_protocol_t *tpm)
{
grub_efi_status_t status;
TCG_EFI_BOOT_SERVICE_CAPABILITY caps;
grub_uint32_t flags;
grub_efi_physical_address_t eventlog, lastevent;
caps.Size = (grub_uint8_t)sizeof(caps);
status = efi_call_5(tpm->status_check, tpm, &caps, &flags, &eventlog,
&lastevent);
if (status != GRUB_EFI_SUCCESS || caps.TPMDeactivatedFlag
|| !caps.TPMPresentFlag)
return 0;
return 1;
}
static grub_efi_boolean_t grub_tpm2_present(grub_efi_tpm2_protocol_t *tpm)
{
grub_efi_status_t status;
EFI_TCG2_BOOT_SERVICE_CAPABILITY caps;
caps.Size = (grub_uint8_t)sizeof(caps);
status = efi_call_2(tpm->get_capability, tpm, &caps);
if (status != GRUB_EFI_SUCCESS || !caps.TPMPresentFlag)
return 0;
return 1;
}
static grub_efi_boolean_t grub_tpm_handle_find(grub_efi_handle_t *tpm_handle,
grub_efi_uint8_t *protocol_version)
{
grub_efi_handle_t *handles;
grub_efi_uintn_t num_handles;
handles = grub_efi_locate_handle (GRUB_EFI_BY_PROTOCOL, &tpm_guid, NULL,
&num_handles);
if (handles && num_handles > 0) {
*tpm_handle = handles[0];
*protocol_version = 1;
return 1;
}
handles = grub_efi_locate_handle (GRUB_EFI_BY_PROTOCOL, &tpm2_guid, NULL,
&num_handles);
if (handles && num_handles > 0) {
*tpm_handle = handles[0];
*protocol_version = 2;
return 1;
}
return 0;
}
static grub_err_t
grub_tpm1_execute(grub_efi_handle_t tpm_handle,
PassThroughToTPM_InputParamBlock *inbuf,
PassThroughToTPM_OutputParamBlock *outbuf)
{
grub_efi_status_t status;
grub_efi_tpm_protocol_t *tpm;
grub_uint32_t inhdrsize = sizeof(*inbuf) - sizeof(inbuf->TPMOperandIn);
grub_uint32_t outhdrsize = sizeof(*outbuf) - sizeof(outbuf->TPMOperandOut);
tpm = grub_efi_open_protocol (tpm_handle, &tpm_guid,
GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL);
if (!grub_tpm_present(tpm))
return 0;
/* UEFI TPM protocol takes the raw operand block, no param block header */
status = efi_call_5 (tpm->pass_through_to_tpm, tpm,
inbuf->IPBLength - inhdrsize, inbuf->TPMOperandIn,
outbuf->OPBLength - outhdrsize, outbuf->TPMOperandOut);
switch (status) {
case GRUB_EFI_SUCCESS:
return 0;
case GRUB_EFI_DEVICE_ERROR:
return grub_error (GRUB_ERR_IO, N_("Command failed"));
case GRUB_EFI_INVALID_PARAMETER:
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("Invalid parameter"));
case GRUB_EFI_BUFFER_TOO_SMALL:
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("Output buffer too small"));
case GRUB_EFI_NOT_FOUND:
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("TPM unavailable"));
default:
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("Unknown TPM error"));
}
}
static grub_err_t
grub_tpm2_execute(grub_efi_handle_t tpm_handle,
PassThroughToTPM_InputParamBlock *inbuf,
PassThroughToTPM_OutputParamBlock *outbuf)
{
grub_efi_status_t status;
grub_efi_tpm2_protocol_t *tpm;
grub_uint32_t inhdrsize = sizeof(*inbuf) - sizeof(inbuf->TPMOperandIn);
grub_uint32_t outhdrsize = sizeof(*outbuf) - sizeof(outbuf->TPMOperandOut);
tpm = grub_efi_open_protocol (tpm_handle, &tpm2_guid,
GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL);
if (!grub_tpm2_present(tpm))
return 0;
/* UEFI TPM protocol takes the raw operand block, no param block header */
status = efi_call_5 (tpm->submit_command, tpm,
inbuf->IPBLength - inhdrsize, inbuf->TPMOperandIn,
outbuf->OPBLength - outhdrsize, outbuf->TPMOperandOut);
switch (status) {
case GRUB_EFI_SUCCESS:
return 0;
case GRUB_EFI_DEVICE_ERROR:
return grub_error (GRUB_ERR_IO, N_("Command failed"));
case GRUB_EFI_INVALID_PARAMETER:
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("Invalid parameter"));
case GRUB_EFI_BUFFER_TOO_SMALL:
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("Output buffer too small"));
case GRUB_EFI_NOT_FOUND:
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("TPM unavailable"));
default:
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("Unknown TPM error"));
}
}
grub_err_t
grub_tpm_execute(PassThroughToTPM_InputParamBlock *inbuf,
PassThroughToTPM_OutputParamBlock *outbuf)
{
grub_efi_handle_t tpm_handle;
grub_uint8_t protocol_version;
/* It's not a hard failure for there to be no TPM */
if (!grub_tpm_handle_find(&tpm_handle, &protocol_version))
return 0;
if (protocol_version == 1) {
return grub_tpm1_execute(tpm_handle, inbuf, outbuf);
} else {
return grub_tpm2_execute(tpm_handle, inbuf, outbuf);
}
}
static grub_err_t
grub_tpm1_log_event(grub_efi_handle_t tpm_handle, unsigned char *buf,
grub_size_t size, grub_uint8_t pcr,
const char *description)
{
TCG_PCR_EVENT *event;
grub_efi_status_t status;
grub_efi_tpm_protocol_t *tpm;
grub_efi_physical_address_t lastevent;
grub_uint32_t algorithm;
grub_uint32_t eventnum = 0;
tpm = grub_efi_open_protocol (tpm_handle, &tpm_guid,
GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL);
if (!grub_tpm_present(tpm))
return 0;
event = grub_zalloc(sizeof (TCG_PCR_EVENT) + grub_strlen(description) + 1);
if (!event)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
N_("cannot allocate TPM event buffer"));
event->PCRIndex = pcr;
event->EventType = EV_IPL;
event->EventSize = grub_strlen(description) + 1;
grub_memcpy(event->Event, description, event->EventSize);
algorithm = TCG_ALG_SHA;
status = efi_call_7 (tpm->log_extend_event, tpm, (grub_efi_physical_address_t)buf, (grub_uint64_t) size,
algorithm, event, &eventnum, &lastevent);
switch (status) {
case GRUB_EFI_SUCCESS:
return 0;
case GRUB_EFI_DEVICE_ERROR:
return grub_error (GRUB_ERR_IO, N_("Command failed"));
case GRUB_EFI_INVALID_PARAMETER:
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("Invalid parameter"));
case GRUB_EFI_BUFFER_TOO_SMALL:
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("Output buffer too small"));
case GRUB_EFI_NOT_FOUND:
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("TPM unavailable"));
default:
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("Unknown TPM error"));
}
}
static grub_err_t
grub_tpm2_log_event(grub_efi_handle_t tpm_handle, unsigned char *buf,
grub_size_t size, grub_uint8_t pcr,
const char *description)
{
EFI_TCG2_EVENT *event;
grub_efi_status_t status;
grub_efi_tpm2_protocol_t *tpm;
tpm = grub_efi_open_protocol (tpm_handle, &tpm2_guid,
GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL);
if (!grub_tpm2_present(tpm))
return 0;
event = grub_zalloc(sizeof (EFI_TCG2_EVENT) + grub_strlen(description) + 1);
if (!event)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
N_("cannot allocate TPM event buffer"));
event->Header.HeaderSize = sizeof(EFI_TCG2_EVENT_HEADER);
event->Header.HeaderVersion = 1;
event->Header.PCRIndex = pcr;
event->Header.EventType = EV_IPL;
event->Size = sizeof(*event) - sizeof(event->Event) + grub_strlen(description) + 1;
grub_memcpy(event->Event, description, grub_strlen(description) + 1);
status = efi_call_5 (tpm->hash_log_extend_event, tpm, 0, (grub_efi_physical_address_t)buf,
(grub_uint64_t) size, event);
switch (status) {
case GRUB_EFI_SUCCESS:
return 0;
case GRUB_EFI_DEVICE_ERROR:
return grub_error (GRUB_ERR_IO, N_("Command failed"));
case GRUB_EFI_INVALID_PARAMETER:
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("Invalid parameter"));
case GRUB_EFI_BUFFER_TOO_SMALL:
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("Output buffer too small"));
case GRUB_EFI_NOT_FOUND:
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("TPM unavailable"));
default:
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("Unknown TPM error"));
}
}
grub_err_t
grub_tpm_log_event(unsigned char *buf, grub_size_t size, grub_uint8_t pcr,
const char *description)
{
grub_efi_handle_t tpm_handle;
grub_efi_uint8_t protocol_version;
if (!grub_tpm_handle_find(&tpm_handle, &protocol_version))
return 0;
if (protocol_version == 1) {
return grub_tpm1_log_event(tpm_handle, buf, size, pcr, description);
} else {
return grub_tpm2_log_event(tpm_handle, buf, size, pcr, description);
}
}

Some files were not shown because too many files have changed in this diff Show more