Z572/grub
1
0
Fork 0
mirror of http://cgit.git.savannah.gnu.org/git/grub.git synced 2026-04-28 14:33:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: Z572:phcoder/arrows
Branches Tags
Z572:master Z572:multiboot2 Z572:phcoder/verifiers Z572:arm_coreboot Z572:phcoder/termux Z572:next Z572:phcoder/rotate Z572:phcoder/xenfixes Z572:phcoder/gnuroot Z572:andrey/ext4_inline_data Z572:phcoder/arm Z572:phcoder/c3 Z572:master-bad-anon-commit Z572:pfsmorigo/no-libgcc Z572:pfsmorigo/vlantag Z572:phcoder/scratch Z572:phcoder/greffs Z572:phcoder/arrows Z572:leiflindholm/arm64 Z572:phcoder/file_types Z572:phcoder/efi_compression Z572:phcoder/ports/alpha Z572:phcoder/brltty Z572:phcoder/filesize Z572:phcoder/newports/s390 Z572:peter/devmapper Z572:multiboot Z572:grub-legacy
Z572:grub-2.14 Z572:grub-2.14-rc1 Z572:grub-2.12 Z572:grub-2.12-rc1 Z572:grub-2.06 Z572:grub-2.06-rc1a Z572:grub-2.06-rc1 Z572:grub-2.04 Z572:grub-2.04-rc1 Z572:grub-2.02 Z572:2.02 Z572:grub-2.02-rc2 Z572:2.02-rc2 Z572:grub-2.02-rc1 Z572:2.02-rc1 Z572:grub-2.02-beta3 Z572:2.02-beta3 Z572:grub-2.02-beta2 Z572:grub-2.02-beta1 Z572:2.00 Z572:1.99 Z572:1.98 Z572:0.6.96
..
compare: Z572:phcoder/filesize
Branches Tags
Z572:master Z572:multiboot2 Z572:phcoder/verifiers Z572:arm_coreboot Z572:phcoder/termux Z572:next Z572:phcoder/rotate Z572:phcoder/xenfixes Z572:phcoder/gnuroot Z572:andrey/ext4_inline_data Z572:phcoder/arm Z572:phcoder/c3 Z572:master-bad-anon-commit Z572:pfsmorigo/no-libgcc Z572:pfsmorigo/vlantag Z572:phcoder/scratch Z572:phcoder/greffs Z572:phcoder/arrows Z572:leiflindholm/arm64 Z572:phcoder/file_types Z572:phcoder/efi_compression Z572:phcoder/ports/alpha Z572:phcoder/brltty Z572:phcoder/filesize Z572:phcoder/newports/s390 Z572:peter/devmapper Z572:multiboot Z572:grub-legacy
Z572:grub-2.14 Z572:grub-2.14-rc1 Z572:grub-2.12 Z572:grub-2.12-rc1 Z572:grub-2.06 Z572:grub-2.06-rc1a Z572:grub-2.06-rc1 Z572:grub-2.04 Z572:grub-2.04-rc1 Z572:grub-2.02 Z572:2.02 Z572:grub-2.02-rc2 Z572:2.02-rc2 Z572:grub-2.02-rc1 Z572:2.02-rc1 Z572:grub-2.02-beta3 Z572:2.02-beta3 Z572:grub-2.02-beta2 Z572:grub-2.02-beta1 Z572:2.00 Z572:1.99 Z572:1.98 Z572:0.6.96

1 Commits
phcoder/ar ... phcoder/fi

Author SHA1 Message Date
Vladimir Serbinenko
8e2fb1e3ce More efficient retrieval of file size 2013-10-27 17:24:35 +01:00
510 changed files with 9788 additions and 35766 deletions
Expand all files Collapse all files

17
.gitignore vendored
View File

@@ -12,9 +12,7 @@ ascii.bitmaps
ascii.h
autom4te.cache
build_env.mk
build-grub-gen-asciih
build-grub-gen-widthspec
build-grub-mkfont
.bzrignore
cdboot_test
cmp_test
config.cache
@@ -51,7 +49,6 @@ grub_cmd_set_date
grub_cmd_sleep
grub-editenv
grub-emu
grub-emu-lite
grub_emu_init.c
grub_emu_init.h
grub-fstest
@@ -62,7 +59,7 @@ grub-install
grub-kbdcomp
grub-macho2img
grub-menulst2cfg
/grub-mk*
grub-mk*
grub-mount
grub-ofpathname
grub-pe2elf
@@ -130,7 +127,6 @@ mod-*.c
missing
netboot_test
*.o
*.a
ohci_test
partmap_test
pata_test
@@ -159,15 +155,16 @@ GPATH
GRTAGS
GSYMS
GTAGS
Makefile.tpl
compile
depcomp
mdate-sh
texinfo.tex
grub-core/lib/libgcrypt-grub
.deps
.deps-util
.deps-core
.dirstamp
**/.deps
**/.deps-util
**/.deps-core
**/.dirstamp
Makefile.util.am
contrib
grub-core/bootinfo.txt

2172
ChangeLog
View File

File diff suppressed because it is too large Load Diff

20
INSTALL
View File

@@ -12,23 +12,6 @@ you don't have any of them, please obtain and install them before
configuring the GRUB.
* GCC 4.1.3 or later
Note: older versions may work but support is limited
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 3.3 or later works for arm64
earlier versions have no arm64 support
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 has no support for generating 64-bit sparc code and hence you
can't compile GRUB for sparc64 with clang
Note: clang has no support for ia64 and hence you can't compile GRUB
for ia64 with clang
* GNU Make
* GNU Bison 2.3 or later
* GNU gettext 0.17 or later
@@ -54,9 +37,10 @@ To build GRUB's graphical terminal (gfxterm), you need:
If you use a development snapshot or want to hack on GRUB you may
need the following.
* Python 2.6 or later
* Python 2.5.2 or later
* Autoconf 2.60 or later
* Automake 1.10.1 or later
* Autogen 5.10 or later
Prerequisites for make-check:

49
Makefile.am
View File

@@ -68,20 +68,12 @@ starfield_theme_files = $(srcdir)/themes/starfield/blob_w.png $(srcdir)/themes/s
build-grub-mkfont: util/grub-mkfont.c grub-core/unidata.c grub-core/kern/emu/misc.c util/misc.c
$(BUILD_CC) -o $@ -I$(top_srcdir)/include $(BUILD_CFLAGS) $(BUILD_CPPFLAGS) -DGRUB_MKFONT=1 -DGRUB_BUILD=1 -DGRUB_UTIL=1 -DGRUB_BUILD_PROGRAM_NAME=\"build-grub-mkfont\" $^ $(build_freetype_cflags) $(build_freetype_libs)
CLEANFILES += build-grub-mkfont
garbage-gen: util/garbage-gen.c
$(BUILD_CC) -o $@ $(BUILD_CFLAGS) $(BUILD_CPPFLAGS) $^
CLEANFILES += garbage-gen
EXTRA_DIST += util/garbage-gen.c
build-grub-gen-asciih: util/grub-gen-asciih.c
$(BUILD_CC) -o $@ -I$(top_srcdir)/include $(BUILD_CFLAGS) $(BUILD_CPPFLAGS) -DGRUB_MKFONT=1 -DGRUB_BUILD=1 -DGRUB_UTIL=1 $^ $(build_freetype_cflags) $(build_freetype_libs) -Wall -Werror
CLEANFILES += build-grub-gen-asciih
build-grub-gen-widthspec: util/grub-gen-widthspec.c
$(BUILD_CC) -o $@ -I$(top_srcdir)/include $(BUILD_CFLAGS) $(BUILD_CPPFLAGS) -DGRUB_MKFONT=1 -DGRUB_BUILD=1 -DGRUB_UTIL=1 $^ $(build_freetype_cflags) $(build_freetype_libs) -Wall -Werror
CLEANFILES += build-grub-gen-widthspec
if COND_STARFIELD
starfield_DATA = dejavu_10.pf2 dejavu_12.pf2 dejavu_bold_14.pf2 dejavu_14.pf2 dejavu_16.pf2 $(starfield_theme_files)
@@ -96,14 +88,14 @@ dejavu_bold_14.pf2: $(DJVU_FONT_SOURCE) build-grub-mkfont
dejavu_16.pf2: $(DJVU_FONT_SOURCE) build-grub-mkfont
./build-grub-mkfont -s 16 -o $@ $(DJVU_FONT_SOURCE)
else
starfield_DATA =
starfield_DATA =
endif
EXTRA_DIST += $(starfield_theme_files)
EXTRA_DIST += $(srcdir)/themes/starfield/src/slider_s.xcf $(srcdir)/themes/starfield/src/slider_n.xcf $(srcdir)/themes/starfield/src/slider_c.xcf $(srcdir)/themes/starfield/src/blob_nw.xcf $(srcdir)/themes/starfield/src/bootmenu/center.xcf $(srcdir)/themes/starfield/src/bootmenu/corner.xcf $(srcdir)/themes/starfield/src/bootmenu/side.xcf $(srcdir)/themes/starfield/src/terminalbox/side.xcf $(srcdir)/themes/starfield/src/terminalbox/corner.xcf $(srcdir)/themes/starfield/src/terminalbox/center.xcf
unicode.pf2: $(FONT_SOURCE) build-grub-mkfont
./build-grub-mkfont -o $@ $(FONT_SOURCE) || (rm -f $@; exit 1)
./build-grub-mkfont -o $@ $(FONT_SOURCE)
CLEANFILES += unicode.pf2
# Arrows and lines are needed to draw the menu, so always include them
@@ -111,19 +103,19 @@ UNICODE_ARROWS=0x2190-0x2193
UNICODE_LINES=0x2501-0x251B
ascii.pf2: $(FONT_SOURCE) build-grub-mkfont
./build-grub-mkfont -o $@ $(FONT_SOURCE) -r 0x0-0x7f,$(UNICODE_ARROWS),$(UNICODE_LINES) || (rm -f $@; exit 1)
./build-grub-mkfont -o $@ $(FONT_SOURCE) -r 0x0-0x7f,$(UNICODE_ARROWS),$(UNICODE_LINES)
CLEANFILES += ascii.pf2
euro.pf2: $(FONT_SOURCE) build-grub-mkfont
./build-grub-mkfont -o $@ $(FONT_SOURCE) -r 0x0-0x4ff,0x1e00-0x1fff,$(UNICODE_ARROWS),$(UNICODE_LINES) || (rm -f $@; exit 1)
./build-grub-mkfont -o $@ $(FONT_SOURCE) -r 0x0-0x4ff,0x1e00-0x1fff,$(UNICODE_ARROWS),$(UNICODE_LINES)
CLEANFILES += euro.pf2
ascii.h: $(FONT_SOURCE) build-grub-gen-asciih
./build-grub-gen-asciih $(FONT_SOURCE) $@ || (rm -f $@; exit 1)
./build-grub-gen-asciih $(FONT_SOURCE) $@
CLEANFILES += ascii.h
widthspec.h: $(FONT_SOURCE) build-grub-gen-widthspec
./build-grub-gen-widthspec $(FONT_SOURCE) $@ || (rm -f $@; exit 1)
./build-grub-gen-widthspec $(FONT_SOURCE) $@
CLEANFILES += widthspec.h
# Install config.h into platformdir
@@ -397,33 +389,4 @@ BOOTCHECK_TIMEOUT=180
bootcheck: $(BOOTCHECKS)
if COND_i386_coreboot
default_payload.elf: grub-mkstandalone grub-mkimage
pkgdatadir=. ./grub-mkstandalone --grub-mkimage=./grub-mkimage -O i386-coreboot -o $@ --modules='ahci pata ehci uhci ohci usb_keyboard usbms part_msdos xfs ext2 fat at_keyboard part_gpt usbserial_usbdebug cbfs' --install-modules='ls linux search configfile normal cbtime cbls memrw iorw minicmd lsmmap lspci halt reboot hexdump pcidump regexp setpci lsacpi chain test' --fonts= --themes= --locales= -d grub-core/ /boot/grub/grub.cfg=$(srcdir)/coreboot.cfg
endif
windowsdir=$(top_builddir)/$(PACKAGE)-$(VERSION)-for-windows
windowsdir: $(PROGRAMS) $(starfield_DATA) $(platform_DATA)
test -d $(windowsdir) && rm -rf $(windowsdir) || true
test -d $(windowsdir) || mkdir $(windowsdir)
$(MAKE) -C po $(AM_MAKEFLAGS) windowsdir
$(MAKE) -C grub-core $(AM_MAKEFLAGS) windowsdir
test -d $(windowsdir)/themes || mkdir $(windowsdir)/themes
test -d $(windowsdir)/themes/starfield || mkdir $(windowsdir)/themes/starfield
for x in $(PROGRAMS); do \
if [ x$(STRIP) != x ]; then $(STRIP) $$x -o $(windowsdir)/$$x; \
else cp -fp $$x $(windowsdir)/$$x; fi; \
done
for x in $(pkgdata_DATA); do \
cp -fp $$x $(windowsdir)/$$x; \
done
for x in $(starfield_DATA); do \
cp -fp $$x $(windowsdir)/themes/starfield/$$(basename $$x); \
done
windowszip=$(top_builddir)/$(PACKAGE)-$(VERSION)-for-windows.zip
windowszip: windowsdir
test -f $(windowszip) && rm $(windowszip) || true
zip -r $(windowszip) $(windowsdir)
EXTRA_DIST += linguas.sh

279
Makefile.util.def
View File

@@ -15,7 +15,6 @@ library = {
common = grub-core/osdep/getroot.c;
common = grub-core/osdep/devmapper/getroot.c;
common = grub-core/osdep/relpath.c;
extra_dist = grub-core/kern/disk_common.c;
extra_dist = grub-core/osdep/unix/relpath.c;
extra_dist = grub-core/osdep/aros/relpath.c;
extra_dist = grub-core/osdep/windows/relpath.c;
@@ -156,8 +155,6 @@ library = {
common = grub-core/io/gzio.c;
common = grub-core/io/lzopio.c;
common = grub-core/kern/ia64/dl_helper.c;
common = grub-core/kern/arm/dl_helper.c;
common = grub-core/kern/arm64/dl_helper.c;
common = grub-core/lib/minilzo/minilzo.c;
common = grub-core/lib/xzembed/xz_dec_bcj.c;
common = grub-core/lib/xzembed/xz_dec_lzma2.c;
@@ -173,11 +170,8 @@ program = {
common = util/resolve.c;
common = grub-core/kern/emu/argp_common.c;
common = grub-core/osdep/init.c;
common = grub-core/osdep/config.c;
extra_dist = grub-core/osdep/aros/config.c;
extra_dist = grub-core/osdep/windows/config.c;
extra_dist = grub-core/osdep/unix/config.c;
common = util/config.c;
common = grub-core/kern/arm/dl_helper.c;
extra_dist = util/grub-mkimagexx.c;
@@ -255,7 +249,7 @@ program = {
name = grub-macho2img;
mansection = 1;
common = util/grub-macho2img.c;
condition = COND_APPLE_LINKER;
condition = COND_APPLE_CC;
};
program = {
@@ -315,7 +309,6 @@ program = {
installdir = sbin;
mansection = 8;
common = util/grub-probe.c;
common = util/probe.c;
common = grub-core/osdep/ofpath.c;
common = grub-core/kern/emu/argp_common.c;
common = grub-core/osdep/init.c;
@@ -485,157 +478,38 @@ script = {
installdir = grubconf;
};
program = {
script = {
mansection = 1;
name = grub-mkrescue;
common = util/grub-mkrescue.c;
common = util/render-label.c;
common = util/glue-efi.c;
common = util/mkimage.c;
common = util/grub-install-common.c;
common = util/setup_bios.c;
common = util/setup_sparc.c;
common = grub-core/lib/reed_solomon.c;
common = grub-core/osdep/random.c;
common = grub-core/osdep/ofpath.c;
common = grub-core/osdep/platform.c;
common = grub-core/osdep/platform_unix.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/editenv.c;
common = grub-core/osdep/blocklist.c;
common = grub-core/osdep/config.c;
common = util/config.c;
common = grub-core/kern/emu/hostfs.c;
common = grub-core/disk/host.c;
common = util/resolve.c;
common = grub-core/kern/emu/argp_common.c;
common = grub-core/osdep/init.c;
ldadd = '$(LIBLZMA)';
ldadd = libgrubmods.a;
ldadd = libgrubgcry.a;
ldadd = libgrubkern.a;
ldadd = grub-core/gnulib/libgnu.a;
ldadd = '$(LIBINTL) $(LIBDEVMAPPER) $(LIBUTIL) $(LIBZFS) $(LIBNVPAIR) $(LIBGEOM)';
condition = COND_HAVE_EXEC;
common = util/grub-install_header;
common = util/grub-mkrescue.in;
enable = noemu;
};
program = {
script = {
mansection = 1;
name = grub-mkstandalone;
common = util/grub-mkstandalone.c;
common = util/render-label.c;
common = util/glue-efi.c;
common = util/mkimage.c;
common = util/grub-install-common.c;
common = util/setup_bios.c;
common = util/setup_sparc.c;
common = grub-core/lib/reed_solomon.c;
common = grub-core/osdep/random.c;
common = grub-core/osdep/ofpath.c;
common = grub-core/osdep/platform.c;
common = grub-core/osdep/platform_unix.c;
extra_dist = grub-core/osdep/linux/platform.c;
extra_dist = grub-core/osdep/basic/platform.c;
extra_dist = grub-core/osdep/basic/no_platform.c;
extra_dist = grub-core/osdep/unix/platform.c;
common = grub-core/osdep/compress.c;
common = util/editenv.c;
common = grub-core/osdep/blocklist.c;
common = grub-core/osdep/config.c;
common = util/config.c;
common = grub-core/kern/emu/hostfs.c;
common = grub-core/disk/host.c;
common = util/resolve.c;
common = grub-core/kern/emu/argp_common.c;
common = grub-core/osdep/init.c;
ldadd = '$(LIBLZMA)';
ldadd = libgrubmods.a;
ldadd = libgrubgcry.a;
ldadd = libgrubkern.a;
ldadd = grub-core/gnulib/libgnu.a;
ldadd = '$(LIBINTL) $(LIBDEVMAPPER) $(LIBUTIL) $(LIBZFS) $(LIBNVPAIR) $(LIBGEOM)';
common = util/grub-install_header;
common = util/grub-mkstandalone.in;
};
program = {
script = {
mansection = 8;
installdir = sbin;
name = grub-install;
common = util/grub-install.c;
common = util/probe.c;
common = util/mkimage.c;
common = util/grub-install-common.c;
common = util/setup_bios.c;
common = util/setup_sparc.c;
common = grub-core/lib/reed_solomon.c;
common = grub-core/osdep/random.c;
common = grub-core/osdep/ofpath.c;
common = grub-core/osdep/platform.c;
common = grub-core/osdep/platform_unix.c;
common = grub-core/osdep/compress.c;
common = util/editenv.c;
common = grub-core/osdep/blocklist.c;
common = grub-core/osdep/config.c;
common = util/config.c;
common = util/resolve.c;
common = util/grub-install_header;
common = util/grub-install.in;
enable = noemu;
common = grub-core/kern/emu/argp_common.c;
common = grub-core/osdep/init.c;
ldadd = '$(LIBLZMA)';
ldadd = libgrubmods.a;
ldadd = libgrubgcry.a;
ldadd = libgrubkern.a;
ldadd = grub-core/gnulib/libgnu.a;
ldadd = '$(LIBINTL) $(LIBDEVMAPPER) $(LIBUTIL) $(LIBZFS) $(LIBNVPAIR) $(LIBGEOM)';
};
program = {
script = {
mansection = 1;
installdir = bin;
name = grub-mknetdir;
common = util/grub-mknetdir.c;
common = util/mkimage.c;
common = util/grub-install-common.c;
common = util/setup_bios.c;
common = util/setup_sparc.c;
common = grub-core/lib/reed_solomon.c;
common = grub-core/osdep/random.c;
common = grub-core/osdep/ofpath.c;
common = grub-core/osdep/platform.c;
common = grub-core/osdep/platform_unix.c;
common = grub-core/osdep/compress.c;
common = util/editenv.c;
common = grub-core/osdep/blocklist.c;
common = grub-core/osdep/config.c;
common = util/config.c;
common = util/resolve.c;
common = grub-core/kern/emu/argp_common.c;
common = grub-core/osdep/init.c;
ldadd = '$(LIBLZMA)';
ldadd = libgrubmods.a;
ldadd = libgrubgcry.a;
ldadd = libgrubkern.a;
ldadd = grub-core/gnulib/libgnu.a;
ldadd = '$(LIBINTL) $(LIBDEVMAPPER) $(LIBUTIL) $(LIBZFS) $(LIBNVPAIR) $(LIBGEOM)';
common = util/grub-install_header;
common = util/grub-mknetdir.in;
};
script = {
@@ -683,127 +557,6 @@ script = {
installdir = noinst;
};
script = {
name = grub-fs-tester;
common = tests/util/grub-fs-tester.in;
installdir = noinst;
dependencies = garbage-gen;
};
script = {
testcase;
name = ext234_test;
common = tests/ext234_test.in;
};
script = {
testcase;
name = squashfs_test;
common = tests/squashfs_test.in;
};
script = {
testcase;
name = iso9660_test;
common = tests/iso9660_test.in;
};
script = {
testcase;
name = hfsplus_test;
common = tests/hfsplus_test.in;
};
script = {
testcase;
name = ntfs_test;
common = tests/ntfs_test.in;
};
script = {
testcase;
name = reiserfs_test;
common = tests/reiserfs_test.in;
};
script = {
testcase;
name = fat_test;
common = tests/fat_test.in;
};
script = {
testcase;
name = minixfs_test;
common = tests/minixfs_test.in;
};
script = {
testcase;
name = xfs_test;
common = tests/xfs_test.in;
};
script = {
testcase;
name = nilfs2_test;
common = tests/nilfs2_test.in;
};
script = {
testcase;
name = romfs_test;
common = tests/romfs_test.in;
};
script = {
testcase;
name = exfat_test;
common = tests/exfat_test.in;
};
script = {
testcase;
name = tar_test;
common = tests/tar_test.in;
};
script = {
testcase;
name = udf_test;
common = tests/udf_test.in;
};
script = {
testcase;
name = hfs_test;
common = tests/hfs_test.in;
};
script = {
testcase;
name = jfs_test;
common = tests/jfs_test.in;
};
script = {
testcase;
name = btrfs_test;
common = tests/btrfs_test.in;
};
script = {
testcase;
name = zfs_test;
common = tests/zfs_test.in;
};
script = {
testcase;
name = cpio_test;
common = tests/cpio_test.in;
};
script = {
testcase;
name = example_scripted_test;

86
acinclude.m4
View File

@@ -134,29 +134,6 @@ if test "x$grub_cv_prog_ld_build_id_none" = xyes; then
fi
])
dnl Check nm
AC_DEFUN([grub_PROG_NM_WORKS],
[AC_MSG_CHECKING([whether nm works])
AC_CACHE_VAL(grub_cv_prog_nm_works,
[
nm_works_tmp_dir="$(mktemp -d "./confXXXXXX")"
AC_LANG_CONFTEST([AC_LANG_PROGRAM([[]], [[]])])
$TARGET_CC $TARGET_CFLAGS -c conftest.c -o "$nm_works_tmp_dir/ef"
if $TARGET_NM "$nm_works_tmp_dir/ef" > /dev/null; then
grub_cv_prog_nm_works=yes
else
grub_cv_prog_nm_minus_p=no
fi
rm "$nm_works_tmp_dir/ef"
rmdir "$nm_works_tmp_dir"
])
AC_MSG_RESULT([$grub_cv_prog_nm_works])
if test "x$grub_cv_prog_nm_works" != xyes; then
AC_MSG_ERROR([nm does not work])
fi
])
dnl Supply -P to nm
AC_DEFUN([grub_PROG_NM_MINUS_P],
[AC_MSG_CHECKING([whether nm accepts -P])
@@ -164,14 +141,13 @@ AC_CACHE_VAL(grub_cv_prog_nm_minus_p,
[
nm_minus_p_tmp_dir="$(mktemp -d "./confXXXXXX")"
AC_LANG_CONFTEST([AC_LANG_PROGRAM([[]], [[]])])
$TARGET_CC $TARGET_CFLAGS -c conftest.c -o "$nm_minus_p_tmp_dir/ef"
$TARGET_CC conftest.c -o "$nm_minus_p_tmp_dir/ef"
if $TARGET_NM -P "$nm_minus_p_tmp_dir/ef" 2>&1 > /dev/null; then
grub_cv_prog_nm_minus_p=yes
else
grub_cv_prog_nm_minus_p=no
fi
rm "$nm_minus_p_tmp_dir/ef"
rmdir "$nm_minus_p_tmp_dir"
])
AC_MSG_RESULT([$grub_cv_prog_nm_minus_p])
@@ -189,14 +165,13 @@ AC_CACHE_VAL(grub_cv_prog_nm_defined_only,
[
nm_defined_only_tmp_dir="$(mktemp -d "./confXXXXXX")"
AC_LANG_CONFTEST([AC_LANG_PROGRAM([[]], [[]])])
$TARGET_CC $TARGET_CFLAGS -c conftest.c -o "$nm_defined_only_tmp_dir/ef"
$TARGET_CC conftest.c -o "$nm_defined_only_tmp_dir/ef"
if $TARGET_NM --defined-only "$nm_defined_only_tmp_dir/ef" 2>&1 > /dev/null; then
grub_cv_prog_nm_defined_only=yes
else
grub_cv_prog_nm_defined_only=no
fi
rm "$nm_defined_only_tmp_dir/ef"
rmdir "$nm_defined_only_tmp_dir"
])
AC_MSG_RESULT([$grub_cv_prog_nm_defined_only])
@@ -237,7 +212,7 @@ else
sed -e s/@ADDR32@/addr32\;/ < conftest.s.in > conftest.s
fi
if AC_TRY_COMMAND([${CC-cc} ${TARGET_CCASFLAGS} ${CFLAGS} -c conftest.s]) && test -s conftest.o; then
if AC_TRY_COMMAND([${CC-cc} ${CFLAGS} -c conftest.s]) && test -s conftest.o; then
grub_cv_i386_asm_addr32=yes
else
grub_cv_i386_asm_addr32=no
@@ -247,6 +222,37 @@ rm -f conftest*])
AC_MSG_RESULT([$grub_cv_i386_asm_addr32])])
dnl check if our compiler is apple cc
dnl because it requires numerous workarounds
AC_DEFUN([grub_apple_cc],
[AC_REQUIRE([AC_PROG_CC])
AC_MSG_CHECKING([whether our compiler is apple cc])
AC_CACHE_VAL(grub_cv_apple_cc,
[if $CC -v 2>&1 | grep "Apple Inc." > /dev/null; then
grub_cv_apple_cc=yes
else
grub_cv_apple_cc=no
fi
])
AC_MSG_RESULT([$grub_cv_apple_cc])])
dnl check if our target compiler is apple cc
dnl because it requires numerous workarounds
AC_DEFUN([grub_apple_target_cc],
[AC_REQUIRE([AC_PROG_CC])
AC_MSG_CHECKING([whether our target compiler is apple cc])
AC_CACHE_VAL(grub_cv_apple_target_cc,
[if $CC -v 2>&1 | grep "Apple Inc." > /dev/null; then
grub_cv_apple_target_cc=yes
else
grub_cv_apple_target_cc=no
fi
])
AC_MSG_RESULT([$grub_cv_apple_target_cc])])
dnl Later versions of GAS requires that addr32 and data32 prefixes
dnl appear in the same lines as the instructions they modify, while
dnl earlier versions requires that they appear in separate lines.
@@ -260,7 +266,7 @@ AC_CACHE_VAL(grub_cv_i386_asm_prefix_requirement,
l1: addr32 movb %al, l1
EOF
if AC_TRY_COMMAND([${CC-cc} ${TARGET_CCASFLAGS} ${CFLAGS} -c conftest.s]) && test -s conftest.o; then
if AC_TRY_COMMAND([${CC-cc} ${CFLAGS} -c conftest.s]) && test -s conftest.o; then
grub_cv_i386_asm_prefix_requirement=yes
else
grub_cv_i386_asm_prefix_requirement=no
@@ -385,7 +391,7 @@ AC_MSG_CHECKING([whether `$CC' accepts `-mstack-arg-probe'])
AC_LANG_CONFTEST([AC_LANG_SOURCE([[
void foo (void) { volatile char a[8]; a[3]; }
]])])
[if eval "$ac_compile -S -mstack-arg-probe -Werror -o conftest.s" 2> /dev/null; then]
[if eval "$ac_compile -S -mstack-arg-probe -o conftest.s" 2> /dev/null; then]
AC_MSG_RESULT([yes])
[# Should we clear up other files as well, having called `AC_LANG_CONFTEST'?
rm -f conftest.s
@@ -474,3 +480,23 @@ dnl program.
AC_DEFUN([grub_TRANSFORM],[dnl
AC_SUBST(AS_TR_SH([$1]), [`AS_ECHO([$1]) | sed "$program_transform_name"`])dnl
])
dnl Check if the C compiler supports `-mno-unaligned-access'.
AC_DEFUN([grub_CHECK_NO_UNALIGNED_ACCESS],[
[# foobar
nua_possible=yes]
AC_MSG_CHECKING([whether `$CC' supports `-mno-unaligned-access'])
AC_LANG_CONFTEST([AC_LANG_SOURCE([[
int main() {
return 0;
}
]])])
[if eval "$ac_compile -S -mno-unaligned-access -o conftest.s" 2> /dev/null; then]
AC_MSG_RESULT([yes])
[rm -f conftest.s
else
nua_possible=no]
AC_MSG_RESULT([no])
[fi]
])

11
autogen.sh
View File

@@ -8,6 +8,8 @@ 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' |sort > po/POTFILES.in
find util -iname '*.in' ! -name Makefile.in |sort > po/POTFILES-shell.in
autogen --version >/dev/null || exit 1
echo "Importing unicode..."
python util/import_unicode.py unicode/UnicodeData.txt unicode/BidiMirroring.txt unicode/ArabicShaping.txt grub-core/unidata.c
@@ -30,7 +32,10 @@ for x in mpi-asm-defs.h mpih-add1.c mpih-sub1.c mpih-mul1.c mpih-mul2.c mpih-mul
ln -s generic/"$x" grub-core/lib/libgcrypt-grub/mpi/"$x"
done
echo "Generating Automake input..."
echo "Creating Makefile.tpl..."
python gentpl.py | sed -e '/^$/{N;/^\n$/D;}' > Makefile.tpl
echo "Running autogen..."
# Automake doesn't like including files from a path outside the project.
rm -f contrib grub-core/contrib
@@ -54,8 +59,8 @@ for extra in contrib/*/Makefile.core.def; do
fi
done
python gentpl.py $UTIL_DEFS > Makefile.util.am
python gentpl.py $CORE_DEFS > grub-core/Makefile.core.am
cat $UTIL_DEFS | autogen -T Makefile.tpl | sed -e '/^$/{N;/^\n$/D;}' > Makefile.util.am
cat $CORE_DEFS | autogen -T Makefile.tpl | sed -e '/^$/{N;/^\n$/D;}' > grub-core/Makefile.core.am
for extra in contrib/*/Makefile.common; do
if test -e "$extra"; then

73
conf/Makefile.common
View File

@@ -6,24 +6,42 @@ export LC_COLLATE := C
unexport LC_ALL
# Platform specific options
if COND_i386_pc
CFLAGS_PLATFORM += -mrtd -mregparm=3 -freg-struct-return
endif
if COND_i386_qemu
CFLAGS_PLATFORM += -mrtd -mregparm=3 -freg-struct-return
endif
if COND_i386_coreboot
CFLAGS_PLATFORM += -mrtd -mregparm=3 -freg-struct-return
endif
if COND_i386_ieee1275
CFLAGS_PLATFORM += -mrtd -mregparm=3 -freg-struct-return
endif
if COND_mips_loongson
CFLAGS_PLATFORM += -mexplicit-relocs
CPPFLAGS_PLATFORM = -DUSE_ASCII_FALLBACK
endif
if COND_mips
CFLAGS_PLATFORM += -mflush-func=grub_red_herring
CCASFLAGS_PLATFORM = -march=mips3
endif
if COND_sparc64_ieee1275
CFLAGS_PLATFORM += -mno-app-regs
LDFLAGS_PLATFORM = -Wl,-melf64_sparc -mno-relax
endif
if COND_arm
CFLAGS_PLATFORM += -mthumb-interwork
CCASFLAGS_PLATFORM = -mthumb-interwork
CFLAGS_PLATFORM += -mthumb-interwork -mlong-calls
LDFLAGS_PLATFORM = -Wl,--wrap=__clear_cache
endif
if COND_arm64
CFLAGS_PLATFORM += -mcmodel=large
endif
#FIXME: discover and check XEN headers
CPPFLAGS_XEN = -I/usr/include
# Other options
if ! COND_emu
CFLAGS_PLATFORM += -Dfloat=__grub_poison
CFLAGS_PLATFORM += -Ddouble=__grub_poison
endif
CPPFLAGS_DEFAULT = -DGRUB_FILE=\"$(subst $(srcdir)/,,$<)\"
CPPFLAGS_DEFAULT += -I$(builddir)
CPPFLAGS_DEFAULT += -I$(srcdir)
@@ -36,10 +54,26 @@ CPPFLAGS_DEFAULT += -I$(top_srcdir)/grub-core/lib/libgcrypt-grub/src/
CCASFLAGS_DEFAULT = $(CPPFLAGS_DEFAULT) -DASM_FILE=1
BUILD_CPPFLAGS += $(CPPFLAGS_DEFAULT)
LDADD_KERNEL = $(TARGET_LIBGCC)
LDADD_KERNEL =
if ! COND_i386_pc
if ! COND_i386_efi
if ! COND_i386_qemu
if ! COND_i386_coreboot
if ! COND_i386_multiboot
if ! COND_i386_ieee1275
if ! COND_x86_64_efi
LDADD_KERNEL += -lgcc
endif
endif
endif
endif
endif
endif
endif
CFLAGS_KERNEL = $(CFLAGS_CPU) $(CFLAGS_PLATFORM) -ffreestanding
LDFLAGS_KERNEL = $(LDFLAGS_CPU) $(LDFLAGS_PLATFORM) -nostdlib $(TARGET_LDFLAGS_OLDMAGIC) $(TARGET_LDFLAGS_STATIC_LIBGCC)
LDFLAGS_KERNEL = $(LDFLAGS_CPU) $(LDFLAGS_PLATFORM) -nostdlib $(TARGET_LDFLAGS_OLDMAGIC) -static-libgcc
CPPFLAGS_KERNEL = $(CPPFLAGS_CPU) $(CPPFLAGS_PLATFORM) -DGRUB_KERNEL=1
CCASFLAGS_KERNEL = $(CCASFLAGS_CPU) $(CCASFLAGS_PLATFORM)
if COND_CYGWIN
@@ -73,13 +107,13 @@ grubconfdir = $(sysconfdir)/grub.d
platformdir = $(pkglibdir)/$(target_cpu)-$(platform)
starfielddir = $(pkgdatadir)/themes/starfield
CFLAGS_GNULIB = -Wno-undef -Wno-sign-compare -Wno-unused -Wno-unused-parameter -Wno-redundant-decls -Wno-unreachable-code -Wno-conversion
CFLAGS_GNULIB = -Wno-undef -Wno-sign-compare -Wno-unused -Wno-unused-parameter -Wno-redundant-decls -Wno-unreachable-code -Wno-conversion -Wno-old-style-definition -Wno-unsafe-loop-optimizations
CPPFLAGS_GNULIB = -I$(top_builddir)/grub-core/gnulib -I$(top_srcdir)/grub-core/gnulib
CFLAGS_POSIX = -fno-builtin
CPPFLAGS_POSIX = -I$(top_srcdir)/grub-core/lib/posix_wrap
CFLAGS_GCRY = -Wno-error -Wno-missing-field-initializers -Wno-redundant-decls -Wno-undef $(CFLAGS_POSIX)
CFLAGS_GCRY = -Wno-error -Wno-missing-field-initializers -Wno-redundant-decls $(CFLAGS_POSIX)
CPPFLAGS_GCRY = -I$(top_srcdir)/grub-core/lib/libgcrypt_wrap $(CPPFLAGS_POSIX) -D_GCRYPT_IN_LIBGCRYPT=1 -I$(top_srcdir)/include/grub/gcrypt
CPPFLAGS_EFIEMU = -I$(top_srcdir)/grub-core/efiemu/runtime
@@ -130,15 +164,20 @@ EXTRA_DIST =
CLEANFILES =
BUILT_SOURCES =
# Rules for Automake input
# Rules for autogen definition files
.PRECIOUS: $(top_srcdir)/Makefile.tpl
$(top_srcdir)/Makefile.tpl: $(top_srcdir)/gentpl.py
python $< | sed -e '/^$$/{N;/^\\n$$/D;}' > $@.new || (rm -f $@.new; exit 1)
mv $@.new $@
.PRECIOUS: $(top_srcdir)/Makefile.util.am
$(top_srcdir)/Makefile.util.am: $(top_srcdir)/gentpl.py $(top_srcdir)/Makefile.util.def $(top_srcdir)/Makefile.utilgcry.def
python $^ > $@.new || (rm -f $@.new; exit 1)
$(top_srcdir)/Makefile.util.am: $(top_srcdir)/Makefile.util.def $(top_srcdir)/Makefile.utilgcry.def $(top_srcdir)/Makefile.tpl
cat $(top_srcdir)/Makefile.util.def $(top_srcdir)/Makefile.utilgcry.def | autogen -T $(top_srcdir)/Makefile.tpl | sed -e '/^$$/{N;/^\\n$$/D;}' > $@.new || (rm -f $@.new; exit 1)
mv $@.new $@
.PRECIOUS: $(top_srcdir)/grub-core/Makefile.core.am
$(top_srcdir)/grub-core/Makefile.core.am: $(top_srcdir)/gentpl.py $(top_srcdir)/grub-core/Makefile.core.def $(top_srcdir)/grub-core/Makefile.gcry.def
$(top_srcdir)/grub-core/Makefile.core.am: $(top_srcdir)/grub-core/Makefile.core.def $(top_srcdir)/grub-core/Makefile.gcry.def $(top_srcdir)/Makefile.tpl
if [ "x$$GRUB_CONTRIB" != x ]; then echo "You need to run ./autogen.sh manually." >&2; exit 1; fi
python $^ > $@.new || (rm -f $@.new; exit 1)
cat $(top_srcdir)/grub-core/Makefile.core.def $(top_srcdir)/grub-core/Makefile.gcry.def | autogen -T $(top_srcdir)/Makefile.tpl | sed -e '/^$$/{N;/^\\n$$/D;}' > $@.new || (rm -f $@.new; exit 1)
mv $@.new $@

9
conf/Makefile.extra-dist
View File

@@ -2,6 +2,7 @@ EXTRA_DIST += autogen.sh
EXTRA_DIST += geninit.sh
EXTRA_DIST += gentpl.py
EXTRA_DIST += Makefile.tpl
EXTRA_DIST += Makefile.util.def
EXTRA_DIST += Makefile.utilgcry.def
@@ -11,9 +12,7 @@ EXTRA_DIST += util/import_gcry.py
EXTRA_DIST += util/import_unicode.py
EXTRA_DIST += docs/man
EXTRA_DIST += docs/autoiso.cfg
EXTRA_DIST += docs/grub.cfg
EXTRA_DIST += docs/osdetect.cfg
EXTRA_DIST += conf/i386-pc-cygwin-img-ld.sc
@@ -27,11 +26,6 @@ EXTRA_DIST += grub-core/gensymlist.sh
EXTRA_DIST += grub-core/genemuinit.sh
EXTRA_DIST += grub-core/genemuinitheader.sh
EXTRA_DIST += grub-core/gnulib-fix-null-deref.diff
EXTRA_DIST += grub-core/gnulib-fix-width.diff
EXTRA_DIST += grub-core/gnulib-no-abort.diff
EXTRA_DIST += grub-core/gnulib-no-gets.diff
EXTRA_DIST += grub-core/lib/libgcrypt
EXTRA_DIST += grub-core/lib/libgcrypt-grub/mpi/generic
EXTRA_DIST += $(shell find $(top_srcdir)/include -name '*.h')
@@ -109,4 +103,3 @@ EXTRA_DIST += grub-core/osdep/windows/sleep.c
EXTRA_DIST += tests/dfly-mbr-mbexample.mbr.img.gz
EXTRA_DIST += tests/dfly-mbr-mbexample.dfly.img.gz
EXTRA_DIST += coreboot.cfg

3
config.h.in
View File

@@ -6,8 +6,6 @@
#define __powerpc__ 1
#endif
#define GCRYPT_NO_DEPRECATED 1
/* Define to 1 to enable disk cache statistics. */
#define DISK_CACHE_STATS @DISK_CACHE_STATS@
#define BOOT_TIME_STATS @BOOT_TIME_STATS@
@@ -28,7 +26,6 @@
#elif defined (GRUB_UTIL) || !defined (GRUB_MACHINE)
#include <config-util.h>
#else
#define HAVE_FONT_SOURCE @HAVE_FONT_SOURCE@
/* Define if C symbols get an underscore after compilation. */
#define HAVE_ASM_USCORE @HAVE_ASM_USCORE@
/* Define it to \"addr32\" or \"addr32;\" to make GAS happy. */

693
configure.ac
View File

File diff suppressed because it is too large Load Diff

3
coreboot.cfg
View File

@@ -1,3 +0,0 @@
if test -f (cbfsdisk)/etc/grub.cfg; then
source (cbfsdisk)/etc/grub.cfg
fi

244
docs/autoiso.cfg
View File

@@ -1,244 +0,0 @@
# Sample GRUB script to autodetect operating systems
#
# Copyright (C) 2010 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/>.
function pathname { regexp -s 2:"$2" '^(\(.*\))?(/.*)$' "$1"; }
function devname { regexp -s "$2" '^(\(.*\)).*$' "$1"; }
function loopback_iso_entry {
realdev="$1"
isopath="$2"
loopdev="$3"
if test -f /boot/grub/loopback.cfg; then
cfgpath=/boot/grub/loopback.cfg
elif test -f /grub/loopback.cfg; then
cfgpath=/grub/loopback.cfg
else
return 1;
fi
echo loopback.cfg $isopath: yes
menuentry "Boot GRUB Loopback Config from ${realdev}${isopath}" "$realdev" "$isopath" "$cfgpath" {
set device="$2"
set iso_path="$3"
set cfg_path="$4"
export iso_path
loopback loopdev_cfg "${device}${iso_path}"
set root=(loopdev_cfg)
configfile $cfg_path
loopback -d loopdev_cfg
}
return 0
}
function grml_iso_entry {
realdev="$1"
isopath="$2"
loopdev="$3"
result=1
for dir in /boot/grml /boot/grmlsmall /boot/grmlmedium; do
if ! test -f ${dir}/linux26 -a -f ${dir}/initrd.gz; then continue; fi
echo grml $isopath: yes
result=0
menuentry "GRML Linux from ${realdev}${isopath}" \
"$realdev" "$isopath" "$dir" {
set device="$2"
set isopath="$3"
set grmldir="$4"
loopback loopdev_grml "${device}${isopath}"
set root=(loopdev_grml)
linux $grmldir/linux26 findiso="$isopath" apm=power-off quiet \
boot=live nomce
initrd $grmldir/initrd.gz
loopback -d loopdev_grml
}
done
return $result
}
function pmagic_iso_entry {
realdev="$1"
isopath="$2"
loopdev="$3"
if ! test -f /pmagic/bzImage -a -f /pmagic/initramfs; then return 1; fi
echo pmagic $isopath: yes
menuentry "Parted Magic from ${realdev}${isopath}" "$realdev" "$isopath" {
set device="$2"
set isopath="$3"
loopback loopdev_pmagic "${device}${isopath}"
set root=(loopdev_pmagic)
linux /pmagic/bzImage iso_filename="$isopath" edd=off noapic \
load_ramdisk=1 prompt_ramdisk=0 rw sleep=10 loglevel=0 \
keymap=$langcode
initrd /pmagic/initramfs
loopback -d loopdev_pmagic
}
return 0
}
function sidux_iso_entry {
realdev="$1"
isopath="$2"
loopdev="$3"
result=1
for kernel in /boot/vmlinuz-*-sidux-*; do
if ! test -f "$kernel"; then continue; fi
regexp -s 1:v1 -s 2:v2 '/boot/vmlinuz-(.*)-sidux-(.*)' "$kernel"
initrd="/boot/initrd.img-$v1-sidux-$v2"
if ! test -f "$initrd"; then continue; fi
result=0
echo sidux $isopath: yes
menuentry "Sidux vmlinux-$v1-sidux-$v2 from ${realdev}${isopath}" "$realdev" "$isopath" "$kernel" "$initrd" {
set device="$2"
set isopath="$3"
set kernel="$4"
set initrd="$5"
loopback loopdev_sidux "${device}${isopath}"
set root=(loopdev_sidux)
linux $kernel fromiso=$isopath boot=fll quiet
initrd $initrd
loopback -d loopdev_sidux
}
done
return $result
}
function slax_iso_entry {
realdev="$1"
isopath="$2"
loopdev="$3"
if ! test -f /boot/vmlinuz -a -f /boot/initrd.gz; then return 1; fi
echo slax $isopath: yes
menuentry "Slax Linux from ${realdev}${isopath}" "$realdev" "$isopath" {
set device="$2"
set isopath="$3"
loopback loopdev_slax "${device}${isopath}"
set root=(loopdev_slax)
linux /boot/vmlinuz from=$isopath ramdisk_size=6666 root=/dev/ram0 rw
initrd /boot/initrd.gz
loopback -d loopdev_slax
}
return 0
}
function tinycore_iso_entry {
realpath="$1"
isopath="$2"
loopdev="$3"
if ! test -f /boot/bzImage -a -f /boot/tinycore.gz; then return 1; fi
echo tinycore $isopath: yes
menuentry "Tinycore Linux from ${realdev}${isopath}" "$realdev" "$isopath" {
set device="$2"
set isopath="$3"
loopback loopdev_tiny "${device}${isopath}"
set root=(loopdev_tiny)
linux /boot/bzImage
initrd /boot/tinycore.gz
loopback -d loopdev_tiny
}
return 0
}
function casper_iso_entry {
realpath="$1"
isopath="$2"
loopdev="$3"
if ! test -f /casper/vmlinuz; then return 1; fi
initrd=
for f in /casper/initrd.*z; do
if ! test -f "$f"; then continue; fi
pathname "$f" initrd
done
if test -z "$initrd"; then return 1; fi
echo casper $isopath: yes
menuentry "Casper based Linux from ${realdev}${isopath}" "$realdev" "$isopath" "$initrd" {
set device="$2"
set isopath="$3"
set initrd="$4"
loopback loopdev_casper "${device}${isopath}"
set root=(loopdev_casper)
linux /casper/vmlinuz boot=casper iso-scan/filename="$isopath" quiet splash noprompt keyb="$langcode" \
debian-installer/language="$langcode" console-setup/layoutcode?="$langcode" --
initrd $initrd
loopback -d loopdev_casper
}
return 0
}
function scan_isos {
isodirs="$1"
for dev in (*); do
for dir in $isodirs; do
for file in ${dev}${dir}/*.iso ${dev}${dir}/*.ISO; do
if ! test -f "$file"; then continue; fi
pathname $file isopath
if test -z "$dev" -o -z "$isopath"; then continue; fi
if ! loopback loopdev_scan "$file"; then continue; fi
saved_root=$root
set root=(loopdev_scan)
if loopback_iso_entry $dev $isopath (loopdev_scan); then true;
elif grml_iso_entry $dev $isopath (loopdev_scan); then true;
elif pmagic_iso_entry $dev $isopath (loopdev_scan); then true;
elif sidux_iso_entry $dev $isopath (loopdev_scan); then true;
elif slax_iso_entry $dev $isopath (loopdev_scan); then true;
elif tinycore_iso_entry $dev $isopath (loopdev_scan); then true;
elif casper_iso_entry $dev $isopath (loopdev_scan); then true;
else true; fi
set root=$saved_root
loopback -d loopdev_scan
done
done
done
return 0
}
# XXX Remove later
insmod serial
serial
terminal_output --append serial
# terminal_input --append serial
langcode="$lang"
insmod regexp
scan_isos /iso /boot/iso

198
docs/grub-dev.texi
View File

@@ -79,7 +79,7 @@ This edition documents version @value{VERSION}.
* Contributing Changes::
* Porting::
* Error Handling::
* Stack and heap size::
* CIA::
* BIOS port memory map::
* Video Subsystem::
* PFF2 Font File Format::
@@ -92,36 +92,24 @@ This edition documents version @value{VERSION}.
@node Getting the source code
@chapter Getting the source code
GRUB is maintained using the @uref{GIT revision
control system}. To fetch:
GRUB is maintained using the @uref{http://bazaar-vcs.org/, Bazaar revision
control system}. To fetch the primary development branch:
@example
git clone git://git.sv.gnu.org/grub.git
bzr get http://bzr.savannah.gnu.org/r/grub/trunk/grub
@end example
Web access is available under
The GRUB developers maintain several other branches with work in progress.
Of these, the most interesting is the experimental branch, which is a
staging area for new code which we expect to eventually merge into trunk but
which is not yet ready:
@example
http://git.savannah.gnu.org/cgit/grub.git/
bzr get http://bzr.savannah.gnu.org/r/grub/branches/experimental
@end example
The branches available are:
@table @samp
@item master
Main developpement branch.
@item grub-legacy
GRUB 0.97 codebase. Kept for reference and legal reasons
@item multiboot
Multiboot specfication
@item multiboot2
Multiboot2 specfication
@item developper branches
Prefixed with developper name. Every developper of a team manages his own branches.
Developper branches do not need changelog entries.
@end table
Once you have used @kbd{git clone} to fetch an initial copy of a branch, you
can use @kbd{git pull} to keep it up to date. If you have modified your
Once you have used @kbd{bzr get} to fetch an initial copy of a branch, you
can use @kbd{bzr pull} to keep it up to date. If you have modified your
local version, you may need to resolve conflicts when pulling.
@node Coding style
@@ -346,10 +334,10 @@ anymore.
@itemize
@item Always use latest GRUB 2 source code. So get that first.
For developers it is recommended always to use the newest development version of GRUB 2. If development takes a long period of time, please remember to keep in sync with newest developments regularly so it is much easier to integrate your change in the future. GRUB 2 is being developed in a GIT repository.
For developers it is recommended always to use the newest development version of GRUB 2. If development takes a long period of time, please remember to keep in sync with newest developments regularly so it is much easier to integrate your change in the future. GRUB 2 is being developed in a Bazaar (bzr) repository.
Please check Savannah's GRUB project page for details how to get newest git:
@uref{https://savannah.gnu.org/git/?group=grub, GRUB 2 git Repository}
Please check Savannah's GRUB project page for details how to get newest bzr:
@uref{http://savannah.gnu.org/bzr/?group=grub, GRUB 2 bzr Repository}
@item Compile it and try it out.
@@ -907,68 +895,33 @@ if (grub_errno != GRUB_ERR_NONE)
grub_error_pop ();
@end example
@node Stack and heap size
@chapter Stack and heap size
@node CIA
@chapter CIA
@c By Robert Millan and Carles Pina
If you have commit access, please setup CIA in your Bazaar
config so those in IRC receive notification of your commits.
On emu stack and heap are just normal host OS stack and heap. Stack is typically
8 MiB although it's OS-dependent.
In @file{~/.bazaar/bazaar.conf}, add "cia_send_revno = true".
Optionally, you can also add "cia_user = myusername" if you'd
like CIA service to use a specific account (for statistical purpose).
On i386-pc, i386-coreboot, i386-qemu and i386-multiboot the stack is 60KiB.
All available space between 1MiB and 4GiB marks is part of heap.
In the @file{.bzr/branch/branch.conf} of your checkout branch,
"set nickname = /path_to_this_branch" and "cia_project = GNU GRUB".
On *-xen stack is 4MiB. If compiled for x86-64 with GCC 4.4 or later adressable
space is unlimited. When compiled for x86-64 with older GCC version adressable
space is limited to 2GiB. When compiling for i386 adressable space is limited
to 4GiB. All adressable pages except the ones for stack, GRUB binary, special
pages and page table are in the heap.
Additionally, please set cia_send_revno in the [DEFAULT] section
of your @file{~/.bazaar/bazaar.conf}. E.g.:
On *-efi GRUB uses same stack as EFI. If compiled for x86-64 with GCC 4.4 or
later adressable space is unlimited. When compiled for x86-64 with older GCC
version adressable space is limited to 2GiB. For all other platforms adressable
space is limited to 4GiB. GRUB allocates pages from EFI for its heap, at most
1.6 GiB.
@example
[DEFAULT]
cia_send_revno = true
@end example
On i386-ieee1275 and powerpc-ieee1275 GRUB uses same stack as IEEE1275.
It allocates at most 32MiB for its heap.
On sparc64-ieee1275 stack is 256KiB and heap is 2MiB.
On mips(el)-qemu_mips and mipsel-loongson stack is 2MiB (everything below
GRUB image) and everything above GRUB image (from 2MiB + kernel size)
until 256MiB is part of heap.
On mips-arc stack is 2MiB (everything below GRUB image) and everything above
GRUB image(from 2MiB + kernel size) until 128MiB is part of heap.
On mipsel-arc stack is 2MiB (everything below GRUB image which is not part
of ARC) and everything above GRUB image (from 7MiB + kernel size)
until 256MiB is part of heap.
On arm-uboot stack is 256KiB and heap is 2MiB.
In short:
@multitable @columnfractions .15 .25 .5
@headitem Platform @tab Stack @tab Heap
@item emu @tab 8 MiB @tab ?
@item i386-pc @tab 60 KiB @tab < 4 GiB
@item i386-coreboot @tab 60 KiB @tab < 4 GiB
@item i386-multiboot @tab 60 KiB @tab < 4 GiB
@item i386-qemu @tab 60 KiB @tab < 4 GiB
@item *-efi @tab ? @tab < 1.6 GiB
@item i386-ieee1275 @tab ? @tab < 32 MiB
@item powerpc-ieee1275 @tab ? @tab < 32 MiB
@item sparc64-ieee1275 @tab 256KiB @tab 2 MiB
@item arm-uboot @tab 256KiB @tab 2 MiB
@item mips(el)-qemu_mips @tab 2MiB @tab 253 MiB
@item mipsel-loongson @tab 2MiB @tab 253 MiB
@item mips-arc @tab 2MiB @tab 125 MiB
@item mipsel-arc @tab 2MiB @tab 248 MiB
@item x86_64-xen (GCC >= 4.4) @tab 4MiB @tab unlimited
@item x86_64-xen (GCC < 4.4) @tab 4MiB @tab < 2GiB
@item i386-xen @tab 4MiB @tab < 4GiB
@end multitable
Remember to install cia-clients (Debian/Ubuntu package) to be able to use CIA.
Keep in mind Bazaar sends notifications for all commits to branches that have
this setting, regardless of whether they're bound branches (checkouts) or not.
So if you make local commits in a non-bound branch and it bothers you that
others can read them, do not use this setting.
@node BIOS port memory map
@chapter BIOS port memory map
@@ -981,8 +934,9 @@ In short:
@item ? @tab 0x2000 - 1 @tab Real mode stack
@item 0x7C00 @tab 0x7D00 - 1 @tab Boot sector
@item 0x8000 @tab ? @tab GRUB kernel
@item 0x68000 @tab 0x71000 - 1 @tab Disk buffer
@item 0x68000 @tab 0x78000 - 1 @tab Disk buffer
@item ? @tab 0x80000 - 1 @tab Protected mode stack
@item 0x80000 @tab ? @tab Heap
@item ? @tab 0xA0000 - 1 @tab Extended BIOS Data Area
@item 0xA0000 @tab 0xC0000 - 1 @tab Video RAM
@item 0xC0000 @tab 0x100000 - 1 @tab BIOS
@@ -1159,47 +1113,6 @@ struct grub_video_palette_data
Used to query indexed color palettes. If mode is RGB mode, colors will be copied from emulated palette data. In Indexed Color modes, palettes will be read from hardware. Color values will be converted to suit structure format. @code{start} will tell what hardware color index (or emulated color index) will be used as a source for first indice of @code{palette_data}, after that both hardware color index and @code{palette_data} index will be incremented until @code{count} number of colors have been read.
@end itemize
@subsection grub_video_set_area_status
@itemize
@item Prototype:
@example
grub_err_t
grub_video_set_area_status (grub_video_area_status_t area_status);
@end example
@example
enum grub_video_area_status_t
@{
GRUB_VIDEO_AREA_DISABLED,
GRUB_VIDEO_AREA_ENABLED
@};
@end example
@item Description:
Used to set area drawing mode for redrawing the specified region. Draw commands
are performed in the intersection of the viewport and the region called area.
Coordinates remain related to the viewport. If draw commands try to draw over
the area, they are clipped.
Set status to DISABLED if you need to draw everything.
Set status to ENABLED and region to the desired rectangle to redraw everything
inside the region leaving everything else intact.
Should be used for redrawing of active elements.
@end itemize
@subsection grub_video_get_area_status
@itemize
@item Prototype:
@example
grub_err_r
grub_video_get_area_status (grub_video_area_status_t *area_status);
@end example
@item Description:
Used to query the area status.
@end itemize
@subsection grub_video_set_viewport
@itemize
@item Prototype:
@@ -1226,37 +1139,6 @@ grub_video_get_viewport (unsigned int *x, unsigned int *y, unsigned int *width,
Used to query current viewport dimensions. Software developer can use this to choose best way to render contents of the viewport.
@end itemize
@subsection grub_video_set_region
@itemize
@item Prototype:
@example
grub_err_t
grub_video_set_region (unsigned int x, unsigned int y, unsigned int width, unsigned int height);
@end example
@item Description:
Used to specify the region of the screen which should be redrawn. Use absolute
values. When the region is set and area status is ENABLE all draw commands will
be performed inside the interseption of region and viewport named area.
If draw commands try to draw over viewport, they are clipped. If developer
requests larger than possible region, width and height will be clamped to fit
screen. Should be used for redrawing of active elements.
@end itemize
@subsection grub_video_get_region
@itemize
@item Prototype:
@example
grub_err_t
grub_video_get_region (unsigned int *x, unsigned int *y, unsigned int *width, unsigned int *height);
@end example
@item Description:
Used to query current region dimensions.
@end itemize
@subsection grub_video_map_color
@itemize
@item Prototype:
@@ -1812,9 +1694,7 @@ right edges of two adjacent glyphs. The @strong{device width} field determines
the effective leading value that is used to render the font.
@end itemize
@ifnottex
@image{font_char_metrics,,,,.png}
@end ifnottex
@image{font_char_metrics,,,,png}
An illustration of how the various font metrics apply to characters.

256
docs/grub.texi
View File

@@ -701,26 +701,6 @@ you may run those commands directly to install GRUB, without using
with the internals of GRUB. Installing a boot loader on a running OS may be
extremely dangerous.
On EFI systems for fixed disk install you have to mount EFI System Partition.
If you mount it at @file{/boot/efi} then you don't need any special arguments:
@example
# @kbd{grub-install}
@end example
Otherwise you need to specify where your EFI System partition is mounted:
@example
# @kbd{grub-install --efi-directory=/mnt/efi}
@end example
For removable installs you have to use @option{--removable} and specify both
@option{--boot-directory} and @option{--efi-directory}:
@example
# @kbd{grub-install --efi-directory=/mnt/usb --boot-directory=/mnt/usb/boot --removable}
@end example
@node Making a GRUB bootable CD-ROM
@section Making a GRUB bootable CD-ROM
@@ -1254,14 +1234,14 @@ Valid keys in @file{/etc/default/grub} are as follows:
@item GRUB_DEFAULT
The default menu entry. This may be a number, in which case it identifies
the Nth entry in the generated menu counted from zero, or the title of a
menu entry, or the special string @samp{saved}. Using the id may be
menu entry, or the special string @samp{saved}. Using the title may be
useful if you want to set a menu entry as the default even though there may
be a variable number of entries before it.
For example, if you have:
@verbatim
menuentry 'Example GNU/Linux distribution' --class gnu-linux --id example-gnu-linux {
menuentry 'Example GNU/Linux distribution' --class gnu-linux {
...
}
@end verbatim
@@ -1269,17 +1249,12 @@ menuentry 'Example GNU/Linux distribution' --class gnu-linux --id example-gnu-li
then you can make this the default using:
@example
GRUB_DEFAULT=example-gnu-linux
GRUB_DEFAULT='Example GNU/Linux distribution'
@end example
Previously it was documented the way to use entry title. While this still
works it's not recommended since titles often contain unstable device names
and may be translated
If you set this to @samp{saved}, then the default menu entry will be that
saved by @samp{GRUB_SAVEDEFAULT} or @command{grub-set-default}. This relies on
the environment block, which may not be available in all situations
(@pxref{Environment block}).
saved by @samp{GRUB_SAVEDEFAULT}, @command{grub-set-default}, or
@command{grub-reboot}.
The default is @samp{0}.
@@ -1288,7 +1263,7 @@ If this option is set to @samp{true}, then, when an entry is selected, save
it as a new default entry for use by future runs of GRUB. This is only
useful if @samp{GRUB_DEFAULT=saved}; it is a separate option because
@samp{GRUB_DEFAULT=saved} is useful without this option, in conjunction with
@command{grub-set-default}. Unset by default.
@command{grub-set-default} or @command{grub-reboot}. Unset by default.
This option relies on the environment block, which may not be available in
all situations (@pxref{Environment block}).
@@ -1298,26 +1273,23 @@ a key is pressed. The default is @samp{5}. Set to @samp{0} to boot
immediately without displaying the menu, or to @samp{-1} to wait
indefinitely.
If @samp{GRUB_TIMEOUT_STYLE} is set to @samp{countdown} or @samp{hidden},
the timeout is instead counted before the menu is displayed.
@item GRUB_HIDDEN_TIMEOUT
Wait this many seconds for @key{ESC} to be pressed before displaying the menu.
If no @key{ESC} is pressed during that time, display the menu for the number of
seconds specified in GRUB_TIMEOUT before booting the default entry. We expect
that most people who use GRUB_HIDDEN_TIMEOUT will want to have GRUB_TIMEOUT set
to @samp{0} so that the menu is not displayed at all unless @key{ESC} is
pressed.
Unset by default.
@item GRUB_TIMEOUT_STYLE
If this option is unset or set to @samp{menu}, then GRUB will display the
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.
If this option is set to @samp{countdown} or @samp{hidden}, then, before
displaying the menu, GRUB will wait for the timeout set by
@samp{GRUB_TIMEOUT} to expire. If @key{ESC} is pressed during that time, it
will display the menu and wait for input. If a hotkey associated with a
menu entry is pressed, it will boot the associated menu entry immediately.
If the timeout expires before either of these happens, it will boot the
default entry. In the @samp{countdown} case, it will show a one-line
indication of the remaining time.
@item GRUB_HIDDEN_TIMEOUT_QUIET
In conjunction with @samp{GRUB_HIDDEN_TIMEOUT}, set this to @samp{true} to
suppress the verbose countdown while waiting for a key to be pressed before
displaying the menu. Unset by default.
@item GRUB_DEFAULT_BUTTON
@itemx GRUB_TIMEOUT_BUTTON
@itemx GRUB_TIMEOUT_STYLE_BUTTON
@itemx GRUB_HIDDEN_TIMEOUT_BUTTON
@itemx GRUB_BUTTON_CMOS_ADDRESS
Variants of the corresponding variables without the @samp{_BUTTON} suffix,
used to support vendor-specific power buttons. @xref{Vendor power-on keys}.
@@ -1454,22 +1426,6 @@ Normally, @command{grub-mkconfig} will try to use the external
systems installed on the same system and generate appropriate menu entries
for them. Set this option to @samp{true} to disable this.
@item GRUB_OS_PROBER_SKIP_LIST
List of space-separated FS UUIDs of filesystems to be ignored from os-prober
output. For efi chainloaders it's <UUID>@@<EFI FILE>
@item GRUB_DISABLE_SUBMENU
Normally, @command{grub-mkconfig} will generate top level menu entry for
the kernel with highest version number and put all other found kernels
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
in submenu. If this option is set to @samp{y}, flat menu with all entries
on top level will be generated instead. Changing this option will require
changing existing values of @samp{GRUB_DEFAULT}, @samp{fallback} (@pxref{fallback})
and @samp{default} (@pxref{default}) environment variables as well as saved
default entry using @command{grub-set-default} and value used with
@command{grub-reboot}.
@item GRUB_ENABLE_CRYPTODISK
If set to @samp{y}, @command{grub-mkconfig} and @command{grub-install} will
check for encrypted disks and generate additional commands needed to access
@@ -1492,44 +1448,6 @@ Each module will be loaded as early as possible, at the start of
@end table
The following options are still accepted for compatibility with existing
configurations, but have better replacements:
@table @samp
@item GRUB_HIDDEN_TIMEOUT
Wait this many seconds before displaying the menu. If @key{ESC} is pressed
during that time, display the menu and wait for input according to
@samp{GRUB_TIMEOUT}. If a hotkey associated with a menu entry is pressed,
boot the associated menu entry immediately. If the timeout expires before
either of these happens, display the menu for the number of seconds
specified in @samp{GRUB_TIMEOUT} before booting the default entry.
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
@key{ESC} is pressed.
This option is unset by default, and is deprecated in favour of the less
confusing @samp{GRUB_TIMEOUT_STYLE=countdown} or
@samp{GRUB_TIMEOUT_STYLE=hidden}.
@item GRUB_HIDDEN_TIMEOUT_QUIET
In conjunction with @samp{GRUB_HIDDEN_TIMEOUT}, set this to @samp{true} to
suppress the verbose countdown while waiting for a key to be pressed before
displaying the menu.
This option is unset by default, and is deprecated in favour of the less
confusing @samp{GRUB_TIMEOUT_STYLE=countdown}.
@item GRUB_HIDDEN_TIMEOUT_BUTTON
Variant of @samp{GRUB_HIDDEN_TIMEOUT}, used to support vendor-specific power
buttons. @xref{Vendor power-on keys}.
This option is unset by default, and is deprecated in favour of the less
confusing @samp{GRUB_TIMEOUT_STYLE=countdown} or
@samp{GRUB_TIMEOUT_STYLE=hidden}.
@end table
For more detailed customisation of @command{grub-mkconfig}'s output, you may
edit the scripts in @file{/etc/grub.d} directly.
@file{/etc/grub.d/40_custom} is particularly useful for adding entire custom
@@ -2518,20 +2436,17 @@ menu requires several fancy features of your terminal.
@node Vendor power-on keys
@chapter Using GRUB with vendor power-on keys
Some laptop vendors provide an additional power-on button which boots
another OS. GRUB supports such buttons with the @samp{GRUB_TIMEOUT_BUTTON},
@samp{GRUB_TIMEOUT_STYLE_BUTTON}, @samp{GRUB_DEFAULT_BUTTON}, and
Some laptop vendors provide an additional power-on button which boots another
OS. GRUB supports such buttons with the @samp{GRUB_TIMEOUT_BUTTON},
@samp{GRUB_DEFAULT_BUTTON}, @samp{GRUB_HIDDEN_TIMEOUT_BUTTON} and
@samp{GRUB_BUTTON_CMOS_ADDRESS} variables in default/grub (@pxref{Simple
configuration}). @samp{GRUB_TIMEOUT_BUTTON},
@samp{GRUB_TIMEOUT_STYLE_BUTTON}, and @samp{GRUB_DEFAULT_BUTTON} are used
instead of the corresponding variables without the @samp{_BUTTON} suffix
when powered on using the special button. @samp{GRUB_BUTTON_CMOS_ADDRESS}
is vendor-specific and partially model-specific. Values known to the GRUB
team are:
configuration}). @samp{GRUB_TIMEOUT_BUTTON}, @samp{GRUB_DEFAULT_BUTTON} and
@samp{GRUB_HIDDEN_TIMEOUT_BUTTON} are used instead of the corresponding
variables without the @samp{_BUTTON} suffix when powered on using the special
button. @samp{GRUB_BUTTON_CMOS_ADDRESS} is vendor-specific and partially
model-specific. Values known to the GRUB team are:
@table @key
@item Dell XPS M1330M
121:3
@item Dell XPS M1530
85:3
@item Dell Latitude E4300
@@ -2711,7 +2626,6 @@ Heavily limited platforms:
Lightly limited platforms:
@itemize
@item *-xen: limited only by adress space and RAM size.
@item i386-qemu: kernel.img (.text + .data + .bss) is limited by 392704 bytes.
(core.img would be limited by ROM size but it's unlimited on qemu
@item All EFI platforms: limited by contiguous RAM size and possibly firmware bugs
@@ -2767,9 +2681,9 @@ by a digit, like @samp{fd0}, or @samp{cd}.
AHCI, PATA (ata), crypto, USB use the name of driver followed by a number.
Memdisk and host are limited to one disk and so it's refered just by driver
name.
RAID (md), ofdisk (ieee1275 and nand), LVM (lvm), LDM, virtio (vdsk)
and arcdisk (arc) use intrinsic name of disk prefixed by driver name.
Additionally just ``nand'' refers to the disk aliased as ``nand''.
RAID (md), ofdisk (ieee1275 and nand), LVM (lvm), LDM and arcdisk (arc) use
intrinsic name of disk prefixed by driver name. Additionally just ``nand''
refers to the disk aliased as ``nand''.
Conflicts are solved by suffixing a number if necessarry.
Commas need to be escaped.
Loopback uses whatever name specified to @command{loopback} command.
@@ -3035,7 +2949,6 @@ These variables have special meaning to GRUB.
* biosnum::
* check_signatures::
* chosen::
* cmdpath::
* color_highlight::
* color_normal::
* debug::
@@ -3072,7 +2985,6 @@ These variables have special meaning to GRUB.
* superusers::
* theme::
* timeout::
* timeout_style::
@end menu
@@ -3106,16 +3018,6 @@ the titles of each of the submenus starting from the top level followed by
the title of the menu entry itself, separated by @samp{>}.
@node cmdpath
@subsection cmdpath
The location from which @file{core.img} was loaded as an absolute
directory name (@pxref{File name syntax}). This is set by GRUB at
startup based on information returned by platform firmware. Not every
platform provides this information and some may return only device
without path name.
@node color_highlight
@subsection color_highlight
@@ -3186,8 +3088,7 @@ to go beyond the current 16 colors.
This variable may be set to enable debugging output from various components
of GRUB. The value is a list of debug facility names separated by
whitespace or @samp{,}, or @samp{all} to enable all available debugging
output. The facility names are the first argument to grub_dprintf. Consult
source for more details.
output.
@node default
@@ -3195,21 +3096,7 @@ source for more details.
If this variable is set, it identifies a menu entry that should be selected
by default, possibly after a timeout (@pxref{timeout}). The entry may be
identified by number or by id.
For example, if you have:
@verbatim
menuentry 'Example GNU/Linux distribution' --class gnu-linux --id example-gnu-linux {
...
}
@end verbatim
then you can make this the default using:
@example
default=example-gnu-linux
@end example
identified by number or by title.
If the entry is in a submenu, then it must be identified using the titles of
each of the submenus starting from the top level followed by the number or
@@ -3249,8 +3136,7 @@ If this variable is set, it sets the resolution used on the @samp{gfxterm}
graphical terminal. Note that you can only use modes which your graphics
card supports via VESA BIOS Extensions (VBE), so for example native LCD
panel resolutions may not be available. The default is @samp{auto}, which
selects a platform-specific default that should look reasonable. Supported
modes can be listed by @samp{videoinfo} command in GRUB.
selects a platform-specific default that should look reasonable.
The resolution may be specified as a sequence of one or more modes,
separated by commas (@samp{,}) or semicolons (@samp{;}); each will be tried
@@ -3505,21 +3391,8 @@ keyboard input before booting the default menu entry. A timeout of @samp{0}
means to boot the default entry immediately without displaying the menu; a
timeout of @samp{-1} (or unset) means to wait indefinitely.
If @samp{timeout_style} (@pxref{timeout_style}) is set to @samp{countdown}
or @samp{hidden}, the timeout is instead counted before the menu is
displayed.
This variable is often set by @samp{GRUB_TIMEOUT} (@pxref{Simple
configuration}).
@node timeout_style
@subsection timeout_style
This variable may be set to @samp{menu}, @samp{countdown}, or @samp{hidden}
to control the way in which the timeout (@pxref{timeout}) interacts with
displaying the menu. See the documentation of @samp{GRUB_TIMEOUT_STYLE}
(@pxref{Simple configuration}) for details.
This variable is often set by @samp{GRUB_TIMEOUT} or
@samp{GRUB_HIDDEN_TIMEOUT} (@pxref{Simple configuration}).
@node Environment block
@@ -3807,8 +3680,6 @@ you forget a command, you can run the command @command{help}
* lsfonts:: List loaded fonts
* lsmod:: Show loaded modules
* md5sum:: Compute or check MD5 hash
* module:: Load module for multiboot kernel
* multiboot:: Load multiboot compliant kernel
* nativedisk:: Switch to native disk drivers
* normal:: Enter normal mode
* normal_exit:: Exit from normal mode
@@ -4476,7 +4347,7 @@ List devices or files.
With no arguments, print all devices known to GRUB.
If the argument is a device name enclosed in parentheses (@pxref{Device
syntax}), then print the name of the filesystem of that device.
syntax}), then list all files at the root directory of that device.
If the argument is a directory given as an absolute file name (@pxref{File
name syntax}), then list the contents of that directory.
@@ -4498,6 +4369,7 @@ List loaded fonts.
Show list of loaded modules.
@end deffn
@node md5sum
@subsection md5sum
@@ -4506,34 +4378,6 @@ Alias for @code{hashsum --hash md5 arg @dots{}}. See command @command{hashsum}
(@pxref{hashsum}) for full description.
@end deffn
@node module
@subsection module
@deffn Command module [--nounzip] file [arguments]
Load a module for multiboot kernel image. The rest of the
line is passed verbatim as the module command line.
@end deffn
@node multiboot
@subsection multiboot
@deffn Command multiboot [--quirk-bad-kludge] [--quirk-modules-after-kernel] file @dots{}
Load a multiboot kernel image from @var{file}. The rest of the
line is passed verbatim as the @dfn{kernel command-line}. Any module must
be reloaded after using this command (@pxref{module}).
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
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
use kludge. Use this option to ignore kludge.
Known affected systems: old Solaris, SkyOS.
--quirk-modules-after-kernel is needed for kernels which load at relatively
high address e.g. 16MiB mark and can't cope with modules stuffed between
1MiB mark and beginning of the kernel.
Known afftected systems: VMWare.
@end deffn
@node nativedisk
@subsection nativedisk
@@ -4939,8 +4783,7 @@ Alias for @code{hashsum --hash sha512 arg @dots{}}. See command @command{hashsum
@deffn Command sleep [@option{--verbose}] [@option{--interruptible}] count
Sleep for @var{count} seconds. If option @option{--interruptible} is given,
allow @key{ESC} to interrupt sleep. With @option{--verbose} show countdown
of remaining seconds. Exit code is set to 0 if timeout expired and to 1
if timeout was interrupted by @key{ESC}.
of remaining seconds.
@end deffn
@@ -5277,14 +5120,12 @@ is given, use default list of servers.
@node Internationalisation
@chapter Internationalisation
@section Charset
@chapter Charset
GRUB uses UTF-8 internally other than in rendering where some GRUB-specific
appropriate representation is used. All text files (including config) are
assumed to be encoded in UTF-8.
@section Filesystems
@chapter Filesystems
NTFS, JFS, UDF, HFS+, exFAT, long filenames in FAT, Joliet part of
ISO9660 are treated as UTF-16 as per specification. AFS and BFS are read
as UTF-8, again according to specification. BtrFS, cpio, tar, squash4, minix,
@@ -5318,7 +5159,7 @@ treated as distinct from u+combining diaresis. This however means that in
order to access file on HFS+ its name must be specified in normalisation form D.
On normalized ZFS subvolumes filenames out of normalisation are inaccessible.
@section Output terminal
@chapter Output terminal
Firmware output console ``console'' on ARC and IEEE1275 are limited to ASCII.
BIOS firmware console and VGA text are limited to ASCII and some pseudographics.
@@ -5352,7 +5193,7 @@ called ``annotation characters'' If you can complete either of
two lists or, better, propose a patch to improve rendering, please contact
developer team.
@section Input terminal
@chapter Input terminal
Firmware console on BIOS, IEEE1275 and ARC doesn't allow you to enter non-ASCII
characters. EFI specification allows for such but author is unaware of any
actual implementations. Serial input is currently limited for latin1 (unlikely
@@ -5362,15 +5203,15 @@ So no dead keys or advanced input method. Also there is no keymap change hotkey.
In practice it makes difficult to enter any text using non-Latin alphabet.
Moreover all current input consumers are limited to ASCII.
@section Gettext
@chapter Gettext
GRUB supports being translated. For this you need to have language *.mo files in $prefix/locale, load gettext module and set ``lang'' variable.
@section Regexp
@chapter Regexp
Regexps work on unicode characters, however no attempt at checking cannonical
equivalence has been made. Moreover the classes like [:alpha:] match only
ASCII subset.
@section Other
@chapter Other
Currently GRUB always uses YEAR-MONTH-DAY HOUR:MINUTE:SECOND [WEEKDAY] 24-hour
datetime format but weekdays are translated.
GRUB always uses the decimal number format with [0-9] as digits and . as
@@ -5499,8 +5340,9 @@ may halt or otherwise impact the boot process.
GRUB uses GPG-style detached signatures (meaning that a file
@file{foo.sig} will be produced when file @file{foo} is signed), and
currently supports the DSA and RSA signing algorithms. A signing key
can be generated as follows:
currently supports the DSA signing algorithm. Both 2048-bit and
3072-bit keys are supported. A signing key can be generated as
follows:
@example
gpg --gen-key
@@ -5840,7 +5682,7 @@ X86 support is summarised in the following table. ``Yes'' means that the kernel
PowerPC, IA64 and Sparc64 ports support only Linux. MIPS port supports Linux
and multiboot2.
@section Boot tests
@chapter Boot tests
As you have seen in previous chapter the support matrix is pretty big and some of the configurations are only rarely used. To ensure the quality bootchecks are available for all x86 targets except EFI chainloader, Appleloader and XNU. All x86 platforms have bootcheck facility except ieee1275. Multiboot, multiboot2, BIOS chainloader, ntldr and freebsd-bootloader boot targets are tested only with a fake kernel images. Only Linux is tested among the payloads using Linux protocols.

1038
gentpl.py
View File

File diff suppressed because it is too large Load Diff

96
grub-core/Makefile.am
View File

@@ -10,6 +10,10 @@ CCAS=$(TARGET_CC)
RANLIB=$(TARGET_RANLIB)
STRIP=$(TARGET_STRIP)
if COND_HAVE_FONT_SOURCE
TARGET_CFLAGS += -DUSE_ASCII_FALLBACK=1 -DHAVE_UNIFONT_WIDTHSPEC=1
endif
MACHO2IMG=$(top_builddir)/grub-macho2img
AM_CFLAGS = $(TARGET_CFLAGS)
@@ -78,9 +82,7 @@ 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/mm_private.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/net.h
if !COND_clang
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/libgcc.h
endif
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/memory.h
if COND_i386_pc
@@ -126,24 +128,6 @@ KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/lib/arg.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/i386/tsc.h
endif
if COND_i386_xen
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/xen.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/i386/xen/hypercall.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/terminfo.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/extcmd.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/lib/arg.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/loader.h
endif
if COND_x86_64_xen
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/xen.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/x86_64/xen/hypercall.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/terminfo.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/extcmd.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/lib/arg.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/loader.h
endif
if COND_x86_64_efi
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/efi/efi.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/efi/disk.h
@@ -230,11 +214,6 @@ KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/efi/efi.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/efi/disk.h
endif
if COND_arm64_efi
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/efi/efi.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/efi/disk.h
endif
if COND_emu
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/datetime.h
KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/emu/misc.h
@@ -389,44 +368,43 @@ CLEANFILES += $(MOD_FILES)
if COND_ENABLE_EFIEMU
efiemu32.o: efiemu/runtime/efiemu.c $(TARGET_OBJ2ELF)
-rm -f $@
-rm -f $@.bin
$(TARGET_CC) $(DEFS) $(INCLUDES) $(CPPFLAGS_EFIEMU) $(CPPFLAGS_DEFAULT) -m32 -Wall -Werror -nostdlib -static -O2 -c -o $@.bin $<
if test "x$(TARGET_APPLE_LINKER)" = x1; then \
$(TARGET_OBJCONV) -felf32 -nu -nd $@.bin $@ || exit 1; \
rm -f $@.bin ; \
elif test ! -z "$(TARGET_OBJ2ELF)"; then \
$(TARGET_OBJ2ELF) $@.bin || (rm -f $@.bin; exit 1); \
mv $@.bin $@ ; \
else \
mv $@.bin $@ ; \
fi
# Link format -arch,x86_64 means Apple linker
efiemu64_c.o: efiemu/runtime/efiemu.c
$(TARGET_CC) $(DEFS) $(INCLUDES) $(CPPFLAGS_EFIEMU) $(CPPFLAGS_DEFAULT) -m64 -nostdlib -Wall -Werror -O2 -mcmodel=large -mno-red-zone -c -o $@ $<
efiemu64_s.o: efiemu/runtime/efiemu.S
$(TARGET_CC) $(DEFS) $(INCLUDES) $(CPPFLAGS_EFIEMU) $(CPPFLAGS_DEFAULT) -m64 -Wall -Werror -nostdlib -O2 -mcmodel=large -mno-red-zone -c -o $@ $<
efiemu64.o: efiemu64_c.o efiemu64_s.o $(TARGET_OBJ2ELEF)
-rm -f $@
-rm -f $@.bin
$(TARGET_CC) -m64 $(EFIEMU64_LINK_FORMAT) -nostdlib -static -Wl,-r -o $@.bin $^
if test "x$(EFIEMU64_LINK_FORMAT)" = x-arch,x86_64; then \
$(TARGET_OBJCONV) -felf64 -nu -nd $@.bin $@ || exit 1; \
-rm -f $@; \
if test "x$(TARGET_APPLE_CC)" = x1; then \
$(TARGET_CC) $(DEFS) $(INCLUDES) $(CPPFLAGS_EFIEMU) $(CPPFLAGS_DEFAULT) -DELF32 -DAPPLE_CC -m32 -Wall -Werror -nostdlib -O2 -c -o $@.bin $< || exit 1; \
$(OBJCONV) -felf32 -nu -nd $@.bin $@ || exit 1; \
rm -f $@.bin; \
else \
mv $@.bin $@ ; \
$(TARGET_CC) $(DEFS) $(INCLUDES) $(CPPFLAGS_EFIEMU) $(CPPFLAGS_DEFAULT) -DELF32 -m32 -Wall -Werror -nostdlib -O2 -c -o $@ $< || exit 1; \
if test ! -z "$(TARGET_OBJ2ELF)"; then $(TARGET_OBJ2ELF) $@ || (rm -f $@; exit 1); fi; \
fi
efiemu64_c.o: efiemu/runtime/efiemu.c
if test "x$(TARGET_APPLE_CC)" = x1; then \
$(TARGET_CC) $(DEFS) $(INCLUDES) $(CPPFLAGS_EFIEMU) $(CPPFLAGS_DEFAULT) -DELF64 -DAPPLE_CC=1 -m64 -nostdlib -Wall -Werror -mno-red-zone -c -o $@ $< || exit 1; \
else \
$(TARGET_CC) $(DEFS) $(INCLUDES) $(CPPFLAGS_EFIEMU) $(CPPFLAGS_DEFAULT) -DELF64 -m64 -nostdlib -Wall -Werror -O2 -mcmodel=large -mno-red-zone -c -o $@ $< || exit 1; \
fi
efiemu64_s.o: efiemu/runtime/efiemu.S
-rm -f $@
if test "x$(TARGET_APPLE_CC)" = x1; then \
$(TARGET_CC) $(DEFS) $(INCLUDES) $(CPPFLAGS_EFIEMU) $(CPPFLAGS_DEFAULT) -DELF64 -DAPPLE_CC=1 -m64 -Wall -Werror -nostdlib -O2 -mno-red-zone -c -o $@ $< || exit 1; \
else \
$(TARGET_CC) $(DEFS) $(INCLUDES) $(CPPFLAGS_EFIEMU) $(CPPFLAGS_DEFAULT) -DELF64 -m64 -Wall -Werror -nostdlib -O2 -mcmodel=large -mno-red-zone -c -o $@ $< || exit 1; \
fi
efiemu64.o: efiemu64_c.o efiemu64_s.o $(TARGET_OBJ2ELEF)
-rm -f $@; \
if test "x$(TARGET_APPLE_CC)" = x1; then \
rm -f $@.bin; \
$(TARGET_CC) -m64 -Wl,-r -nostdlib -o $@.bin $^ || exit 1; \
$(OBJCONV) -felf64 -nu -nd $@.bin $@ || exit 1; \
rm -f $@.bin; \
else \
$(TARGET_CC) -m64 -nostdlib -Wl,-r -o $@ $^ || exit 1; \
if test ! -z "$(TARGET_OBJ2ELF)"; then $(TARGET_OBJ2ELF) $@ || (rm -f $@; exit 1); fi; \
fi
platform_DATA += efiemu32.o efiemu64.o
CLEANFILES += efiemu32.o efiemu64.o efiemu64_c.o efiemu64_s.o
endif
windowsdir=$(top_builddir)/$(PACKAGE)-$(VERSION)-for-windows
windowsdir: $(PROGRAMS) $(starfield_DATA) $(platform_DATA)
test -d $(windowsdir)/$(target_cpu)-$(platform) || mkdir $(windowsdir)/$(target_cpu)-$(platform)
for x in $(platform_DATA); do \
cp -fp $$x $(windowsdir)/$(target_cpu)-$(platform)/$$x; \
done

144
grub-core/Makefile.core.def
View File

@@ -59,17 +59,9 @@ kernel = {
ia64_efi_ldflags = '-Wl,-r,-d';
ia64_efi_stripflags = '--strip-unneeded -K start -R .note -R .comment -R .note.gnu.gold-version';
x86_64_xen_ldflags = '-Wl,-Ttext=0';
x86_64_xen_cppflags = '$(CPPFLAGS_XEN)';
i386_xen_ldflags = '-Wl,-Ttext=0';
i386_xen_cppflags = '$(CPPFLAGS_XEN)';
arm_efi_ldflags = '-Wl,-r,-d';
arm_efi_stripflags = '--strip-unneeded -K start -R .note -R .comment -R .note.gnu.gold-version';
arm64_efi_ldflags = '-Wl,-r,-d';
arm64_efi_stripflags = '--strip-unneeded -K start -R .note -R .comment -R .note.gnu.gold-version';
i386_pc_ldflags = '$(TARGET_IMG_LDFLAGS)';
i386_pc_ldflags = '$(TARGET_IMG_BASE_LDOPT),0x9000';
@@ -88,6 +80,7 @@ kernel = {
mips_qemu_mips_ldflags = '-Wl,-Ttext,0x80200000';
mips_arc_cppflags = '-DGRUB_DECOMPRESSOR_LINK_ADDR=$(TARGET_DECOMPRESSOR_LINK_ADDR)';
mips_loongson_cppflags = '-DUSE_ASCII_FALLBACK';
i386_qemu_cppflags = '-DGRUB_BOOT_MACHINE_LINK_ADDR=$(GRUB_BOOT_MACHINE_LINK_ADDR)';
emu_cflags = '$(CFLAGS_GNULIB)';
emu_cppflags = '$(CPPFLAGS_GNULIB)';
@@ -97,8 +90,6 @@ kernel = {
i386_pc_startup = kern/i386/pc/startup.S;
i386_efi_startup = kern/i386/efi/startup.S;
x86_64_efi_startup = kern/x86_64/efi/startup.S;
i386_xen_startup = kern/i386/xen/startup.S;
x86_64_xen_startup = kern/x86_64/xen/startup.S;
i386_qemu_startup = kern/i386/qemu/startup.S;
i386_ieee1275_startup = kern/i386/ieee1275/startup.S;
i386_coreboot_startup = kern/i386/coreboot/startup.S;
@@ -108,7 +99,6 @@ kernel = {
powerpc_ieee1275_startup = kern/powerpc/ieee1275/startup.S;
arm_uboot_startup = kern/arm/uboot/startup.S;
arm_efi_startup = kern/arm/efi/startup.S;
arm64_efi_startup = kern/arm64/efi/startup.S;
common = kern/command.c;
common = kern/corecmd.c;
@@ -156,7 +146,6 @@ kernel = {
terminfoinkernel = lib/arg.c;
i386 = kern/i386/dl.c;
i386_xen = kern/i386/dl.c;
i386_coreboot = kern/i386/coreboot/init.c;
i386_multiboot = kern/i386/coreboot/init.c;
@@ -175,20 +164,11 @@ kernel = {
i386_efi = kern/i386/efi/init.c;
i386_efi = bus/pci.c;
x86_64 = kern/x86_64/dl.c;
x86_64_xen = kern/x86_64/dl.c;
x86_64_efi = kern/x86_64/dl.c;
x86_64_efi = kern/x86_64/efi/callwrap.S;
x86_64_efi = kern/i386/efi/init.c;
x86_64_efi = bus/pci.c;
xen = kern/i386/tsc.c;
x86_64_xen = kern/x86_64/xen/hypercall.S;
i386_xen = kern/i386/xen/hypercall.S;
xen = kern/xen/init.c;
xen = term/xen/console.c;
xen = disk/xen/xendisk.c;
xen = commands/boot.c;
ia64_efi = kern/ia64/efi/startup.S;
ia64_efi = kern/ia64/efi/init.c;
ia64_efi = kern/ia64/dl.c;
@@ -197,8 +177,6 @@ kernel = {
arm_efi = kern/arm/efi/init.c;
arm_efi = kern/arm/efi/misc.c;
arm64_efi = kern/arm/efi/init.c;
i386_pc = kern/i386/pc/init.c;
i386_pc = kern/i386/pc/mmap.c;
i386_pc = term/i386/pc/console.c;
@@ -259,11 +237,6 @@ kernel = {
arm = kern/arm/cache.c;
arm = kern/arm/misc.S;
arm64 = kern/arm64/cache.c;
arm64 = kern/arm64/cache_flush.S;
arm64 = kern/arm64/dl.c;
arm64 = kern/arm64/dl_helper.c;
emu = disk/host.c;
emu = kern/emu/cache_s.S;
emu = kern/emu/hostdisk.c;
@@ -436,9 +409,9 @@ image = {
cppflags = '-I$(srcdir)/lib/posix_wrap -I$(srcdir)/lib/xzembed -DGRUB_EMBED_DECOMPRESSOR=1';
objcopyflags = '-O binary';
mips_ldflags = '$(TARGET_LDFLAGS_STATIC_LIBGCC) -Wl,-Ttext,$(TARGET_DECOMPRESSOR_LINK_ADDR)';
ldadd = '$(TARGET_LIBGCC)';
cflags = '-Wno-unreachable-code $(TARGET_LDFLAGS_STATIC_LIBGCC)';
mips_ldflags = '-static-libgcc -Wl,-Ttext,$(TARGET_DECOMPRESSOR_LINK_ADDR)';
ldadd = '-lgcc';
cflags = '-Wno-unreachable-code -static-libgcc';
enable = mips;
};
@@ -450,9 +423,9 @@ image = {
cppflags = '-DGRUB_EMBED_DECOMPRESSOR=1';
objcopyflags = '-O binary';
mips_ldflags = '$(TARGET_LDFLAGS_STATIC_LIBGCC) -Wl,-Ttext,$(TARGET_DECOMPRESSOR_LINK_ADDR)';
ldadd = '$(TARGET_LIBGCC)';
cflags = '$(TARGET_LDFLAGS_STATIC_LIBGCC)';
mips_ldflags = '-static-libgcc -Wl,-Ttext,$(TARGET_DECOMPRESSOR_LINK_ADDR)';
ldadd = '-lgcc';
cflags = '-static-libgcc';
enable = mips;
};
@@ -470,7 +443,7 @@ image = {
name = fwstart;
mips_loongson = boot/mips/loongson/fwstart.S;
objcopyflags = '-O binary';
ldflags = '$(TARGET_LDFLAGS_STATIC_LIBGCC) $(TARGET_LIBGCC) -Wl,-N,-S,-Ttext,0xbfc00000,-Bstatic';
ldflags = '-static-libgcc -lgcc -Wl,-N,-S,-Ttext,0xbfc00000,-Bstatic';
enable = mips_loongson;
};
@@ -478,14 +451,13 @@ image = {
name = fwstart_fuloong2f;
mips_loongson = boot/mips/loongson/fuloong2f.S;
objcopyflags = '-O binary';
ldflags = '$(TARGET_LDFLAGS_STATIC_LIBGCC) $(TARGET_LIBGCC) -Wl,-N,-S,-Ttext,0xbfc00000,-Bstatic';
ldflags = '-static-libgcc -lgcc -Wl,-N,-S,-Ttext,0xbfc00000,-Bstatic';
enable = mips_loongson;
};
module = {
name = disk;
common = lib/disk.c;
extra_dist = kern/disk_common.c;
};
module = {
@@ -524,7 +496,6 @@ module = {
module = {
name = emuusb;
common = bus/usb/usb.c;
enable = emu;
condition = COND_GRUB_EMU_USB;
};
@@ -573,7 +544,6 @@ module = {
module = {
name = pci;
common = bus/pci.c;
i386_ieee1275 = bus/i386/ieee1275/pci.c;
enable = i386_pc;
enable = i386_ieee1275;
@@ -595,7 +565,6 @@ module = {
common = bus/emu/pci.c;
common = commands/lspci.c;
enable = emu;
condition = COND_GRUB_EMU_PCI;
};
@@ -606,17 +575,11 @@ module = {
enable = mips_arc;
};
module = {
name = lsxen;
common = commands/xen/lsxen.c;
cppflags = '$(CPPFLAGS_XEN)';
enable = xen;
};
module = {
name = check_nt_hiberfil;
common = commands/i386/nthibr.c;
library = {
name = libgnulib.a;
common = gnulib/regex.c;
cflags = '$(CFLAGS_POSIX) $(CFLAGS_GNULIB)';
cppflags = '$(CPPFLAGS_POSIX) $(CPPFLAGS_GNULIB)';
};
module = {
@@ -670,7 +633,8 @@ module = {
name = regexp;
common = commands/regexp.c;
common = commands/wildcard.c;
common = gnulib/regex.c;
ldadd = libgnulib.a;
dependencies = libgnulib.a;
cflags = '$(CFLAGS_POSIX) $(CFLAGS_GNULIB)';
cppflags = '$(CPPFLAGS_POSIX) $(CPPFLAGS_GNULIB)';
};
@@ -753,7 +717,6 @@ module = {
enable = mips_arc;
enable = ia64_efi;
enable = arm_efi;
enable = arm64_efi;
enable = arm_uboot;
};
@@ -774,10 +737,8 @@ module = {
module = {
name = cpuid;
common = commands/i386/cpuid.c;
x86 = commands/i386/cpuid.c;
enable = x86;
enable = i386_xen;
enable = x86_64_xen;
};
module = {
@@ -834,8 +795,6 @@ module = {
i386_multiboot = lib/i386/halt.c;
i386_coreboot = lib/i386/halt.c;
i386_qemu = lib/i386/halt.c;
xen = lib/xen/halt.c;
xen_cppflags = '$(CPPFLAGS_XEN)';
efi = lib/efi/halt.c;
ieee1275 = lib/ieee1275/halt.c;
emu = lib/emu/halt.c;
@@ -849,14 +808,11 @@ module = {
ia64_efi = lib/efi/reboot.c;
x86_64_efi = lib/efi/reboot.c;
arm_efi = lib/efi/reboot.c;
arm64_efi = lib/efi/reboot.c;
powerpc_ieee1275 = lib/ieee1275/reboot.c;
sparc64_ieee1275 = lib/ieee1275/reboot.c;
mips_arc = lib/mips/arc/reboot.c;
mips_loongson = lib/mips/loongson/reboot.c;
mips_qemu_mips = lib/mips/qemu_mips/reboot.c;
xen = lib/xen/reboot.c;
xen_cppflags = '$(CPPFLAGS_XEN)';
uboot = lib/uboot/reboot.c;
common = commands/reboot.c;
};
@@ -1480,11 +1436,6 @@ module = {
common = io/gzio.c;
};
module = {
name = offsetio;
common = io/offset.c;
};
module = {
name = bufio;
common = io/bufio.c;
@@ -1518,21 +1469,13 @@ module = {
x86 = lib/i386/relocator64.S;
i386 = lib/i386/relocator_asm.S;
x86_64 = lib/x86_64/relocator_asm.S;
i386_xen = lib/i386/relocator_asm.S;
x86_64_xen = lib/x86_64/relocator_asm.S;
x86 = lib/i386/relocator.c;
x86 = lib/i386/relocator_common_c.c;
ieee1275 = lib/ieee1275/relocator.c;
efi = lib/efi/relocator.c;
mips = lib/mips/relocator_asm.S;
mips = lib/mips/relocator.c;
powerpc = lib/powerpc/relocator_asm.S;
powerpc = lib/powerpc/relocator.c;
xen = lib/xen/relocator.c;
i386_xen = lib/i386/xen/relocator.S;
x86_64_xen = lib/x86_64/xen/relocator.S;
xen = lib/i386/relocator_common_c.c;
xen_cppflags = '$(CPPFLAGS_XEN)';
extra_dist = lib/i386/relocator_common.S;
extra_dist = kern/powerpc/cache_flush.S;
@@ -1540,7 +1483,6 @@ module = {
enable = mips;
enable = powerpc;
enable = x86;
enable = xen;
};
module = {
@@ -1552,8 +1494,6 @@ module = {
powerpc_ieee1275 = lib/ieee1275/datetime.c;
sparc64_ieee1275 = lib/ieee1275/cmos.c;
powerpc_ieee1275 = lib/ieee1275/cmos.c;
xen = lib/xen/datetime.c;
xen_cppflags = '$(CPPFLAGS_XEN)';
mips_arc = lib/arc/datetime.c;
enable = noemu;
@@ -1570,7 +1510,6 @@ module = {
extra_dist = lib/ia64/setjmp.S;
extra_dist = lib/ia64/longjmp.S;
extra_dist = lib/arm/setjmp.S;
extra_dist = lib/arm64/setjmp.S;
};
module = {
@@ -1629,7 +1568,6 @@ module = {
cppflags = "-DGRUB_USE_MULTIBOOT2";
common = loader/multiboot.c;
common = lib/cmdline.c;
common = loader/multiboot_mbi2.c;
enable = x86;
enable = mips;
@@ -1638,7 +1576,6 @@ module = {
module = {
name = multiboot;
common = loader/multiboot.c;
common = lib/cmdline.c;
x86 = loader/i386/multiboot_mbi.c;
extra_dist = loader/multiboot_elfxx.c;
enable = x86;
@@ -1647,12 +1584,6 @@ module = {
module = {
name = linux;
x86 = loader/i386/linux.c;
xen = loader/i386/xen.c;
xen = loader/i386/xen_file.c;
xen = loader/i386/xen_file32.c;
xen = loader/i386/xen_file64.c;
extra_dist = loader/i386/xen_fileXX.c;
xen_cppflags = '$(CPPFLAGS_XEN)';
i386_pc = lib/i386/pc/vesa_modes_table.c;
mips = loader/mips/linux.c;
powerpc_ieee1275 = loader/powerpc/ieee1275/linux.c;
@@ -1691,7 +1622,6 @@ module = {
efi = loader/efi/chainloader.c;
i386_pc = loader/i386/pc/chainloader.c;
i386_coreboot = loader/i386/coreboot/chainloader.c;
i386_coreboot = lib/LzmaDec.c;
enable = i386_pc;
enable = i386_coreboot;
enable = efi;
@@ -1713,7 +1643,6 @@ module = {
enable = x86;
enable = ia64_efi;
enable = arm_efi;
enable = arm64_efi;
enable = mips;
};
@@ -1918,37 +1847,6 @@ module = {
common = tests/setjmp_test.c;
};
module = {
name = signature_test;
common = tests/signature_test.c;
common = tests/signatures.h;
};
module = {
name = xnu_uuid_test;
common = tests/xnu_uuid_test.c;
};
module = {
name = pbkdf2_test;
common = tests/pbkdf2_test.c;
};
module = {
name = legacy_password_test;
common = tests/legacy_password_test.c;
enable = i386_pc;
enable = i386_efi;
enable = x86_64_efi;
enable = emu;
enable = xen;
};
module = {
name = div_test;
common = tests/div_test.c;
};
module = {
name = videotest_checksum;
common = tests/videotest_checksum.c;
@@ -2102,13 +2000,11 @@ module = {
emu = lib/i386/pc/vesa_modes_table.c;
i386_efi = lib/i386/pc/vesa_modes_table.c;
x86_64_efi = lib/i386/pc/vesa_modes_table.c;
xen = lib/i386/pc/vesa_modes_table.c;
enable = i386_pc;
enable = i386_efi;
enable = x86_64_efi;
enable = emu;
enable = xen;
};
module = {
@@ -2142,12 +2038,8 @@ module = {
module = {
name = backtrace;
x86 = lib/i386/backtrace.c;
i386_xen = lib/i386/backtrace.c;
x86_64_xen = lib/i386/backtrace.c;
common = lib/backtrace.c;
enable = x86;
enable = i386_xen;
enable = x86_64_xen;
};
module = {

48
grub-core/boot/i386/pc/boot.S
View File

@@ -31,32 +31,27 @@
.macro floppy
part_start:
LOCAL(probe_values):
probe_values:
.byte 36, 18, 15, 9, 0
LOCAL(floppy_probe):
pushw %dx
/*
* Perform floppy probe.
*/
#ifdef __APPLE__
LOCAL(probe_values_minus_one) = LOCAL(probe_values) - 1
movw MACRO_DOLLAR(LOCAL(probe_values_minus_one)), %si
#else
movw MACRO_DOLLAR(LOCAL(probe_values)) - 1, %si
#endif
movw $probe_values - 1, %si
LOCAL(probe_loop):
/* reset floppy controller INT 13h AH=0 */
xorw %ax, %ax
int MACRO_DOLLAR(0x13)
int $0x13
incw %si
movb (%si), %cl
/* if number of sectors is 0, display error and die */
testb %cl, %cl
jnz 1f
cmpb $0, %cl
jne 1f
/*
* Floppy disk probe failure.
@@ -69,20 +64,20 @@ fd_probe_error_string: .asciz "Floppy"
1:
/* perform read */
movw MACRO_DOLLAR(GRUB_BOOT_MACHINE_BUFFER_SEG), %bx
movw $GRUB_BOOT_MACHINE_BUFFER_SEG, %bx
movw %bx, %es
xorw %bx, %bx
movw MACRO_DOLLAR(0x201), %ax
movb MACRO_DOLLAR(0), %ch
movb MACRO_DOLLAR(0), %dh
int MACRO_DOLLAR(0x13)
movw $0x201, %ax
movb $0, %ch
movb $0, %dh
int $0x13
/* if error, jump to "LOCAL(probe_loop)" */
jc LOCAL(probe_loop)
/* %cl is already the correct value! */
movb MACRO_DOLLAR(1), %dh
movb MACRO_DOLLAR(79), %ch
movb $1, %dh
movb $79, %ch
jmp LOCAL(final_init)
.endm
@@ -185,9 +180,7 @@ kernel_address:
#ifndef HYBRID_BOOT
. = _start + GRUB_BOOT_MACHINE_KERNEL_SECTOR
kernel_sector:
.long 1
kernel_sector_high:
.long 0
.long 1, 0
#endif
. = _start + GRUB_BOOT_MACHINE_BOOT_DRIVE
@@ -292,7 +285,7 @@ lba_mode:
/* the absolute address */
movl kernel_sector, %ebx
movl %ebx, 8(%si)
movl kernel_sector_high, %ebx
movl kernel_sector + 4, %ebx
movl %ebx, 12(%si)
/* the segment of buffer address */
@@ -325,12 +318,11 @@ LOCAL(chs_mode):
int $0x13
jnc LOCAL(final_init)
popw %dx
/*
* The call failed, so maybe use the floppy probe instead.
*/
testb %dl, %dl
jnb LOCAL(floppy_probe)
testb $GRUB_BOOT_MACHINE_BIOS_HD_FLAG, %dl
jz LOCAL(floppy_probe)
/* Nope, we definitely have a hard disk, and we're screwed. */
ERR(hd_probe_error_string)
@@ -361,7 +353,7 @@ LOCAL(final_init):
setup_sectors:
/* load logical sector start (top half) */
movl kernel_sector_high, %eax
movl kernel_sector + 4, %eax
orl %eax, %eax
jnz LOCAL(geometry_error)
@@ -513,9 +505,7 @@ LOCAL(message):
#ifdef HYBRID_BOOT
. = _start + 0x1b0
kernel_sector:
.long 1
kernel_sector_high:
.long 0
.long 1, 0
#endif
. = _start + GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC
nt_magic:

1
grub-core/boot/i386/qemu/boot.S
View File

@@ -18,6 +18,7 @@
#include <config.h>
#include <grub/symbol.h>
#include <grub/i386/pc/memory.h>
#include <grub/machine/memory.h>
#include <grub/machine/boot.h>
#include <grub/machine/kernel.h>

22
grub-core/boot/mips/startup_raw.S
View File

@@ -27,7 +27,6 @@
.extern __bss_start
.extern _end
.extern _edata
.globl __start, _start, start
.set noreorder
@@ -249,9 +248,8 @@ cmdlinedone:
#include "../../kern/mips/cache_flush.S"
/* Decompress the payload. */
lui $a0, %hi(_edata)
addiu $a0, $a0, %lo(_edata)
lui $a0, %hi(__bss_start)
addiu $a0, $a0, %lo(__bss_start)
lui $t0, %hi(base)
addiu $t0, $t0, %lo(base)
subu $a0, $a0, $t0
@@ -267,16 +265,16 @@ cmdlinedone:
*/
move $s6, $a3
lui $t9, %hi(EXT_C(grub_decompress_core))
addiu $t9, $t9, %lo(EXT_C(grub_decompress_core))
lui $t0, %hi(EXT_C(grub_decompress_core))
addiu $t0, $t0, %lo(EXT_C(grub_decompress_core))
#ifdef GRUB_MACHINE_ARC
lui $sp, %hi(_start - 512)
jalr $t9
jalr $t0
addiu $sp, $sp, %lo(_start - 512)
#else
lui $sp, %hi(_start - 256)
jalr $t9
jalr $t0
addiu $sp, $sp, %lo(_start - 256)
#endif
move $a0, $s1
@@ -289,11 +287,3 @@ cmdlinedone:
jr $t1
nop
/* Ensure that .data section is created. In code we suppose that _edata
is first location not in decompressor image. Strictly speaking it's
_edata only when .data is present and _etext otherwise. But checking
for .data presence would cost more in code than it is to ensure that
.data is created.
*/
.data
.long 0

6
grub-core/boot/sparc64/ieee1275/boot.S
View File

@@ -48,7 +48,7 @@ kernel_byte: .xword (2 << 9)
boot_path_end:
kernel_address: .word GRUB_BOOT_MACHINE_KERNEL_ADDR
#else
#define boot_path (_start + 512 + SCRATCH_PAD_BOOT_SIZE)
#define boot_path (_start + 512)
#define boot_path_end (_start + 1024)
#include <grub/offsets.h>
@@ -140,11 +140,7 @@ prom_call:
boot_continue:
mov %o7, PIC_REG /* PIC base */
#ifndef CDBOOT
sethi %hi(SCRATCH_PAD_BOOT), %l1 /* OF argument slots */
#else
GET_ABS(_start + 512, %l1) /* OF argument slots */
#endif
/* Find the /chosen node so we can fetch the stdout handle,
* and thus perform console output.

42
grub-core/bus/i386/ieee1275/pci.c
View File

@@ -1,42 +0,0 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2013 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/dl.h>
#include <grub/pci.h>
#include <grub/mm.h>
#include <grub/misc.h>
#include <grub/ieee1275/ieee1275.h>
volatile void *
grub_pci_device_map_range (grub_pci_device_t dev __attribute__ ((unused)),
grub_addr_t base,
grub_size_t size)
{
if (grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_REAL_MODE))
return (volatile void *) base;
if (grub_ieee1275_map (base, base, size, 7))
grub_fatal ("couldn't map 0x%lx", base);
return (volatile void *) base;
}
void
grub_pci_device_unmap_range (grub_pci_device_t dev __attribute__ ((unused)),
volatile void *mem __attribute__ ((unused)),
grub_size_t size __attribute__ ((unused)))
{
}

26
grub-core/bus/usb/ehci.c
View File

@@ -534,20 +534,11 @@ grub_ehci_pci_iter (grub_pci_device_t dev, grub_pci_id_t pciid,
"EHCI grub_ehci_pci_iter: registers above 4G are not supported\n");
return 0;
}
base &= GRUB_PCI_ADDR_MEM_MASK;
if (!base)
{
grub_dprintf ("ehci",
"EHCI: EHCI is not mapped\n");
return 0;
}
/* Set bus master - needed for coreboot, VMware, broken BIOSes etc. */
addr = grub_pci_make_address (dev, GRUB_PCI_REG_COMMAND);
grub_pci_write_word(addr,
GRUB_PCI_COMMAND_MEM_ENABLED
| GRUB_PCI_COMMAND_BUS_MASTER
| grub_pci_read_word(addr));
GRUB_PCI_COMMAND_BUS_MASTER | grub_pci_read_word(addr));
grub_dprintf ("ehci", "EHCI grub_ehci_pci_iter: 32-bit EHCI OK\n");
}
@@ -1686,7 +1677,7 @@ grub_ehci_hubports (grub_usb_controller_t dev)
return portinfo;
}
static grub_usb_err_t
static grub_err_t
grub_ehci_portstatus (grub_usb_controller_t dev,
unsigned int port, unsigned int enable)
{
@@ -1708,14 +1699,14 @@ grub_ehci_portstatus (grub_usb_controller_t dev,
endtime = grub_get_time_ms () + 1000;
while (grub_ehci_port_read (e, port) & GRUB_EHCI_PORT_ENABLED)
if (grub_get_time_ms () > endtime)
return GRUB_USB_ERR_TIMEOUT;
return grub_error (GRUB_ERR_IO, "portstatus: EHCI Timed out - disable");
if (!enable) /* We don't need reset port */
{
grub_dprintf ("ehci", "portstatus: Disabled.\n");
grub_dprintf ("ehci", "portstatus: end, status=0x%02x\n",
grub_ehci_port_read (e, port));
return GRUB_USB_ERR_NONE;
return GRUB_ERR_NONE;
}
grub_dprintf ("ehci", "portstatus: enable\n");
@@ -1733,7 +1724,8 @@ grub_ehci_portstatus (grub_usb_controller_t dev,
endtime = grub_get_time_ms () + 1000;
while (grub_ehci_port_read (e, port) & GRUB_EHCI_PORT_RESET)
if (grub_get_time_ms () > endtime)
return GRUB_USB_ERR_TIMEOUT;
return grub_error (GRUB_ERR_IO,
"portstatus: EHCI Timed out - reset port");
grub_boot_time ("Port %d reset", port);
/* Remember "we did the reset" - needed by detect_dev */
e->reset |= (1 << port);
@@ -1761,7 +1753,7 @@ grub_ehci_portstatus (grub_usb_controller_t dev,
grub_dprintf ("ehci", "portstatus: end, status=0x%02x\n",
grub_ehci_port_read (e, port));
return GRUB_USB_ERR_NONE;
return GRUB_ERR_NONE;
}
static grub_usb_speed_t
@@ -1896,7 +1888,7 @@ grub_ehci_restore_hw (void)
}
}
return GRUB_ERR_NONE;
return GRUB_USB_ERR_NONE;
}
static grub_err_t
@@ -1919,7 +1911,7 @@ grub_ehci_fini_hw (int noreturn __attribute__ ((unused)))
grub_ehci_reset (e);
}
return GRUB_ERR_NONE;
return GRUB_USB_ERR_NONE;
}
static struct grub_usb_controller_dev usb_controller = {

28
grub-core/bus/usb/ohci.c
View File

@@ -265,20 +265,16 @@ grub_ohci_pci_iter (grub_pci_device_t dev, grub_pci_id_t pciid,
addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESS_REG0);
base = grub_pci_read (addr);
base &= GRUB_PCI_ADDR_MEM_MASK;
if (!base)
{
grub_dprintf ("ehci",
"EHCI: EHCI is not mapper\n");
return 0;
}
#if 0
/* Stop if there is no IO space base address defined. */
if (! (base & 1))
return 0;
#endif
/* Set bus master - needed for coreboot, VMware, broken BIOSes etc. */
addr = grub_pci_make_address (dev, GRUB_PCI_REG_COMMAND);
grub_pci_write_word(addr,
GRUB_PCI_COMMAND_MEM_ENABLED
| GRUB_PCI_COMMAND_BUS_MASTER
| grub_pci_read_word(addr));
GRUB_PCI_COMMAND_BUS_MASTER | grub_pci_read_word(addr));
grub_dprintf ("ohci", "class=0x%02x 0x%02x interface 0x%02x\n",
class, subclass, interf);
@@ -1220,7 +1216,7 @@ grub_ohci_cancel_transfer (grub_usb_controller_t dev,
return GRUB_USB_ERR_NONE;
}
static grub_usb_err_t
static grub_err_t
grub_ohci_portstatus (grub_usb_controller_t dev,
unsigned int port, unsigned int enable)
{
@@ -1240,11 +1236,11 @@ grub_ohci_portstatus (grub_usb_controller_t dev,
while ((grub_ohci_readreg32 (o, GRUB_OHCI_REG_RHUBPORT + port)
& (1 << 1)))
if (grub_get_time_ms () > endtime)
return GRUB_USB_ERR_TIMEOUT;
return grub_error (GRUB_ERR_IO, "OHCI Timed out - disable");
grub_dprintf ("ohci", "end of portstatus=0x%02x\n",
grub_ohci_readreg32 (o, GRUB_OHCI_REG_RHUBPORT + port));
return GRUB_USB_ERR_NONE;
return GRUB_ERR_NONE;
}
/* OHCI does one reset signal 10ms long but USB spec.
@@ -1261,7 +1257,7 @@ grub_ohci_portstatus (grub_usb_controller_t dev,
while (! (grub_ohci_readreg32 (o, GRUB_OHCI_REG_RHUBPORT + port)
& GRUB_OHCI_SET_PORT_RESET_STATUS_CHANGE))
if (grub_get_time_ms () > endtime)
return GRUB_USB_ERR_TIMEOUT;
return grub_error (GRUB_ERR_IO, "OHCI Timed out - reset");
/* End the reset signaling - reset the reset status change */
grub_ohci_writereg32 (o, GRUB_OHCI_REG_RHUBPORT + port,
@@ -1279,7 +1275,7 @@ grub_ohci_portstatus (grub_usb_controller_t dev,
while (! (grub_ohci_readreg32 (o, GRUB_OHCI_REG_RHUBPORT + port)
& (1 << 1)))
if (grub_get_time_ms () > endtime)
return GRUB_USB_ERR_TIMEOUT;
return grub_error (GRUB_ERR_IO, "OHCI Timed out - enable");
/* Reset bit Connect Status Change */
grub_ohci_writereg32 (o, GRUB_OHCI_REG_RHUBPORT + port,
@@ -1291,7 +1287,7 @@ grub_ohci_portstatus (grub_usb_controller_t dev,
grub_dprintf ("ohci", "end of portstatus=0x%02x\n",
grub_ohci_readreg32 (o, GRUB_OHCI_REG_RHUBPORT + port));
return GRUB_USB_ERR_NONE;
return GRUB_ERR_NONE;
}
static grub_usb_speed_t

6
grub-core/bus/usb/serial/ftdi.c
View File

@@ -91,13 +91,11 @@ real_config (struct grub_serial_port *port)
grub_usb_control_msg (port->usbdev, GRUB_USB_REQTYPE_VENDOR_OUT,
GRUB_FTDI_MODEM_CTRL,
port->config.rtscts ? GRUB_FTDI_MODEM_CTRL_DTRRTS : 0,
0, 0, 0);
GRUB_FTDI_MODEM_CTRL_DTRRTS, 0, 0, 0);
grub_usb_control_msg (port->usbdev, GRUB_USB_REQTYPE_VENDOR_OUT,
GRUB_FTDI_FLOW_CTRL,
port->config.rtscts ? GRUB_FTDI_FLOW_CTRL_DTRRTS : 0,
0, 0, 0);
GRUB_FTDI_FLOW_CTRL_DTRRTS, 0, 0, 0);
divisor = get_divisor (port->config.speed);
grub_usb_control_msg (port->usbdev, GRUB_USB_REQTYPE_VENDOR_OUT,

2
grub-core/bus/usb/serial/pl2303.c
View File

@@ -125,7 +125,7 @@ real_config (struct grub_serial_port *port)
0x22, 3, 0, 0, 0);
grub_usb_control_msg (port->usbdev, GRUB_USB_REQTYPE_VENDOR_OUT,
1, 0, port->config.rtscts ? 0x61 : 0, 0, 0);
1, 0, 0x61, 0, 0);
port->configured = 1;
}

31
grub-core/bus/usb/uhci.c
View File

@@ -189,6 +189,11 @@ grub_uhci_writereg32 (struct grub_uhci *u,
grub_outl (val, u->iobase + reg);
}
static grub_err_t
grub_uhci_portstatus (grub_usb_controller_t dev,
unsigned int port, unsigned int enable);
/* Iterate over all PCI devices. Determine if a device is an UHCI
controller. If this is the case, initialize it. */
static int
@@ -217,6 +222,12 @@ grub_uhci_pci_iter (grub_pci_device_t dev,
if (class != 0x0c || subclass != 0x03 || interf != 0x00)
return 0;
/* Set bus master - needed for coreboot or broken BIOSes */
addr = grub_pci_make_address (dev, GRUB_PCI_REG_COMMAND);
grub_pci_write_word(addr, GRUB_PCI_COMMAND_IO_ENABLED
| GRUB_PCI_COMMAND_BUS_MASTER
| grub_pci_read_word (addr));
/* Determine IO base address. */
addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESS_REG4);
base = grub_pci_read (addr);
@@ -227,13 +238,6 @@ grub_uhci_pci_iter (grub_pci_device_t dev,
if ((base & GRUB_UHCI_IOMASK) == 0)
return 0;
/* Set bus master - needed for coreboot or broken BIOSes */
addr = grub_pci_make_address (dev, GRUB_PCI_REG_COMMAND);
grub_pci_write_word(addr, GRUB_PCI_COMMAND_IO_ENABLED
| GRUB_PCI_COMMAND_BUS_MASTER
| GRUB_PCI_COMMAND_MEM_ENABLED
| grub_pci_read_word (addr));
grub_dprintf ("uhci", "base = %x\n", base);
/* Allocate memory for the controller and register it. */
@@ -711,7 +715,7 @@ grub_uhci_iterate (grub_usb_controller_iterate_hook_t hook, void *hook_data)
return 0;
}
static grub_usb_err_t
static grub_err_t
grub_uhci_portstatus (grub_usb_controller_t dev,
unsigned int port, unsigned int enable)
{
@@ -729,7 +733,8 @@ grub_uhci_portstatus (grub_usb_controller_t dev,
else if (port == 1)
reg = GRUB_UHCI_REG_PORTSC2;
else
return GRUB_USB_ERR_INTERNAL;
return grub_error (GRUB_ERR_OUT_OF_RANGE,
"UHCI Root Hub port does not exist");
status = grub_uhci_readreg16 (u, reg);
grub_dprintf ("uhci", "detect=0x%02x\n", status);
@@ -742,11 +747,11 @@ grub_uhci_portstatus (grub_usb_controller_t dev,
endtime = grub_get_time_ms () + 1000;
while ((grub_uhci_readreg16 (u, reg) & (1 << 2)))
if (grub_get_time_ms () > endtime)
return GRUB_USB_ERR_TIMEOUT;
return grub_error (GRUB_ERR_IO, "UHCI Timed out - disable");
status = grub_uhci_readreg16 (u, reg);
grub_dprintf ("uhci", ">3detect=0x%02x\n", status);
return GRUB_USB_ERR_NONE;
return GRUB_ERR_NONE;
}
/* Reset the port. */
@@ -777,7 +782,7 @@ grub_uhci_portstatus (grub_usb_controller_t dev,
endtime = grub_get_time_ms () + 1000;
while (! ((status = grub_uhci_readreg16 (u, reg)) & (1 << 2)))
if (grub_get_time_ms () > endtime)
return GRUB_USB_ERR_TIMEOUT;
return grub_error (GRUB_ERR_IO, "UHCI Timed out - enable");
/* Reset recovery time */
grub_millisleep (10);
@@ -787,7 +792,7 @@ grub_uhci_portstatus (grub_usb_controller_t dev,
grub_dprintf ("uhci", ">3detect=0x%02x\n", status);
return GRUB_USB_ERR_NONE;
return GRUB_ERR_NONE;
}
static grub_usb_speed_t

4
grub-core/bus/usb/usbhub.c
View File

@@ -195,7 +195,7 @@ grub_usb_add_hub (grub_usb_device_t dev)
rescan = 1;
return GRUB_USB_ERR_NONE;
return GRUB_ERR_NONE;
}
static void
@@ -203,7 +203,7 @@ attach_root_port (struct grub_usb_hub *hub, int portno,
grub_usb_speed_t speed)
{
grub_usb_device_t dev;
grub_usb_err_t err;
grub_err_t err;
grub_boot_time ("After detect_dev");

38
grub-core/commands/blocklist.c
View File

@@ -62,47 +62,23 @@ read_blocklist (grub_disk_addr_t sector, unsigned offset, unsigned length,
if (ctx->num_sectors > 0)
{
if (ctx->start_sector + ctx->num_sectors == sector
&& offset == 0 && length >= GRUB_DISK_SECTOR_SIZE)
&& offset == 0 && length == GRUB_DISK_SECTOR_SIZE)
{
ctx->num_sectors += length >> GRUB_DISK_SECTOR_BITS;
sector += length >> GRUB_DISK_SECTOR_BITS;
length &= (GRUB_DISK_SECTOR_SIZE - 1);
ctx->num_sectors++;
return;
}
if (!length)
return;
print_blocklist (ctx->start_sector, ctx->num_sectors, 0, 0, ctx);
ctx->num_sectors = 0;
}
if (offset)
{
unsigned l = length + offset;
l &= (GRUB_DISK_SECTOR_SIZE - 1);
l -= offset;
print_blocklist (sector, 0, offset, l, ctx);
length -= l;
sector++;
offset = 0;
}
if (!length)
return;
if (length & (GRUB_DISK_SECTOR_SIZE - 1))
{
if (length >> GRUB_DISK_SECTOR_BITS)
{
print_blocklist (sector, length >> GRUB_DISK_SECTOR_BITS, 0, 0, ctx);
sector += length >> GRUB_DISK_SECTOR_BITS;
}
print_blocklist (sector, 0, 0, length & (GRUB_DISK_SECTOR_SIZE - 1), ctx);
}
else
if (offset == 0 && length == GRUB_DISK_SECTOR_SIZE)
{
ctx->start_sector = sector;
ctx->num_sectors = length >> GRUB_DISK_SECTOR_BITS;
ctx->num_sectors++;
}
else
print_blocklist (sector, 0, offset, length, ctx);
}
static grub_err_t

3
grub-core/commands/boot.c
View File

@@ -146,7 +146,8 @@ grub_loader_boot (void)
return grub_error (GRUB_ERR_NO_KERNEL,
N_("you need to load the kernel first"));
grub_machine_fini (grub_loader_flags);
if (grub_loader_flags & GRUB_LOADER_FLAG_NORETURN)
grub_machine_fini ();
for (cur = preboots_head; cur; cur = cur->next)
{

36
grub-core/commands/hashsum.c
View File

@@ -63,23 +63,17 @@ hextoval (char c)
static grub_err_t
hash_file (grub_file_t file, const gcry_md_spec_t *hash, void *result)
{
void *context;
grub_uint8_t *readbuf;
#define BUF_SIZE 4096
readbuf = grub_malloc (BUF_SIZE);
if (!readbuf)
return grub_errno;
context = grub_zalloc (hash->contextsize);
if (!readbuf || !context)
goto fail;
GRUB_PROPERLY_ALIGNED_ARRAY (context, hash->contextsize);
grub_uint8_t readbuf[4096];
grub_memset (context, 0, sizeof (context));
hash->init (context);
while (1)
{
grub_ssize_t r;
r = grub_file_read (file, readbuf, BUF_SIZE);
r = grub_file_read (file, readbuf, sizeof (readbuf));
if (r < 0)
goto fail;
return grub_errno;
if (r == 0)
break;
hash->write (context, readbuf, r);
@@ -87,15 +81,7 @@ hash_file (grub_file_t file, const gcry_md_spec_t *hash, void *result)
hash->final (context);
grub_memcpy (result, hash->read (context), hash->mdlen);
grub_free (readbuf);
grub_free (context);
return GRUB_ERR_NONE;
fail:
grub_free (readbuf);
grub_free (context);
return grub_errno;
}
static grub_err_t
@@ -104,15 +90,12 @@ check_list (const gcry_md_spec_t *hash, const char *hashfilename,
{
grub_file_t hashlist, file;
char *buf = NULL;
grub_uint8_t expected[GRUB_CRYPTO_MAX_MDLEN];
grub_uint8_t actual[GRUB_CRYPTO_MAX_MDLEN];
grub_uint8_t expected[hash->mdlen];
grub_uint8_t actual[hash->mdlen];
grub_err_t err;
unsigned i;
unsigned unread = 0, mismatch = 0;
if (hash->mdlen > GRUB_CRYPTO_MAX_MDLEN)
return grub_error (GRUB_ERR_BUG, "mdlen is too long");
hashlist = grub_file_open (hashfilename);
if (!hashlist)
return grub_errno;
@@ -222,9 +205,6 @@ grub_cmd_hashsum (struct grub_extcmd_context *ctxt,
if (!hash)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "unknown hash");
if (hash->mdlen > GRUB_CRYPTO_MAX_MDLEN)
return grub_error (GRUB_ERR_BUG, "mdlen is too long");
if (state[2].set)
prefix = state[2].arg;
@@ -238,7 +218,7 @@ grub_cmd_hashsum (struct grub_extcmd_context *ctxt,
for (i = 0; i < (unsigned) argc; i++)
{
GRUB_PROPERLY_ALIGNED_ARRAY (result, GRUB_CRYPTO_MAX_MDLEN);
GRUB_PROPERLY_ALIGNED_ARRAY (result, hash->mdlen);
grub_file_t file;
grub_err_t err;
unsigned j;

24
grub-core/commands/i386/cmostest.c
View File

@@ -81,25 +81,7 @@ grub_cmd_cmosclean (struct grub_command *cmd __attribute__ ((unused)),
return grub_cmos_write (byte, value & (~(1 << bit)));
}
static grub_err_t
grub_cmd_cmosset (struct grub_command *cmd __attribute__ ((unused)),
int argc, char *argv[])
{
int byte, bit;
grub_err_t err;
grub_uint8_t value;
err = parse_args (argc, argv, &byte, &bit);
if (err)
return err;
err = grub_cmos_read (byte, &value);
if (err)
return err;
return grub_cmos_write (byte, value | (1 << bit));
}
static grub_command_t cmd, cmd_clean, cmd_set;
static grub_command_t cmd, cmd_clean;
GRUB_MOD_INIT(cmostest)
@@ -110,14 +92,10 @@ GRUB_MOD_INIT(cmostest)
cmd_clean = grub_register_command ("cmosclean", grub_cmd_cmosclean,
N_("BYTE:BIT"),
N_("Clean bit at BYTE:BIT in CMOS."));
cmd_set = grub_register_command ("cmosset", grub_cmd_cmosset,
N_("BYTE:BIT"),
N_("Set bit at BYTE:BIT in CMOS."));
}
GRUB_MOD_FINI(cmostest)
{
grub_unregister_command (cmd);
grub_unregister_command (cmd_clean);
grub_unregister_command (cmd_set);
}

79
grub-core/commands/i386/nthibr.c
View File

@@ -1,79 +0,0 @@
/* nthibr.c - tests whether an MS Windows system partition is hibernated */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2013 Peter Lustig
* Copyright (C) 2013 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/types.h>
#include <grub/mm.h>
#include <grub/file.h>
#include <grub/misc.h>
#include <grub/dl.h>
#include <grub/command.h>
#include <grub/err.h>
#include <grub/i18n.h>
GRUB_MOD_LICENSE ("GPLv3+");
static grub_err_t
grub_cmd_nthibr (grub_command_t cmd __attribute__ ((unused)),
int argc, char **args)
{
grub_uint8_t hibr_file_magic[4];
grub_file_t hibr_file = 0;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
hibr_file = grub_file_open (args[0]);
if (!hibr_file)
return grub_errno;
/* Try to read magic number of 'hiberfil.sys' */
if (grub_file_read (hibr_file, hibr_file_magic,
sizeof (hibr_file_magic))
!= (grub_ssize_t) sizeof (hibr_file_magic))
{
if (!grub_errno)
grub_error (GRUB_ERR_TEST_FAILURE, "false");
goto exit;
}
if (!(grub_memcmp ("hibr", hibr_file_magic, sizeof (hibr_file_magic)) == 0
|| grub_memcmp ("HIBR", hibr_file_magic, sizeof (hibr_file_magic)) == 0))
grub_error (GRUB_ERR_TEST_FAILURE, "false");
exit:
grub_file_close (hibr_file);
return grub_errno;
}
static grub_command_t cmd;
GRUB_MOD_INIT (check_nt_hiberfil)
{
cmd = grub_register_command ("check_nt_hiberfil", grub_cmd_nthibr,
N_("FILE"),
N_("Test whether a hiberfil.sys is "
"in hibernated state."));
}
GRUB_MOD_FINI (check_nt_hiberfil)
{
grub_unregister_command (cmd);
}

63
grub-core/commands/legacycfg.c
View File

@@ -358,7 +358,7 @@ grub_cmd_legacy_kernel (struct grub_command *mycmd __attribute__ ((unused)),
dev = grub_device_open (0);
if (dev && dev->disk
&& dev->disk->dev->id == GRUB_DISK_DEVICE_BIOSDISK_ID
&& dev->disk->id >= 0x80 && dev->disk->id <= 0x90)
&& dev->disk->dev->id >= 0x80 && dev->disk->dev->id <= 0x90)
{
struct grub_partition *part = dev->disk->partition;
bsd_device = dev->disk->id - 0x80 - hdbias;
@@ -546,6 +546,8 @@ struct legacy_md5_password
grub_uint8_t hash[MD5_HASHLEN];
};
#pragma GCC diagnostic ignored "-Wunsafe-loop-optimizations"
static int
check_password_md5_real (const char *entered,
struct legacy_md5_password *pw)
@@ -553,13 +555,8 @@ check_password_md5_real (const char *entered,
grub_size_t enteredlen = grub_strlen (entered);
unsigned char alt_result[MD5_HASHLEN];
unsigned char *digest;
grub_uint8_t *ctx;
grub_uint8_t ctx[GRUB_MD_MD5->contextsize];
grub_size_t i;
int ret;
ctx = grub_zalloc (GRUB_MD_MD5->contextsize);
if (!ctx)
return 0;
GRUB_MD_MD5->init (ctx);
GRUB_MD_MD5->write (ctx, entered, enteredlen);
@@ -605,9 +602,7 @@ check_password_md5_real (const char *entered,
GRUB_MD_MD5->final (ctx);
}
ret = (grub_crypto_memcmp (digest, pw->hash, MD5_HASHLEN) == 0);
grub_free (ctx);
return ret;
return (grub_crypto_memcmp (digest, pw->hash, MD5_HASHLEN) == 0);
}
static grub_err_t
@@ -730,37 +725,11 @@ grub_cmd_legacy_password (struct grub_command *mycmd __attribute__ ((unused)),
NULL);
}
int
grub_legacy_check_md5_password (int argc, char **args,
char *entered)
{
struct legacy_md5_password *pw = NULL;
int ret;
if (args[0][0] != '-' || args[0][1] != '-')
{
char correct[GRUB_AUTH_MAX_PASSLEN];
grub_memset (correct, 0, sizeof (correct));
grub_strncpy (correct, args[0], sizeof (correct));
return grub_crypto_memcmp (entered, correct, GRUB_AUTH_MAX_PASSLEN) == 0;
}
pw = parse_legacy_md5 (argc, args);
if (!pw)
return 0;
ret = check_password_md5_real (entered, pw);
grub_free (pw);
return ret;
}
static grub_err_t
grub_cmd_legacy_check_password (struct grub_command *mycmd __attribute__ ((unused)),
int argc, char **args)
{
struct legacy_md5_password *pw = NULL;
char entered[GRUB_AUTH_MAX_PASSLEN];
if (argc == 0)
@@ -769,8 +738,24 @@ grub_cmd_legacy_check_password (struct grub_command *mycmd __attribute__ ((unuse
if (!grub_password_get (entered, GRUB_AUTH_MAX_PASSLEN))
return GRUB_ACCESS_DENIED;
if (!grub_legacy_check_md5_password (argc, args,
entered))
if (args[0][0] != '-' || args[0][1] != '-')
{
char correct[GRUB_AUTH_MAX_PASSLEN];
grub_memset (correct, 0, sizeof (correct));
grub_strncpy (correct, args[0], sizeof (correct));
if (grub_crypto_memcmp (entered, correct, GRUB_AUTH_MAX_PASSLEN) != 0)
return GRUB_ACCESS_DENIED;
return GRUB_ERR_NONE;
}
pw = parse_legacy_md5 (argc, args);
if (!pw)
return GRUB_ACCESS_DENIED;
if (!check_password_md5_real (entered, pw))
return GRUB_ACCESS_DENIED;
return GRUB_ERR_NONE;

39
grub-core/commands/loadenv.c
View File

@@ -259,28 +259,10 @@ check_blocklists (grub_envblk_t envblk, struct blocklist *blocklists,
for (p = blocklists; p; p = p->next)
{
struct blocklist *q;
/* Check if any pair of blocks overlap. */
for (q = p->next; q; q = q->next)
{
grub_disk_addr_t s1, s2;
grub_disk_addr_t e1, e2, t;
s1 = p->sector;
e1 = s1 + ((p->length + GRUB_DISK_SECTOR_SIZE - 1) >> GRUB_DISK_SECTOR_BITS);
s2 = q->sector;
e2 = s2 + ((q->length + GRUB_DISK_SECTOR_SIZE - 1) >> GRUB_DISK_SECTOR_BITS);
if (s2 > s1)
{
t = s2;
s2 = s1;
s1 = t;
t = e2;
e2 = e1;
e1 = t;
}
if (e1 > s2)
/* Check if any pair of blocks overlap. */
if (p->sector == q->sector)
{
/* This might be actually valid, but it is unbelievable that
any filesystem makes such a silly allocation. */
@@ -304,18 +286,9 @@ check_blocklists (grub_envblk_t envblk, struct blocklist *blocklists,
part_start = grub_partition_get_start (disk->partition);
buf = grub_envblk_buffer (envblk);
char *blockbuf = NULL;
grub_size_t blockbuf_len = 0;
for (p = blocklists, index = 0; p; index += p->length, p = p->next)
{
if (p->length > blockbuf_len)
{
grub_free (blockbuf);
blockbuf_len = 2 * p->length;
blockbuf = grub_malloc (blockbuf_len);
if (!blockbuf)
return grub_errno;
}
char blockbuf[GRUB_DISK_SECTOR_SIZE];
if (grub_disk_read (disk, p->sector - part_start,
p->offset, p->length, blockbuf))
@@ -367,6 +340,10 @@ save_env_read_hook (grub_disk_addr_t sector, unsigned offset, unsigned length,
struct grub_cmd_save_env_ctx *ctx = data;
struct blocklist *block;
if (offset + length > GRUB_DISK_SECTOR_SIZE)
/* Seemingly a bug. */
return;
block = grub_malloc (sizeof (*block));
if (! block)
return;
@@ -432,8 +409,6 @@ grub_cmd_save_env (grub_extcmd_context_t ctxt, int argc, char **args)
goto fail;
}
}
else
grub_envblk_delete (envblk, args[0]);
argc--;
args++;

30
grub-core/commands/ls.c
View File

@@ -116,35 +116,11 @@ print_files_long (const char *filename, const struct grub_dirhook_info *info,
if (! info->dir)
{
grub_file_t file;
char *pathname;
if (ctx->dirname[grub_strlen (ctx->dirname) - 1] == '/')
pathname = grub_xasprintf ("%s%s", ctx->dirname, filename);
else
pathname = grub_xasprintf ("%s/%s", ctx->dirname, filename);
if (!pathname)
return 1;
/* XXX: For ext2fs symlinks are detected as files while they
should be reported as directories. */
grub_file_filter_disable_compression ();
file = grub_file_open (pathname);
if (! file)
{
grub_errno = 0;
grub_free (pathname);
return 0;
}
if (! ctx->human)
grub_printf ("%-12llu", (unsigned long long) file->size);
grub_printf ("%-12llu", (unsigned long long) info->size);
else
grub_printf ("%-12s", grub_get_human_size (file->size,
GRUB_HUMAN_SIZE_SHORT));
grub_file_close (file);
grub_free (pathname);
grub_printf ("%-12s", grub_get_human_size (info->size,
GRUB_HUMAN_SIZE_SHORT));
}
else
grub_printf ("%-12s", _("DIR"));

1
grub-core/commands/nativedisk.c
View File

@@ -75,7 +75,6 @@ get_uuid (const char *name, char **uuid, int getnative)
/* Native disks. */
case GRUB_DISK_DEVICE_ATA_ID:
case GRUB_DISK_DEVICE_SCSI_ID:
case GRUB_DISK_DEVICE_XEN:
if (getnative)
break;

7
grub-core/commands/testload.c
View File

@@ -35,13 +35,10 @@ GRUB_MOD_LICENSE ("GPLv3+");
static void
read_progress (grub_disk_addr_t sector __attribute__ ((unused)),
unsigned offset __attribute__ ((unused)),
unsigned len,
unsigned len __attribute__ ((unused)),
void *data __attribute__ ((unused)))
{
for (; len >= GRUB_DISK_SECTOR_SIZE; len -= GRUB_DISK_SECTOR_SIZE)
grub_xputs (".");
if (len)
grub_xputs (".");
grub_xputs (".");
grub_refresh ();
}

218
grub-core/commands/verify.c
View File

@@ -145,31 +145,16 @@ const char *hashes[] = {
[0x0b] = "sha224"
};
struct gcry_pk_spec *grub_crypto_pk_dsa;
struct gcry_pk_spec *grub_crypto_pk_ecdsa;
struct gcry_pk_spec *grub_crypto_pk_rsa;
static int
dsa_pad (gcry_mpi_t *hmpi, grub_uint8_t *hval,
const gcry_md_spec_t *hash, struct grub_public_subkey *sk);
static int
rsa_pad (gcry_mpi_t *hmpi, grub_uint8_t *hval,
const gcry_md_spec_t *hash, struct grub_public_subkey *sk);
struct
{
const char *name;
grub_size_t nmpisig;
grub_size_t nmpipub;
struct gcry_pk_spec **algo;
int (*pad) (gcry_mpi_t *hmpi, grub_uint8_t *hval,
const gcry_md_spec_t *hash, struct grub_public_subkey *sk);
const char *module;
} pkalgos[] =
{
[1] = { "rsa", 1, 2, &grub_crypto_pk_rsa, rsa_pad, "gcry_rsa" },
[3] = { "rsa", 1, 2, &grub_crypto_pk_rsa, rsa_pad, "gcry_rsa" },
[17] = { "dsa", 2, 4, &grub_crypto_pk_dsa, dsa_pad, "gcry_dsa" },
[1] = { "rsa", 1, 2 },
[3] = { "rsa", 1, 2 },
[17] = { "dsa", 2, 4 },
};
struct grub_public_key
@@ -192,39 +177,22 @@ free_pk (struct grub_public_key *pk)
struct grub_public_subkey *nsk, *sk;
for (sk = pk->subkeys; sk; sk = nsk)
{
grub_size_t i;
for (i = 0; i < ARRAY_SIZE (sk->mpis); i++)
if (sk->mpis[i])
gcry_mpi_release (sk->mpis[i]);
nsk = sk->next;
grub_free (sk);
}
grub_free (pk);
}
#define READBUF_SIZE 4096
struct grub_public_key *
grub_load_public_key (grub_file_t f)
{
grub_err_t err;
struct grub_public_key *ret;
struct grub_public_subkey **last = 0;
void *fingerprint_context = NULL;
grub_uint8_t *buffer = NULL;
ret = grub_zalloc (sizeof (*ret));
if (!ret)
{
grub_free (fingerprint_context);
return NULL;
}
buffer = grub_zalloc (READBUF_SIZE);
fingerprint_context = grub_zalloc (GRUB_MD_SHA1->contextsize);
if (!buffer || !fingerprint_context)
goto fail;
return NULL;
last = &ret->subkeys;
@@ -238,6 +206,7 @@ grub_load_public_key (grub_file_t f)
struct grub_public_subkey *sk;
grub_size_t i;
grub_uint16_t len_be;
GRUB_PROPERLY_ALIGNED_ARRAY (fingerprint_context, GRUB_MD_SHA1->contextsize);
err = read_packet_header (f, &type, &len);
@@ -246,11 +215,7 @@ grub_load_public_key (grub_file_t f)
if (type == 0xfe)
continue;
if (type == 0xff)
{
grub_free (fingerprint_context);
grub_free (buffer);
return ret;
}
return ret;
grub_dprintf ("crypt", "len = %x\n", (int) len);
@@ -314,6 +279,7 @@ grub_load_public_key (grub_file_t f)
{
grub_uint16_t l;
grub_size_t lb;
grub_uint8_t buffer[4096];
if (grub_file_read (f, &l, sizeof (l)) != sizeof (l))
{
grub_error (GRUB_ERR_BAD_SIGNATURE, N_("bad signature"));
@@ -321,7 +287,7 @@ grub_load_public_key (grub_file_t f)
}
lb = (grub_be_to_cpu16 (l) + GRUB_CHAR_BIT - 1) / GRUB_CHAR_BIT;
if (lb > READBUF_SIZE - sizeof (grub_uint16_t))
if (lb > sizeof (buffer) - sizeof (grub_uint16_t))
{
grub_error (GRUB_ERR_BAD_SIGNATURE, N_("bad signature"));
goto fail;
@@ -356,8 +322,6 @@ grub_load_public_key (grub_file_t f)
}
fail:
free_pk (ret);
grub_free (fingerprint_context);
grub_free (buffer);
return NULL;
}
@@ -387,51 +351,6 @@ grub_crypto_pk_locate_subkey_in_trustdb (grub_uint64_t keyid)
return 0;
}
static int
dsa_pad (gcry_mpi_t *hmpi, grub_uint8_t *hval,
const gcry_md_spec_t *hash, struct grub_public_subkey *sk)
{
unsigned nbits = gcry_mpi_get_nbits (sk->mpis[1]);
grub_dprintf ("crypt", "must be %u bits got %d bits\n", nbits,
(int)(8 * hash->mdlen));
return gcry_mpi_scan (hmpi, GCRYMPI_FMT_USG, hval,
nbits / 8 < (unsigned) hash->mdlen ? nbits / 8
: (unsigned) hash->mdlen, 0);
}
static int
rsa_pad (gcry_mpi_t *hmpi, grub_uint8_t *hval,
const gcry_md_spec_t *hash, struct grub_public_subkey *sk)
{
grub_size_t tlen, emlen, fflen;
grub_uint8_t *em, *emptr;
unsigned nbits = gcry_mpi_get_nbits (sk->mpis[0]);
int ret;
tlen = hash->mdlen + hash->asnlen;
emlen = (nbits + 7) / 8;
if (emlen < tlen + 11)
return 1;
em = grub_malloc (emlen);
if (!em)
return 1;
em[0] = 0x00;
em[1] = 0x01;
fflen = emlen - tlen - 3;
for (emptr = em + 2; emptr < em + 2 + fflen; emptr++)
*emptr = 0xff;
*emptr++ = 0x00;
grub_memcpy (emptr, hash->asnoid, hash->asnlen);
emptr += hash->asnlen;
grub_memcpy (emptr, hval, hash->mdlen);
ret = gcry_mpi_scan (hmpi, GCRYMPI_FMT_USG, em, emlen, 0);
grub_free (em);
return ret;
}
static grub_err_t
grub_verify_signature_real (char *buf, grub_size_t size,
grub_file_t f, grub_file_t sig,
@@ -485,7 +404,7 @@ grub_verify_signature_real (char *buf, grub_size_t size,
grub_dprintf ("crypt", "alive\n");
{
void *context = NULL;
GRUB_PROPERLY_ALIGNED_ARRAY (context, hash->contextsize);
unsigned char *hval;
grub_ssize_t rem = grub_be_to_cpu16 (v4.hashed_sub);
grub_uint32_t headlen = grub_cpu_to_be32 (rem + 6);
@@ -496,22 +415,18 @@ grub_verify_signature_real (char *buf, grub_size_t size,
gcry_mpi_t hmpi;
grub_uint64_t keyid = 0;
struct grub_public_subkey *sk;
grub_uint8_t *readbuf = NULL;
context = grub_zalloc (hash->contextsize);
readbuf = grub_zalloc (READBUF_SIZE);
if (!context || !readbuf)
goto fail;
grub_memset (context, 0, sizeof (context));
hash->init (context);
if (buf)
hash->write (context, buf, size);
else
while (1)
{
r = grub_file_read (f, readbuf, READBUF_SIZE);
grub_uint8_t readbuf[4096];
r = grub_file_read (f, readbuf, sizeof (readbuf));
if (r < 0)
goto fail;
return grub_errno;
if (r == 0)
break;
hash->write (context, readbuf, r);
@@ -521,10 +436,10 @@ grub_verify_signature_real (char *buf, grub_size_t size,
hash->write (context, &v4, sizeof (v4));
while (rem)
{
r = grub_file_read (sig, readbuf,
rem < READBUF_SIZE ? rem : READBUF_SIZE);
grub_uint8_t readbuf[4096];
r = grub_file_read (sig, readbuf, rem < (grub_ssize_t) sizeof (readbuf) ? rem : (grub_ssize_t) sizeof (readbuf));
if (r < 0)
goto fail;
return grub_error (GRUB_ERR_BAD_SIGNATURE, N_("bad signature"));
if (r == 0)
break;
hash->write (context, readbuf, r);
@@ -536,16 +451,17 @@ grub_verify_signature_real (char *buf, grub_size_t size,
hash->write (context, &headlen, sizeof (headlen));
r = grub_file_read (sig, &unhashed_sub, sizeof (unhashed_sub));
if (r != sizeof (unhashed_sub))
goto fail;
return grub_error (GRUB_ERR_BAD_SIGNATURE, N_("bad signature"));
{
grub_uint8_t readbuf[4096];
grub_uint8_t *ptr;
grub_uint32_t l;
rem = grub_be_to_cpu16 (unhashed_sub);
if (rem > READBUF_SIZE)
goto fail;
if (rem > (int) sizeof (readbuf))
return grub_error (GRUB_ERR_BAD_SIGNATURE, N_("bad signature"));
r = grub_file_read (sig, readbuf, rem);
if (r != rem)
goto fail;
return grub_error (GRUB_ERR_BAD_SIGNATURE, N_("bad signature"));
for (ptr = readbuf; ptr < readbuf + rem; ptr += l)
{
if (*ptr < 192)
@@ -576,9 +492,9 @@ grub_verify_signature_real (char *buf, grub_size_t size,
hval = hash->read (context);
if (grub_file_read (sig, hash_start, sizeof (hash_start)) != sizeof (hash_start))
goto fail;
return grub_error (GRUB_ERR_BAD_SIGNATURE, N_("bad signature"));
if (grub_memcmp (hval, hash_start, sizeof (hash_start)) != 0)
goto fail;
return grub_error (GRUB_ERR_BAD_SIGNATURE, N_("bad signature"));
grub_dprintf ("crypt", "@ %x\n", (int)grub_file_tell (sig));
@@ -586,24 +502,25 @@ grub_verify_signature_real (char *buf, grub_size_t size,
{
grub_uint16_t l;
grub_size_t lb;
grub_uint8_t buffer[4096];
grub_dprintf ("crypt", "alive\n");
if (grub_file_read (sig, &l, sizeof (l)) != sizeof (l))
goto fail;
return grub_error (GRUB_ERR_BAD_SIGNATURE, N_("bad signature"));
grub_dprintf ("crypt", "alive\n");
lb = (grub_be_to_cpu16 (l) + 7) / 8;
grub_dprintf ("crypt", "l = 0x%04x\n", grub_be_to_cpu16 (l));
if (lb > READBUF_SIZE - sizeof (grub_uint16_t))
goto fail;
if (lb > sizeof (buffer) - sizeof (grub_uint16_t))
return grub_error (GRUB_ERR_BAD_SIGNATURE, N_("bad signature"));
grub_dprintf ("crypt", "alive\n");
if (grub_file_read (sig, readbuf + sizeof (grub_uint16_t), lb) != (grub_ssize_t) lb)
goto fail;
if (grub_file_read (sig, buffer + sizeof (grub_uint16_t), lb) != (grub_ssize_t) lb)
return grub_error (GRUB_ERR_BAD_SIGNATURE, N_("bad signature"));
grub_dprintf ("crypt", "alive\n");
grub_memcpy (readbuf, &l, sizeof (l));
grub_memcpy (buffer, &l, sizeof (l));
grub_dprintf ("crypt", "alive\n");
if (gcry_mpi_scan (&mpis[i], GCRYMPI_FMT_PGP,
readbuf, lb + sizeof (grub_uint16_t), 0))
goto fail;
buffer, lb + sizeof (grub_uint16_t), 0))
return grub_error (GRUB_ERR_BAD_SIGNATURE, N_("bad signature"));
grub_dprintf ("crypt", "alive\n");
}
@@ -612,42 +529,24 @@ grub_verify_signature_real (char *buf, grub_size_t size,
else
sk = grub_crypto_pk_locate_subkey_in_trustdb (keyid);
if (!sk)
{
/* TRANSLATORS: %08x is 32-bit key id. */
grub_error (GRUB_ERR_BAD_SIGNATURE, N_("public key %08x not found"),
keyid);
goto fail;
}
/* TRANSLATORS: %08x is 32-bit key id. */
return grub_error (GRUB_ERR_BAD_SIGNATURE, N_("public key %08x not found"), keyid);
if (pkalgos[pk].pad (&hmpi, hval, hash, sk))
goto fail;
if (!*pkalgos[pk].algo)
{
grub_dl_load (pkalgos[pk].module);
grub_errno = GRUB_ERR_NONE;
}
unsigned nbits = gcry_mpi_get_nbits (sk->mpis[1]);
grub_dprintf ("crypt", "must be %u bits got %d bits\n", nbits,
(int)(8 * hash->mdlen));
if (!*pkalgos[pk].algo)
{
grub_error (GRUB_ERR_BAD_SIGNATURE, N_("module `%s' isn't loaded"),
pkalgos[pk].module);
goto fail;
}
if ((*pkalgos[pk].algo)->verify (0, hmpi, mpis, sk->mpis, 0, 0))
goto fail;
grub_free (context);
grub_free (readbuf);
return GRUB_ERR_NONE;
fail:
grub_free (context);
grub_free (readbuf);
if (!grub_errno)
if (gcry_mpi_scan (&hmpi, GCRYMPI_FMT_USG, hval,
nbits / 8 < (unsigned) hash->mdlen ? nbits / 8
: (unsigned) hash->mdlen, 0))
return grub_error (GRUB_ERR_BAD_SIGNATURE, N_("bad signature"));
if (!grub_crypto_pk_dsa)
return grub_error (GRUB_ERR_BAD_SIGNATURE, N_("module `%s' isn't loaded"), "gcry_dsa");
if (grub_crypto_pk_dsa->verify (0, hmpi, mpis, sk->mpis, 0, 0))
return grub_error (GRUB_ERR_BAD_SIGNATURE, N_("bad signature"));
return grub_errno;
}
return GRUB_ERR_NONE;
}
grub_err_t
@@ -744,8 +643,8 @@ static grub_err_t
grub_cmd_verify_signature (grub_extcmd_context_t ctxt,
int argc, char **args)
{
grub_file_t f = NULL, sig = NULL;
grub_err_t err = GRUB_ERR_NONE;
grub_file_t f, sig;
grub_err_t err;
struct grub_public_key *pk = NULL;
grub_dprintf ("crypt", "alive\n");
@@ -776,27 +675,19 @@ grub_cmd_verify_signature (grub_extcmd_context_t ctxt,
grub_file_filter_disable_all ();
f = grub_file_open (args[0]);
if (!f)
{
err = grub_errno;
goto fail;
}
return grub_errno;
grub_file_filter_disable_all ();
sig = grub_file_open (args[1]);
if (!sig)
{
err = grub_errno;
goto fail;
grub_file_close (f);
return grub_errno;
}
err = grub_verify_signature (f, sig, pk);
fail:
if (sig)
grub_file_close (sig);
if (f)
grub_file_close (f);
if (pk)
free_pk (pk);
grub_file_close (f);
grub_file_close (sig);
return err;
}
@@ -912,6 +803,9 @@ struct grub_fs pseudo_fs =
.read = pseudo_read
};
struct gcry_pk_spec *grub_crypto_pk_dsa;
struct gcry_pk_spec *grub_crypto_pk_ecdsa;
struct gcry_pk_spec *grub_crypto_pk_rsa;
static grub_extcmd_t cmd, cmd_trust;
static grub_command_t cmd_distrust, cmd_list;

90
grub-core/commands/xen/lsxen.c
View File

@@ -1,90 +0,0 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2011 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/dl.h>
#include <grub/misc.h>
#include <grub/command.h>
#include <grub/i18n.h>
#include <grub/xen.h>
#include <grub/term.h>
GRUB_MOD_LICENSE ("GPLv3+");
static int
hook (const char *dir, void *hook_data __attribute__ ((unused)))
{
grub_printf ("%s\n", dir);
return 0;
}
static grub_err_t
grub_cmd_lsxen (grub_command_t cmd __attribute__ ((unused)),
int argc, char **args)
{
char *dir;
grub_err_t err;
char *buf;
if (argc >= 1)
return grub_xenstore_dir (args[0], hook, NULL);
buf = grub_xenstore_get_file ("domid", NULL);
if (!buf)
return grub_errno;
dir = grub_xasprintf ("/local/domain/%s", buf);
grub_free (buf);
err = grub_xenstore_dir (dir, hook, NULL);
grub_free (dir);
return err;
}
static grub_err_t
grub_cmd_catxen (grub_command_t cmd __attribute__ ((unused)),
int argc, char **args)
{
const char *dir = "domid";
char *buf;
if (argc >= 1)
dir = args[0];
buf = grub_xenstore_get_file (dir, NULL);
if (!buf)
return grub_errno;
grub_xputs (buf);
grub_xputs ("\n");
grub_free (buf);
return GRUB_ERR_NONE;
}
static grub_command_t cmd_ls, cmd_cat;
GRUB_MOD_INIT (lsxen)
{
cmd_ls = grub_register_command ("xen_ls", grub_cmd_lsxen, "[DIR]",
N_("List XEN storage."));
cmd_cat = grub_register_command ("xen_cat", grub_cmd_catxen, "[DIR]",
N_("List XEN storage."));
}
GRUB_MOD_FINI (lsxen)
{
grub_unregister_command (cmd_ls);
grub_unregister_command (cmd_cat);
}

17
grub-core/commands/xnu_uuid.c
View File

@@ -50,7 +50,7 @@ grub_cmd_xnu_uuid (grub_command_t cmd __attribute__ ((unused)),
grub_uint8_t *xnu_uuid;
char uuid_string[sizeof ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")];
char *ptr;
void *ctx;
grub_uint8_t ctx[GRUB_MD_MD5->contextsize];
int low = 0;
if (argc < 1)
@@ -65,14 +65,11 @@ grub_cmd_xnu_uuid (grub_command_t cmd __attribute__ ((unused)),
serial = grub_cpu_to_be64 (grub_strtoull (args[0], 0, 16));
ctx = grub_zalloc (GRUB_MD_MD5->contextsize);
if (!ctx)
return grub_errno;
GRUB_MD_MD5->init (ctx);
GRUB_MD_MD5->write (ctx, hash_prefix, sizeof (hash_prefix));
GRUB_MD_MD5->write (ctx, &serial, sizeof (serial));
GRUB_MD_MD5->final (ctx);
xnu_uuid = GRUB_MD_MD5->read (ctx);
GRUB_MD_MD5->init (&ctx);
GRUB_MD_MD5->write (&ctx, hash_prefix, sizeof (hash_prefix));
GRUB_MD_MD5->write (&ctx, &serial, sizeof (serial));
GRUB_MD_MD5->final (&ctx);
xnu_uuid = GRUB_MD_MD5->read (&ctx);
grub_snprintf (uuid_string, sizeof (uuid_string),
"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
@@ -94,8 +91,6 @@ grub_cmd_xnu_uuid (grub_command_t cmd __attribute__ ((unused)),
if (argc > 1)
grub_env_set (args[1], uuid_string);
grub_free (ctx);
return GRUB_ERR_NONE;
}

7
grub-core/disk/AFSplitter.c
View File

@@ -37,8 +37,8 @@ diffuse (const gcry_md_spec_t * hash, grub_uint8_t * src,
grub_size_t fullblocks = size / hash->mdlen;
int padding = size % hash->mdlen;
grub_uint8_t final[GRUB_CRYPTO_MAX_MDLEN];
grub_uint8_t temp[sizeof (IV) + GRUB_CRYPTO_MAX_MDLEN];
grub_uint8_t final[hash->mdlen];
grub_uint8_t temp[sizeof (IV) + hash->mdlen];
/* hash block the whole data set with different IVs to produce
* more than just a single data block
@@ -76,9 +76,6 @@ AF_merge (const gcry_md_spec_t * hash, grub_uint8_t * src, grub_uint8_t * dst,
if (bufblock == NULL)
return GPG_ERR_OUT_OF_MEMORY;
if (hash->mdlen > GRUB_CRYPTO_MAX_MDLEN)
return GPG_ERR_INV_ARG;
grub_memset (bufblock, 0, blocksize);
for (i = 0; i < blocknumbers - 1; i++)
{

6
grub-core/disk/ahci.c
View File

@@ -133,7 +133,6 @@ struct grub_ahci_device
volatile struct grub_ahci_cmd_table *command_table;
struct grub_pci_dma_chunk *rfis;
int present;
int atapi;
};
static grub_err_t
@@ -617,10 +616,6 @@ grub_ahci_pciinit (grub_pci_device_t dev,
grub_dma_free (failed_adevs[i]->rfis);
}
for (i = 0; i < nports; i++)
if (adevs[i] && (adevs[i]->hba->ports[adevs[i]->port].sig >> 16) == 0xeb14)
adevs[i]->atapi = 1;
for (i = 0; i < nports; i++)
if (adevs[i])
{
@@ -1080,7 +1075,6 @@ grub_ahci_open (int id, int devnum, struct grub_ata *ata)
ata->data = dev;
ata->dma = 1;
ata->atapi = dev->atapi;
ata->maxbuffer = GRUB_AHCI_PRDT_MAX_CHUNK_LENGTH;
ata->present = &dev->present;

22
grub-core/disk/ata.c
View File

@@ -108,9 +108,6 @@ grub_ata_identify (struct grub_ata *dev)
grub_uint16_t *info16;
grub_err_t err;
if (dev->atapi)
return grub_atapi_identify (dev);
info64 = grub_malloc (GRUB_DISK_SECTOR_SIZE);
info32 = (grub_uint32_t *) info64;
info16 = (grub_uint16_t *) info64;
@@ -132,7 +129,7 @@ grub_ata_identify (struct grub_ata *dev)
grub_free (info16);
grub_errno = GRUB_ERR_NONE;
if ((sts & (GRUB_ATA_STATUS_BUSY | GRUB_ATA_STATUS_DRQ
| GRUB_ATA_STATUS_ERR)) == GRUB_ATA_STATUS_ERR
| GRUB_ATA_STATUS_ERR)) == GRUB_ATA_STATUS_ERR
&& (parms.taskfile.error & 0x04 /* ABRT */))
/* Device without ATA IDENTIFY, try ATAPI. */
return grub_atapi_identify (dev);
@@ -288,6 +285,7 @@ grub_ata_readwrite (grub_disk_t disk, grub_disk_addr_t sector,
if (addressing == GRUB_ATA_LBA48 && ((sector + size) >> 28) != 0)
{
batch = 65536;
if (ata->dma)
{
cmd = GRUB_ATA_CMD_READ_SECTORS_DMA_EXT;
@@ -303,6 +301,10 @@ grub_ata_readwrite (grub_disk_t disk, grub_disk_addr_t sector,
{
if (addressing == GRUB_ATA_LBA48)
addressing = GRUB_ATA_LBA;
if (addressing != GRUB_ATA_CHS)
batch = 256;
else
batch = 1;
if (ata->dma)
{
cmd = GRUB_ATA_CMD_READ_SECTORS_DMA;
@@ -315,10 +317,8 @@ grub_ata_readwrite (grub_disk_t disk, grub_disk_addr_t sector,
}
}
if (addressing != GRUB_ATA_CHS)
batch = 256;
else
batch = 1;
if (batch > (ata->maxbuffer >> ata->log_sector_size))
batch = (ata->maxbuffer >> ata->log_sector_size);
while (nsectors < size)
{
@@ -366,7 +366,7 @@ grub_ata_real_open (int id, int bus)
struct grub_ata *ata;
grub_ata_dev_t p;
ata = grub_zalloc (sizeof (*ata));
ata = grub_malloc (sizeof (*ata));
if (!ata)
return NULL;
for (p = grub_ata_dev_list; p; p = p->next)
@@ -464,10 +464,6 @@ grub_ata_open (const char *name, grub_disk_t disk)
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "not an ATA harddisk");
disk->total_sectors = ata->size;
disk->max_agglomerate = (ata->maxbuffer >> (GRUB_DISK_CACHE_BITS + GRUB_DISK_SECTOR_BITS));
if (disk->max_agglomerate > (256U >> (GRUB_DISK_CACHE_BITS + GRUB_DISK_SECTOR_BITS - ata->log_sector_size)))
disk->max_agglomerate = (256U >> (GRUB_DISK_CACHE_BITS + GRUB_DISK_SECTOR_BITS - ata->log_sector_size));
disk->log_sector_size = ata->log_sector_size;
disk->id = grub_make_scsi_id (id, bus, 0);

32
grub-core/disk/cryptodisk.c
View File

@@ -109,9 +109,7 @@ grub_crypto_pcbc_decrypt (grub_crypto_cipher_handle_t cipher,
void *iv)
{
grub_uint8_t *inptr, *outptr, *end;
grub_uint8_t ivt[GRUB_CRYPTO_MAX_CIPHER_BLOCKSIZE];
if (cipher->cipher->blocksize > GRUB_CRYPTO_MAX_CIPHER_BLOCKSIZE)
return GPG_ERR_INV_ARG;
grub_uint8_t ivt[cipher->cipher->blocksize];
if (!cipher->cipher->decrypt)
return GPG_ERR_NOT_SUPPORTED;
if (size % cipher->cipher->blocksize != 0)
@@ -134,9 +132,7 @@ grub_crypto_pcbc_encrypt (grub_crypto_cipher_handle_t cipher,
void *iv)
{
grub_uint8_t *inptr, *outptr, *end;
grub_uint8_t ivt[GRUB_CRYPTO_MAX_CIPHER_BLOCKSIZE];
if (cipher->cipher->blocksize > GRUB_CRYPTO_MAX_CIPHER_BLOCKSIZE)
return GPG_ERR_INV_ARG;
grub_uint8_t ivt[cipher->cipher->blocksize];
if (!cipher->cipher->decrypt)
return GPG_ERR_NOT_SUPPORTED;
if (size % cipher->cipher->blocksize != 0)
@@ -222,9 +218,6 @@ grub_cryptodisk_endecrypt (struct grub_cryptodisk *dev,
grub_size_t i;
gcry_err_code_t err;
if (dev->cipher->cipher->blocksize > GRUB_CRYPTO_MAX_CIPHER_BLOCKSIZE)
return GPG_ERR_INV_ARG;
/* The only mode without IV. */
if (dev->mode == GRUB_CRYPTODISK_MODE_ECB && !dev->rekey)
return (do_encrypt ? grub_crypto_ecb_encrypt (dev->cipher, data, data, len)
@@ -235,7 +228,7 @@ grub_cryptodisk_endecrypt (struct grub_cryptodisk *dev,
grub_size_t sz = ((dev->cipher->cipher->blocksize
+ sizeof (grub_uint32_t) - 1)
/ sizeof (grub_uint32_t));
grub_uint32_t iv[(GRUB_CRYPTO_MAX_CIPHER_BLOCKSIZE + 3) / 4];
grub_uint32_t iv[sz];
if (dev->rekey)
{
@@ -249,7 +242,7 @@ grub_cryptodisk_endecrypt (struct grub_cryptodisk *dev,
}
}
grub_memset (iv, 0, sizeof (iv));
grub_memset (iv, 0, sz * sizeof (iv[0]));
switch (dev->mode_iv)
{
case GRUB_CRYPTODISK_MODE_IV_NULL:
@@ -257,11 +250,9 @@ grub_cryptodisk_endecrypt (struct grub_cryptodisk *dev,
case GRUB_CRYPTODISK_MODE_IV_BYTECOUNT64_HASH:
{
grub_uint64_t tmp;
void *ctx;
GRUB_PROPERLY_ALIGNED_ARRAY (ctx, dev->iv_hash->contextsize);
ctx = grub_zalloc (dev->iv_hash->contextsize);
if (!ctx)
return GPG_ERR_OUT_OF_MEMORY;
grub_memset (ctx, 0, sizeof (ctx));
tmp = grub_cpu_to_le64 (sector << dev->log_sector_size);
dev->iv_hash->init (ctx);
@@ -270,7 +261,6 @@ grub_cryptodisk_endecrypt (struct grub_cryptodisk *dev,
dev->iv_hash->final (ctx);
grub_memcpy (iv, dev->iv_hash->read (ctx), sizeof (iv));
grub_free (ctx);
}
break;
case GRUB_CRYPTODISK_MODE_IV_PLAIN64:
@@ -417,9 +407,7 @@ grub_cryptodisk_setkey (grub_cryptodisk_t dev, grub_uint8_t *key, grub_size_t ke
if (dev->mode_iv == GRUB_CRYPTODISK_MODE_IV_ESSIV)
{
grub_size_t essiv_keysize = dev->essiv_hash->mdlen;
grub_uint8_t hashed_key[GRUB_CRYPTO_MAX_MDLEN];
if (essiv_keysize > GRUB_CRYPTO_MAX_MDLEN)
return GPG_ERR_INV_ARG;
grub_uint8_t hashed_key[essiv_keysize];
grub_crypto_hash (dev->essiv_hash, hashed_key, key, keysize);
err = grub_crypto_cipher_set_key (dev->essiv_cipher,
@@ -529,7 +517,6 @@ grub_cryptodisk_open (const char *name, grub_disk_t disk)
disk->data = dev;
disk->total_sectors = dev->total_length;
disk->max_agglomerate = GRUB_DISK_MAX_MAX_AGGLOMERATE;
disk->id = dev->id;
dev->ref++;
return GRUB_ERR_NONE;
@@ -1011,14 +998,12 @@ hex (grub_uint8_t val)
/* Open a file named NAME and initialize FILE. */
static char *
luks_script_get (grub_size_t *sz)
luks_script_get (void)
{
grub_cryptodisk_t i;
grub_size_t size = 0;
char *ptr, *ret;
*sz = 0;
for (i = cryptodisk_list; i != NULL; i = i->next)
if (grub_strcmp (i->modname, "luks") == 0)
{
@@ -1100,7 +1085,6 @@ luks_script_get (grub_size_t *sz)
*ptr++ = '\n';
}
*ptr = '\0';
*sz = ptr - ret;
return ret;
}

3
grub-core/disk/diskfilter.c
View File

@@ -445,7 +445,6 @@ grub_diskfilter_open (const char *name, grub_disk_t disk)
disk->data = lv;
disk->total_sectors = lv->size;
disk->max_agglomerate = GRUB_DISK_MAX_MAX_AGGLOMERATE;
return 0;
}
@@ -934,7 +933,7 @@ grub_diskfilter_make_raid (grub_size_t uuidlen, char *uuid, int nmemb,
case 4:
case 5:
case 6:
totsize = (nmemb - ((unsigned) level / 3U)) * disk_size;
totsize = (nmemb - level / 3) * disk_size;
break;
default:

27
grub-core/disk/efi/efidisk.c
View File

@@ -518,8 +518,6 @@ grub_efidisk_open (const char *name, struct grub_disk *disk)
grub_dprintf ("efidisk", "m = %p, last block = %llx, block size = %x\n",
m, (unsigned long long) m->last_block, m->block_size);
disk->total_sectors = m->last_block + 1;
/* Don't increase this value due to bug in some EFI. */
disk->max_agglomerate = 0xa0000 >> (GRUB_DISK_CACHE_BITS + GRUB_DISK_SECTOR_BITS);
if (m->block_size & (m->block_size - 1) || !m->block_size)
return grub_error (GRUB_ERR_IO, "invalid sector size %d",
m->block_size);
@@ -544,17 +542,32 @@ static grub_efi_status_t
grub_efidisk_readwrite (struct grub_disk *disk, grub_disk_addr_t sector,
grub_size_t size, char *buf, int wr)
{
/* For now, use the disk io interface rather than the block io's. */
struct grub_efidisk_data *d;
grub_efi_block_io_t *bio;
grub_efi_status_t status;
d = disk->data;
bio = d->block_io;
return efi_call_5 ((wr ? bio->write_blocks : bio->read_blocks), bio,
bio->media->media_id,
(grub_efi_uint64_t) sector,
(grub_efi_uintn_t) size << disk->log_sector_size,
buf);
while (size > 0)
{
grub_size_t len;
len = 0x500;
if (len > size)
len = size;
status = efi_call_5 ((wr ? bio->write_blocks : bio->read_blocks), bio,
bio->media->media_id,
(grub_efi_uint64_t) sector,
(grub_efi_uintn_t) len << disk->log_sector_size,
buf);
size -= len;
buf += len << disk->log_sector_size;
sector += len;
if (status != GRUB_EFI_SUCCESS)
return status;
}
return GRUB_EFI_SUCCESS;
}
static grub_err_t

52
grub-core/disk/geli.c
View File

@@ -146,33 +146,40 @@ geli_rekey (struct grub_cryptodisk *dev, grub_uint64_t zoneno)
grub_uint64_t zone;
} __attribute__ ((packed)) tohash
= { {'e', 'k', 'e', 'y'}, grub_cpu_to_le64 (zoneno) };
GRUB_PROPERLY_ALIGNED_ARRAY (key, GRUB_CRYPTO_MAX_MDLEN);
if (dev->hash->mdlen > GRUB_CRYPTO_MAX_MDLEN)
return GPG_ERR_INV_ARG;
GRUB_PROPERLY_ALIGNED_ARRAY (key, dev->hash->mdlen);
grub_dprintf ("geli", "rekeying %" PRIuGRUB_UINT64_T " keysize=%d\n",
zoneno, dev->rekey_derived_size);
gcry_err = grub_crypto_hmac_buffer (dev->hash, dev->rekey_key, 64,
&tohash, sizeof (tohash), key);
if (gcry_err)
return gcry_err;
return grub_crypto_gcry_error (gcry_err);
return grub_cryptodisk_setkey (dev, (grub_uint8_t *) key,
dev->rekey_derived_size);
}
static inline int
ascii2hex (char c)
{
if (c >= '0' && c <= '9')
return c - '0';
if (c >= 'a' && c <= 'f')
return c - 'a' + 10;
if (c >= 'A' && c <= 'F')
return c - 'A' + 10;
return 0;
}
static inline gcry_err_code_t
make_uuid (const struct grub_geli_phdr *header,
char *uuid)
{
grub_uint8_t uuidbin[GRUB_CRYPTODISK_MAX_UUID_LENGTH];
grub_uint8_t uuidbin[GRUB_MD_SHA256->mdlen];
gcry_err_code_t err;
grub_uint8_t *iptr;
char *optr;
if (2 * GRUB_MD_SHA256->mdlen + 1 > GRUB_CRYPTODISK_MAX_UUID_LENGTH)
return GPG_ERR_TOO_LARGE;
err = grub_crypto_hmac_buffer (GRUB_MD_SHA256,
header->salt, sizeof (header->salt),
"uuid", sizeof ("uuid") - 1, uuidbin);
@@ -180,7 +187,7 @@ make_uuid (const struct grub_geli_phdr *header,
return err;
optr = uuid;
for (iptr = uuidbin; iptr < &uuidbin[GRUB_MD_SHA256->mdlen]; iptr++)
for (iptr = uuidbin; iptr < &uuidbin[ARRAY_SIZE (uuidbin)]; iptr++)
{
grub_snprintf (optr, 3, "%02x", *iptr);
optr += 2;
@@ -247,13 +254,10 @@ configure_ciphers (grub_disk_t disk, const char *check_uuid,
const struct gcry_cipher_spec *ciph;
const char *ciphername = NULL;
gcry_err_code_t gcry_err;
char uuid[GRUB_CRYPTODISK_MAX_UUID_LENGTH];
char uuid[GRUB_MD_SHA256->mdlen * 2 + 1];
grub_disk_addr_t sector;
grub_err_t err;
if (2 * GRUB_MD_SHA256->mdlen + 1 > GRUB_CRYPTODISK_MAX_UUID_LENGTH)
return NULL;
sector = grub_disk_get_size (disk);
if (sector == GRUB_DISK_SIZE_UNKNOWN || sector == 0)
return NULL;
@@ -387,10 +391,10 @@ static grub_err_t
recover_key (grub_disk_t source, grub_cryptodisk_t dev)
{
grub_size_t keysize;
grub_uint8_t digest[GRUB_CRYPTO_MAX_MDLEN];
grub_uint8_t geomkey[GRUB_CRYPTO_MAX_MDLEN];
grub_uint8_t verify_key[GRUB_CRYPTO_MAX_MDLEN];
grub_uint8_t zero[GRUB_CRYPTO_MAX_CIPHER_BLOCKSIZE];
grub_uint8_t digest[dev->hash->mdlen];
grub_uint8_t geomkey[dev->hash->mdlen];
grub_uint8_t verify_key[dev->hash->mdlen];
grub_uint8_t zero[dev->cipher->cipher->blocksize];
char passphrase[MAX_PASSPHRASE] = "";
unsigned i;
gcry_err_code_t gcry_err;
@@ -399,12 +403,6 @@ recover_key (grub_disk_t source, grub_cryptodisk_t dev)
grub_disk_addr_t sector;
grub_err_t err;
if (dev->cipher->cipher->blocksize > GRUB_CRYPTO_MAX_CIPHER_BLOCKSIZE)
return grub_error (GRUB_ERR_BUG, "cipher block is too long");
if (dev->hash->mdlen > GRUB_CRYPTO_MAX_MDLEN)
return grub_error (GRUB_ERR_BUG, "mdlen is too long");
sector = grub_disk_get_size (source);
if (sector == GRUB_DISK_SIZE_UNKNOWN || sector == 0)
return grub_error (GRUB_ERR_BUG, "not a geli");
@@ -466,12 +464,12 @@ recover_key (grub_disk_t source, grub_cryptodisk_t dev)
}
gcry_err = grub_crypto_hmac_buffer (dev->hash, geomkey,
dev->hash->mdlen, "\1", 1, digest);
sizeof (geomkey), "\1", 1, digest);
if (gcry_err)
return grub_crypto_gcry_error (gcry_err);
gcry_err = grub_crypto_hmac_buffer (dev->hash, geomkey,
dev->hash->mdlen, "\0", 1, verify_key);
sizeof (geomkey), "\0", 1, verify_key);
if (gcry_err)
return grub_crypto_gcry_error (gcry_err);
@@ -481,7 +479,7 @@ recover_key (grub_disk_t source, grub_cryptodisk_t dev)
for (i = 0; i < ARRAY_SIZE (header.keys); i++)
{
struct grub_geli_key candidate_key;
grub_uint8_t key_hmac[GRUB_CRYPTO_MAX_MDLEN];
grub_uint8_t key_hmac[dev->hash->mdlen];
/* Check if keyslot is enabled. */
if (! (header.keys_used & (1 << i)))
@@ -502,7 +500,7 @@ recover_key (grub_disk_t source, grub_cryptodisk_t dev)
return grub_crypto_gcry_error (gcry_err);
gcry_err = grub_crypto_hmac_buffer (dev->hash, verify_key,
dev->hash->mdlen,
sizeof (verify_key),
&candidate_key,
(sizeof (candidate_key)
- sizeof (candidate_key.hmac)),

4
grub-core/disk/host.c
View File

@@ -20,13 +20,9 @@
/* When using the disk, make a reference to this module. Otherwise
the user will end up with a useless module :-). */
#include <config.h>
#include <config-util.h>
#include <grub/dl.h>
#include <grub/disk.h>
#include <grub/misc.h>
#include <grub/emu/hostdisk.h>
int grub_disk_host_i_want_a_reference;

11
grub-core/disk/i386/pc/biosdisk.c
View File

@@ -424,13 +424,6 @@ grub_biosdisk_open (const char *name, grub_disk_t disk)
}
disk->total_sectors = total_sectors;
/* Limit the max to 0x7f because of Phoenix EDD. */
disk->max_agglomerate = 0x7f >> GRUB_DISK_CACHE_BITS;
COMPILE_TIME_ASSERT ((0x7f >> GRUB_DISK_CACHE_BITS
<< (GRUB_DISK_SECTOR_BITS + GRUB_DISK_CACHE_BITS))
+ sizeof (struct grub_biosdisk_dap)
< GRUB_MEMORY_MACHINE_SCRATCH_SIZE);
disk->data = data;
return GRUB_ERR_NONE;
@@ -555,6 +548,10 @@ get_safe_sectors (grub_disk_t disk, grub_disk_addr_t sector)
size = sectors - offset;
/* Limit the max to 0x7f because of Phoenix EDD. */
if (size > ((0x7fU << GRUB_DISK_SECTOR_BITS) >> disk->log_sector_size))
size = ((0x7fU << GRUB_DISK_SECTOR_BITS) >> disk->log_sector_size);
return size;
}

83
grub-core/disk/ieee1275/ofdisk.c
View File

@@ -31,14 +31,11 @@ static grub_ieee1275_ihandle_t last_ihandle;
struct ofdisk_hash_ent
{
char *devpath;
char *open_path;
char *grub_devpath;
int is_boot;
int is_cdrom;
/* Pointer to shortest available name on nodes representing canonical names,
otherwise NULL. */
const char *shortest;
const char *grub_shortest;
struct ofdisk_hash_ent *next;
};
@@ -73,50 +70,12 @@ ofdisk_hash_add_real (char *devpath)
{
struct ofdisk_hash_ent *p;
struct ofdisk_hash_ent **head = &ofdisk_hash[ofdisk_hash_fn(devpath)];
const char *iptr;
char *optr;
p = grub_zalloc (sizeof (*p));
if (!p)
return NULL;
p->devpath = devpath;
p->grub_devpath = grub_malloc (sizeof ("ieee1275/")
+ 2 * grub_strlen (p->devpath));
if (!p->grub_devpath)
{
grub_free (p);
return NULL;
}
if (! grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_NO_PARTITION_0))
{
p->open_path = grub_malloc (grub_strlen (p->devpath) + 3);
if (!p->open_path)
{
grub_free (p->grub_devpath);
grub_free (p);
return NULL;
}
optr = grub_stpcpy (p->open_path, p->devpath);
*optr++ = ':';
*optr++ = '0';
*optr = '\0';
}
else
p->open_path = p->devpath;
optr = grub_stpcpy (p->grub_devpath, "ieee1275/");
for (iptr = p->devpath; *iptr; )
{
if (*iptr == ',')
*optr++ = '\\';
*optr++ = *iptr++;
}
*optr = 0;
p->next = *head;
*head = p;
return p;
@@ -145,8 +104,7 @@ ofdisk_hash_add (char *devpath, char *curcan)
if (!curcan)
{
p->shortest = p->devpath;
p->grub_shortest = p->grub_devpath;
p->shortest = devpath;
if (check_string_cdrom (devpath))
p->is_cdrom = 1;
return p;
@@ -167,10 +125,7 @@ ofdisk_hash_add (char *devpath, char *curcan)
{
if (!pcan->shortest
|| grub_strlen (pcan->shortest) > grub_strlen (devpath))
{
pcan->shortest = p->devpath;
pcan->grub_shortest = p->grub_devpath;
}
pcan->shortest = devpath;
}
return p;
@@ -333,8 +288,21 @@ grub_ofdisk_iterate (grub_disk_dev_iterate_hook_t hook, void *hook_data,
if (!ent->is_boot && ent->is_cdrom)
continue;
if (hook (ent->grub_shortest, hook_data))
return 1;
{
char buffer[sizeof ("ieee1275/") + 2 * grub_strlen (ent->shortest)];
const char *iptr;
char *optr;
optr = grub_stpcpy (buffer, "ieee1275/");
for (iptr = ent->shortest; *iptr; )
{
if (*iptr == ',')
*optr++ = '\\';
*optr++ = *iptr++;
}
*optr = 0;
if (hook (buffer, hook_data))
return 1;
}
}
}
return 0;
@@ -428,7 +396,7 @@ grub_ofdisk_open (const char *name, grub_disk_t disk)
if (!op)
return grub_errno;
disk->id = (unsigned long) op;
disk->data = op->open_path;
disk->data = op->devpath;
}
return 0;
@@ -460,7 +428,20 @@ grub_ofdisk_prepare (grub_disk_t disk, grub_disk_addr_t sector)
last_ihandle = 0;
last_devpath = NULL;
grub_ieee1275_open (disk->data, &last_ihandle);
if (! grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_NO_PARTITION_0))
{
char name2[grub_strlen (disk->data) + 3];
char *p;
grub_strcpy (name2, disk->data);
p = name2 + grub_strlen (name2);
*p++ = ':';
*p++ = '0';
*p = 0;
grub_ieee1275_open (name2, &last_ihandle);
}
else
grub_ieee1275_open (disk->data, &last_ihandle);
if (! last_ihandle)
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "can't open device");
last_devpath = disk->data;

4
grub-core/disk/loopback.c
View File

@@ -167,10 +167,6 @@ grub_loopback_open (const char *name, grub_disk_t disk)
/ GRUB_DISK_SECTOR_SIZE);
else
disk->total_sectors = GRUB_DISK_SIZE_UNKNOWN;
/* Avoid reading more than 512M. */
disk->max_agglomerate = 1 << (29 - GRUB_DISK_SECTOR_BITS
- GRUB_DISK_CACHE_BITS);
disk->id = (unsigned long) dev;
disk->data = dev;

6
grub-core/disk/luks.c
View File

@@ -316,8 +316,6 @@ luks_recover_key (grub_disk_t source,
grub_puts_ (N_("Attempting to decrypt master key..."));
keysize = grub_be_to_cpu32 (header.keyBytes);
if (keysize > GRUB_CRYPTODISK_MAX_KEYLEN)
return grub_error (GRUB_ERR_BAD_FS, "key is too long");
for (i = 0; i < ARRAY_SIZE (header.keyblock); i++)
if (grub_be_to_cpu32 (header.keyblock[i].active) == LUKS_KEY_ENABLED
@@ -346,8 +344,8 @@ luks_recover_key (grub_disk_t source,
for (i = 0; i < ARRAY_SIZE (header.keyblock); i++)
{
gcry_err_code_t gcry_err;
grub_uint8_t candidate_key[GRUB_CRYPTODISK_MAX_KEYLEN];
grub_uint8_t digest[GRUB_CRYPTODISK_MAX_KEYLEN];
grub_uint8_t candidate_key[keysize];
grub_uint8_t digest[keysize];
/* Check if keyslot is enabled. */
if (grub_be_to_cpu32 (header.keyblock[i].active) != LUKS_KEY_ENABLED)

71
grub-core/disk/mdraid_linux.c
View File

@@ -184,10 +184,9 @@ grub_mdraid_detect (grub_disk_t disk,
{
grub_disk_addr_t sector;
grub_uint64_t size;
struct grub_raid_super_09 *sb = NULL;
struct grub_raid_super_09 sb;
grub_uint32_t *uuid;
grub_uint32_t level;
struct grub_diskfilter_vg *ret;
/* The sector where the mdraid 0.90 superblock is stored, if available. */
size = grub_disk_get_size (disk);
@@ -196,31 +195,27 @@ grub_mdraid_detect (grub_disk_t disk,
return NULL;
sector = NEW_SIZE_SECTORS (size);
sb = grub_malloc (sizeof (*sb));
if (!sb)
if (grub_disk_read (disk, sector, 0, SB_BYTES, &sb))
return NULL;
if (grub_disk_read (disk, sector, 0, SB_BYTES, sb))
goto fail;
/* Look whether there is a mdraid 0.90 superblock. */
if (sb->md_magic != grub_cpu_to_md32_compile_time (SB_MAGIC))
if (sb.md_magic != grub_cpu_to_md32_compile_time (SB_MAGIC))
/* not 0.9x raid. */
goto fail;
return NULL;
if (sb->major_version != grub_cpu_to_md32_compile_time (0)
|| sb->minor_version != grub_cpu_to_md32_compile_time (90))
if (sb.major_version != grub_cpu_to_md32_compile_time (0)
|| sb.minor_version != grub_cpu_to_md32_compile_time (90))
/* Unsupported version. */
goto fail;
return NULL;
/* No need for explicit check that sb->size is 0 (unspecified) since
/* No need for explicit check that sb.size is 0 (unspecified) since
0 >= non-0 is false. */
if (((grub_disk_addr_t) grub_md_to_cpu32 (sb->size)) * 2 >= size)
goto fail;
if (((grub_disk_addr_t) grub_md_to_cpu32 (sb.size)) * 2 >= size)
return NULL;
/* FIXME: Check the checksum. */
level = grub_md_to_cpu32 (sb->level);
level = grub_md_to_cpu32 (sb.level);
/* Multipath. */
if ((int) level == -4)
level = 1;
@@ -230,43 +225,37 @@ grub_mdraid_detect (grub_disk_t disk,
{
grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
"unsupported RAID level: %d", level);
goto fail;
return NULL;
}
if (grub_md_to_cpu32 (sb->this_disk.number) == 0xffff
|| grub_md_to_cpu32 (sb->this_disk.number) == 0xfffe)
if (grub_md_to_cpu32 (sb.this_disk.number) == 0xffff
|| grub_md_to_cpu32 (sb.this_disk.number) == 0xfffe)
/* Spares aren't implemented. */
goto fail;
return NULL;
uuid = grub_malloc (16);
if (!uuid)
goto fail;
return NULL;
uuid[0] = grub_swap_bytes32 (sb->set_uuid0);
uuid[1] = grub_swap_bytes32 (sb->set_uuid1);
uuid[2] = grub_swap_bytes32 (sb->set_uuid2);
uuid[3] = grub_swap_bytes32 (sb->set_uuid3);
uuid[0] = grub_swap_bytes32 (sb.set_uuid0);
uuid[1] = grub_swap_bytes32 (sb.set_uuid1);
uuid[2] = grub_swap_bytes32 (sb.set_uuid2);
uuid[3] = grub_swap_bytes32 (sb.set_uuid3);
*start_sector = 0;
id->uuidlen = 0;
id->id = grub_md_to_cpu32 (sb->this_disk.number);
id->id = grub_md_to_cpu32 (sb.this_disk.number);
char buf[32];
grub_snprintf (buf, sizeof (buf), "md%d", grub_md_to_cpu32 (sb->md_minor));
ret = grub_diskfilter_make_raid (16, (char *) uuid,
grub_md_to_cpu32 (sb->raid_disks), buf,
(sb->size) ? ((grub_disk_addr_t)
grub_md_to_cpu32 (sb->size)) * 2
: sector,
grub_md_to_cpu32 (sb->chunk_size) >> 9,
grub_md_to_cpu32 (sb->layout),
level);
grub_free (sb);
return ret;
fail:
grub_free (sb);
return NULL;
grub_snprintf (buf, sizeof (buf), "md%d", grub_md_to_cpu32 (sb.md_minor));
return grub_diskfilter_make_raid (16, (char *) uuid,
grub_md_to_cpu32 (sb.raid_disks), buf,
(sb.size) ? ((grub_disk_addr_t)
grub_md_to_cpu32 (sb.size)) * 2
: sector,
grub_md_to_cpu32 (sb.chunk_size) >> 9,
grub_md_to_cpu32 (sb.layout),
level);
}
static struct grub_diskfilter grub_mdraid_dev = {

1
grub-core/disk/memdisk.c
View File

@@ -46,7 +46,6 @@ grub_memdisk_open (const char *name, grub_disk_t disk)
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "not a memdisk");
disk->total_sectors = memdisk_size / GRUB_DISK_SECTOR_SIZE;
disk->max_agglomerate = GRUB_DISK_MAX_MAX_AGGLOMERATE;
disk->id = (unsigned long) "mdsk";
return GRUB_ERR_NONE;

8
grub-core/disk/pata.c
View File

@@ -402,15 +402,9 @@ grub_pata_pciinit (grub_pci_device_t dev,
bar2 = grub_pci_read (addr);
/* Check if the BARs describe an IO region. */
if ((bar1 & 1) && (bar2 & 1) && (bar1 & ~3))
if ((bar1 & 1) && (bar2 & 1))
{
rega = bar1 & ~3;
addr = grub_pci_make_address (dev, GRUB_PCI_REG_COMMAND);
grub_pci_write_word (addr, grub_pci_read_word (addr)
| GRUB_PCI_COMMAND_IO_ENABLED
| GRUB_PCI_COMMAND_MEM_ENABLED
| GRUB_PCI_COMMAND_BUS_MASTER);
}
}

101
grub-core/disk/scsi.c
View File

@@ -606,13 +606,6 @@ grub_scsi_open (const char *name, grub_disk_t disk)
}
disk->total_sectors = scsi->last_block + 1;
/* PATA doesn't support more than 32K reads.
Not sure about AHCI and USB. If it's confirmed that either of
them can do bigger reads reliably this value can be moved to 'scsi'
structure. */
disk->max_agglomerate = 32768 >> (GRUB_DISK_SECTOR_BITS
+ GRUB_DISK_CACHE_BITS);
if (scsi->blocksize & (scsi->blocksize - 1) || !scsi->blocksize)
{
grub_free (scsi);
@@ -654,27 +647,40 @@ grub_scsi_read (grub_disk_t disk, grub_disk_addr_t sector,
scsi = disk->data;
grub_err_t err;
/* Depending on the type, select a read function. */
switch (scsi->devtype)
while (size)
{
case grub_scsi_devtype_direct:
if (sector >> 32)
err = grub_scsi_read16 (disk, sector, size, buf);
else
err = grub_scsi_read10 (disk, sector, size, buf);
if (err)
return err;
break;
/* PATA doesn't support more than 32K reads.
Not sure about AHCI and USB. If it's confirmed that either of
them can do bigger reads reliably this value can be moved to 'scsi'
structure. */
grub_size_t len = 32768 >> disk->log_sector_size;
grub_err_t err;
if (len > size)
len = size;
/* Depending on the type, select a read function. */
switch (scsi->devtype)
{
case grub_scsi_devtype_direct:
if (sector >> 32)
err = grub_scsi_read16 (disk, sector, len, buf);
else
err = grub_scsi_read10 (disk, sector, len, buf);
if (err)
return err;
break;
case grub_scsi_devtype_cdrom:
if (sector >> 32)
err = grub_scsi_read16 (disk, sector, size, buf);
else
err = grub_scsi_read12 (disk, sector, size, buf);
if (err)
return err;
break;
case grub_scsi_devtype_cdrom:
if (sector >> 32)
err = grub_scsi_read16 (disk, sector, len, buf);
else
err = grub_scsi_read12 (disk, sector, len, buf);
if (err)
return err;
break;
}
size -= len;
sector += len;
buf += len << disk->log_sector_size;
}
return GRUB_ERR_NONE;
@@ -712,10 +718,10 @@ grub_scsi_read (grub_disk_t disk, grub_disk_addr_t sector,
}
static grub_err_t
grub_scsi_write (grub_disk_t disk,
grub_disk_addr_t sector,
grub_size_t size,
const char *buf)
grub_scsi_write (grub_disk_t disk __attribute((unused)),
grub_disk_addr_t sector __attribute((unused)),
grub_size_t size __attribute((unused)),
const char *buf __attribute((unused)))
{
grub_scsi_t scsi;
@@ -724,18 +730,31 @@ grub_scsi_write (grub_disk_t disk,
if (scsi->devtype == grub_scsi_devtype_cdrom)
return grub_error (GRUB_ERR_IO, N_("cannot write to CD-ROM"));
grub_err_t err;
/* Depending on the type, select a read function. */
switch (scsi->devtype)
while (size)
{
case grub_scsi_devtype_direct:
if (sector >> 32)
err = grub_scsi_write16 (disk, sector, size, buf);
else
err = grub_scsi_write10 (disk, sector, size, buf);
if (err)
return err;
break;
/* PATA doesn't support more than 32K reads.
Not sure about AHCI and USB. If it's confirmed that either of
them can do bigger reads reliably this value can be moved to 'scsi'
structure. */
grub_size_t len = 32768 >> disk->log_sector_size;
grub_err_t err;
if (len > size)
len = size;
/* Depending on the type, select a read function. */
switch (scsi->devtype)
{
case grub_scsi_devtype_direct:
if (sector >> 32)
err = grub_scsi_write16 (disk, sector, len, buf);
else
err = grub_scsi_write10 (disk, sector, len, buf);
if (err)
return err;
break;
}
size -= len;
sector += len;
buf += len << disk->log_sector_size;
}
return GRUB_ERR_NONE;

1
grub-core/disk/uboot/ubootdisk.c
View File

@@ -47,7 +47,6 @@ grub_ubootdisk_register (struct device_info *newdev)
{
case DT_STOR_IDE:
case DT_STOR_SATA:
case DT_STOR_SCSI:
case DT_STOR_MMC:
case DT_STOR_USB:
/* hd */

21
grub-core/disk/usbms.c
View File

@@ -76,7 +76,7 @@ typedef struct grub_usbms_dev *grub_usbms_dev_t;
static grub_usbms_dev_t grub_usbms_devices[MAX_USBMS_DEVICES];
static int first_available_slot = 0;
static grub_usb_err_t
static grub_err_t
grub_usbms_cbi_cmd (grub_usb_device_t dev, int interface,
grub_uint8_t *cbicb)
{
@@ -86,7 +86,7 @@ grub_usbms_cbi_cmd (grub_usb_device_t dev, int interface,
GRUB_USBMS_CBI_CMD_SIZE, (char*)cbicb);
}
static grub_usb_err_t
static grub_err_t
grub_usbms_cbi_reset (grub_usb_device_t dev, int interface)
{
/* Prepare array with Command Block Reset (=CBR) */
@@ -108,13 +108,17 @@ grub_usbms_cbi_reset (grub_usb_device_t dev, int interface)
return grub_usbms_cbi_cmd (dev, interface, (grub_uint8_t *)&cbicb);
}
static grub_usb_err_t
static grub_err_t
grub_usbms_bo_reset (grub_usb_device_t dev, int interface)
{
return grub_usb_control_msg (dev, 0x21, 255, 0, interface, 0, 0);
grub_usb_err_t u;
u = grub_usb_control_msg (dev, 0x21, 255, 0, interface, 0, 0);
if (u)
return grub_error (GRUB_ERR_IO, "USB error %d", u);
return GRUB_ERR_NONE;
}
static grub_usb_err_t
static grub_err_t
grub_usbms_reset (grub_usbms_dev_t dev)
{
if (dev->protocol == GRUB_USBMS_PROTOCOL_BULK)
@@ -145,7 +149,7 @@ grub_usbms_attach (grub_usb_device_t usbdev, int configno, int interfno)
int j;
grub_uint8_t luns = 0;
unsigned curnum;
grub_usb_err_t err = GRUB_USB_ERR_NONE;
grub_usb_err_t err = GRUB_ERR_NONE;
grub_boot_time ("Attaching USB mass storage");
@@ -567,11 +571,8 @@ grub_usbms_transfer_cbi (struct grub_scsi *scsi, grub_size_t cmdsize, char *cmd,
}
}
}
if (err)
return grub_error (GRUB_ERR_IO, "USB error %d", err);
return GRUB_ERR_NONE;
return err;
}

458
grub-core/disk/xen/xendisk.c
View File

@@ -1,458 +0,0 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2013 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/disk.h>
#include <grub/dl.h>
#include <grub/mm.h>
#include <grub/types.h>
#include <grub/misc.h>
#include <grub/err.h>
#include <grub/term.h>
#include <grub/i18n.h>
#include <grub/xen.h>
#include <grub/time.h>
#include <xen/io/blkif.h>
struct virtdisk
{
int handle;
char *fullname;
char *backend_dir;
char *frontend_dir;
struct blkif_sring *shared_page;
struct blkif_front_ring ring;
grub_xen_grant_t grant;
grub_xen_evtchn_t evtchn;
void *dma_page;
grub_xen_grant_t dma_grant;
};
#define xen_wmb() mb()
#define xen_mb() mb()
static struct virtdisk *virtdisks;
static grub_size_t vdiskcnt;
static int
grub_virtdisk_iterate (grub_disk_dev_iterate_hook_t hook, void *hook_data,
grub_disk_pull_t pull)
{
grub_size_t i;
if (pull != GRUB_DISK_PULL_NONE)
return 0;
for (i = 0; i < vdiskcnt; i++)
if (hook (virtdisks[i].fullname, hook_data))
return 1;
return 0;
}
static grub_err_t
grub_virtdisk_open (const char *name, grub_disk_t disk)
{
grub_size_t i;
grub_uint32_t secsize;
char fdir[200];
char *buf;
for (i = 0; i < vdiskcnt; i++)
if (grub_strcmp (name, virtdisks[i].fullname) == 0)
break;
if (i == vdiskcnt)
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "not a virtdisk");
disk->data = &virtdisks[i];
disk->id = i;
grub_snprintf (fdir, sizeof (fdir), "%s/sectors", virtdisks[i].backend_dir);
buf = grub_xenstore_get_file (fdir, NULL);
if (!buf)
return grub_errno;
disk->total_sectors = grub_strtoull (buf, 0, 10);
if (grub_errno)
return grub_errno;
grub_snprintf (fdir, sizeof (fdir), "%s/sector-size",
virtdisks[i].backend_dir);
buf = grub_xenstore_get_file (fdir, NULL);
if (!buf)
return grub_errno;
secsize = grub_strtoull (buf, 0, 10);
if (grub_errno)
return grub_errno;
if ((secsize & (secsize - 1)) || !secsize || secsize < 512
|| secsize > GRUB_XEN_PAGE_SIZE)
return grub_error (GRUB_ERR_IO, "unsupported sector size %d", secsize);
for (disk->log_sector_size = 0;
(1U << disk->log_sector_size) < secsize; disk->log_sector_size++);
disk->total_sectors >>= disk->log_sector_size - 9;
return GRUB_ERR_NONE;
}
static void
grub_virtdisk_close (grub_disk_t disk __attribute__ ((unused)))
{
}
static grub_err_t
grub_virtdisk_read (grub_disk_t disk, grub_disk_addr_t sector,
grub_size_t size, char *buf)
{
struct virtdisk *data = disk->data;
while (size)
{
grub_size_t cur;
struct blkif_request *req;
struct blkif_response *resp;
int sta = 0;
struct evtchn_send send;
cur = size;
if (cur > (unsigned) (GRUB_XEN_PAGE_SIZE >> disk->log_sector_size))
cur = GRUB_XEN_PAGE_SIZE >> disk->log_sector_size;
while (RING_FULL (&data->ring))
grub_xen_sched_op (SCHEDOP_yield, 0);
req = RING_GET_REQUEST (&data->ring, data->ring.req_prod_pvt);
req->operation = BLKIF_OP_READ;
req->nr_segments = 1;
req->handle = data->handle;
req->id = 0;
req->sector_number = sector << (disk->log_sector_size - 9);
req->seg[0].gref = data->dma_grant;
req->seg[0].first_sect = 0;
req->seg[0].last_sect = (cur << (disk->log_sector_size - 9)) - 1;
data->ring.req_prod_pvt++;
RING_PUSH_REQUESTS (&data->ring);
mb ();
send.port = data->evtchn;
grub_xen_event_channel_op (EVTCHNOP_send, &send);
while (!RING_HAS_UNCONSUMED_RESPONSES (&data->ring))
{
grub_xen_sched_op (SCHEDOP_yield, 0);
mb ();
}
while (1)
{
int wtd;
RING_FINAL_CHECK_FOR_RESPONSES (&data->ring, wtd);
if (!wtd)
break;
resp = RING_GET_RESPONSE (&data->ring, data->ring.rsp_cons);
data->ring.rsp_cons++;
if (resp->status)
sta = resp->status;
}
if (sta)
return grub_error (GRUB_ERR_IO, "read failed");
grub_memcpy (buf, data->dma_page, cur << disk->log_sector_size);
size -= cur;
sector += cur;
buf += cur << disk->log_sector_size;
}
return GRUB_ERR_NONE;
}
static grub_err_t
grub_virtdisk_write (grub_disk_t disk, grub_disk_addr_t sector,
grub_size_t size, const char *buf)
{
struct virtdisk *data = disk->data;
while (size)
{
grub_size_t cur;
struct blkif_request *req;
struct blkif_response *resp;
int sta = 0;
struct evtchn_send send;
cur = size;
if (cur > (unsigned) (GRUB_XEN_PAGE_SIZE >> disk->log_sector_size))
cur = GRUB_XEN_PAGE_SIZE >> disk->log_sector_size;
grub_memcpy (data->dma_page, buf, cur << disk->log_sector_size);
while (RING_FULL (&data->ring))
grub_xen_sched_op (SCHEDOP_yield, 0);
req = RING_GET_REQUEST (&data->ring, data->ring.req_prod_pvt);
req->operation = BLKIF_OP_WRITE;
req->nr_segments = 1;
req->handle = data->handle;
req->id = 0;
req->sector_number = sector << (disk->log_sector_size - 9);
req->seg[0].gref = data->dma_grant;
req->seg[0].first_sect = 0;
req->seg[0].last_sect = (cur << (disk->log_sector_size - 9)) - 1;
data->ring.req_prod_pvt++;
RING_PUSH_REQUESTS (&data->ring);
mb ();
send.port = data->evtchn;
grub_xen_event_channel_op (EVTCHNOP_send, &send);
while (!RING_HAS_UNCONSUMED_RESPONSES (&data->ring))
{
grub_xen_sched_op (SCHEDOP_yield, 0);
mb ();
}
while (1)
{
int wtd;
RING_FINAL_CHECK_FOR_RESPONSES (&data->ring, wtd);
if (!wtd)
break;
resp = RING_GET_RESPONSE (&data->ring, data->ring.rsp_cons);
data->ring.rsp_cons++;
if (resp->status)
sta = resp->status;
}
if (sta)
return grub_error (GRUB_ERR_IO, "write failed");
size -= cur;
sector += cur;
buf += cur << disk->log_sector_size;
}
return GRUB_ERR_NONE;
}
static struct grub_disk_dev grub_virtdisk_dev = {
.name = "xen",
.id = GRUB_DISK_DEVICE_XEN,
.iterate = grub_virtdisk_iterate,
.open = grub_virtdisk_open,
.close = grub_virtdisk_close,
.read = grub_virtdisk_read,
.write = grub_virtdisk_write,
.next = 0
};
static int
count (const char *dir __attribute__ ((unused)), void *data)
{
grub_size_t *ctr = data;
(*ctr)++;
return 0;
}
static int
fill (const char *dir, void *data)
{
grub_size_t *ctr = data;
domid_t dom;
/* "dir" is just a number, at most 19 characters. */
char fdir[200];
char num[20];
grub_err_t err;
void *buf;
struct evtchn_alloc_unbound alloc_unbound;
/* Shouldn't happen unles some hotplug happened. */
if (vdiskcnt >= *ctr)
return 1;
virtdisks[vdiskcnt].handle = grub_strtoul (dir, 0, 10);
if (grub_errno)
{
grub_errno = 0;
return 0;
}
virtdisks[vdiskcnt].fullname = 0;
virtdisks[vdiskcnt].backend_dir = 0;
grub_snprintf (fdir, sizeof (fdir), "device/vbd/%s/backend", dir);
virtdisks[vdiskcnt].backend_dir = grub_xenstore_get_file (fdir, NULL);
if (!virtdisks[vdiskcnt].backend_dir)
goto out_fail_1;
grub_snprintf (fdir, sizeof (fdir), "%s/dev",
virtdisks[vdiskcnt].backend_dir);
buf = grub_xenstore_get_file (fdir, NULL);
if (!buf)
{
grub_errno = 0;
virtdisks[vdiskcnt].fullname = grub_xasprintf ("xenid/%s", dir);
}
else
{
virtdisks[vdiskcnt].fullname = grub_xasprintf ("xen/%s", (char *) buf);
grub_free (buf);
}
if (!virtdisks[vdiskcnt].fullname)
goto out_fail_1;
grub_snprintf (fdir, sizeof (fdir), "device/vbd/%s/backend-id", dir);
buf = grub_xenstore_get_file (fdir, NULL);
if (!buf)
goto out_fail_1;
dom = grub_strtoul (buf, 0, 10);
grub_free (buf);
if (grub_errno)
goto out_fail_1;
virtdisks[vdiskcnt].shared_page =
grub_xen_alloc_shared_page (dom, &virtdisks[vdiskcnt].grant);
if (!virtdisks[vdiskcnt].shared_page)
goto out_fail_1;
virtdisks[vdiskcnt].dma_page =
grub_xen_alloc_shared_page (dom, &virtdisks[vdiskcnt].dma_grant);
if (!virtdisks[vdiskcnt].dma_page)
goto out_fail_2;
alloc_unbound.dom = DOMID_SELF;
alloc_unbound.remote_dom = dom;
grub_xen_event_channel_op (EVTCHNOP_alloc_unbound, &alloc_unbound);
virtdisks[vdiskcnt].evtchn = alloc_unbound.port;
SHARED_RING_INIT (virtdisks[vdiskcnt].shared_page);
FRONT_RING_INIT (&virtdisks[vdiskcnt].ring, virtdisks[vdiskcnt].shared_page,
GRUB_XEN_PAGE_SIZE);
grub_snprintf (fdir, sizeof (fdir), "device/vbd/%s/ring-ref", dir);
grub_snprintf (num, sizeof (num), "%u", virtdisks[vdiskcnt].grant);
err = grub_xenstore_write_file (fdir, num, grub_strlen (num));
if (err)
goto out_fail_3;
grub_snprintf (fdir, sizeof (fdir), "device/vbd/%s/event-channel", dir);
grub_snprintf (num, sizeof (num), "%u", virtdisks[vdiskcnt].evtchn);
err = grub_xenstore_write_file (fdir, num, grub_strlen (num));
if (err)
goto out_fail_3;
grub_snprintf (fdir, sizeof (fdir), "device/vbd/%s/protocol", dir);
err = grub_xenstore_write_file (fdir, XEN_IO_PROTO_ABI_NATIVE,
grub_strlen (XEN_IO_PROTO_ABI_NATIVE));
if (err)
goto out_fail_3;
struct gnttab_dump_table dt;
dt.dom = DOMID_SELF;
grub_xen_grant_table_op (GNTTABOP_dump_table, (void *) &dt, 1);
grub_snprintf (fdir, sizeof (fdir), "device/vbd/%s/state", dir);
err = grub_xenstore_write_file (fdir, "3", 1);
if (err)
goto out_fail_3;
while (1)
{
grub_snprintf (fdir, sizeof (fdir), "%s/state",
virtdisks[vdiskcnt].backend_dir);
buf = grub_xenstore_get_file (fdir, NULL);
if (!buf)
goto out_fail_3;
if (grub_strcmp (buf, "2") != 0)
break;
grub_free (buf);
grub_xen_sched_op (SCHEDOP_yield, 0);
}
grub_dprintf ("xen", "state=%s\n", (char *) buf);
grub_free (buf);
grub_snprintf (fdir, sizeof (fdir), "device/vbd/%s", dir);
virtdisks[vdiskcnt].frontend_dir = grub_strdup (fdir);
vdiskcnt++;
return 0;
out_fail_3:
grub_xen_free_shared_page (virtdisks[vdiskcnt].dma_page);
out_fail_2:
grub_xen_free_shared_page (virtdisks[vdiskcnt].shared_page);
out_fail_1:
grub_free (virtdisks[vdiskcnt].backend_dir);
grub_free (virtdisks[vdiskcnt].fullname);
grub_errno = 0;
return 0;
}
void
grub_xendisk_init (void)
{
grub_size_t ctr = 0;
if (grub_xenstore_dir ("device/vbd", count, &ctr))
grub_errno = 0;
if (!ctr)
return;
virtdisks = grub_malloc (ctr * sizeof (virtdisks[0]));
if (!virtdisks)
return;
if (grub_xenstore_dir ("device/vbd", fill, &ctr))
grub_errno = 0;
grub_disk_dev_register (&grub_virtdisk_dev);
}
void
grub_xendisk_fini (void)
{
char fdir[200];
unsigned i;
for (i = 0; i < vdiskcnt; i++)
{
char *buf;
struct evtchn_close close_op = {.port = virtdisks[i].evtchn };
grub_snprintf (fdir, sizeof (fdir), "%s/state",
virtdisks[i].frontend_dir);
grub_xenstore_write_file (fdir, "6", 1);
while (1)
{
grub_snprintf (fdir, sizeof (fdir), "%s/state",
virtdisks[i].backend_dir);
buf = grub_xenstore_get_file (fdir, NULL);
grub_dprintf ("xen", "state=%s\n", (char *) buf);
if (!buf || grub_strcmp (buf, "6") == 0)
break;
grub_free (buf);
grub_xen_sched_op (SCHEDOP_yield, 0);
}
grub_free (buf);
grub_snprintf (fdir, sizeof (fdir), "%s/ring-ref",
virtdisks[i].frontend_dir);
grub_xenstore_write_file (fdir, NULL, 0);
grub_snprintf (fdir, sizeof (fdir), "%s/event-channel",
virtdisks[i].frontend_dir);
grub_xenstore_write_file (fdir, NULL, 0);
grub_xen_free_shared_page (virtdisks[i].dma_page);
grub_xen_free_shared_page (virtdisks[i].shared_page);
grub_xen_event_channel_op (EVTCHNOP_close, &close_op);
/* Prepare for handoff. */
grub_snprintf (fdir, sizeof (fdir), "%s/state",
virtdisks[i].frontend_dir);
grub_xenstore_write_file (fdir, "1", 1);
}
}

21
grub-core/efiemu/prepare.c
View File

@@ -122,10 +122,7 @@ SUFFIX (grub_efiemu_crc) (void)
int handle;
grub_off_t off;
struct SUFFIX (grub_efiemu_runtime_services) *runtime_services;
grub_uint32_t crc32_val;
if (GRUB_MD_CRC32->mdlen != 4)
return grub_error (GRUB_ERR_BUG, "incorrect mdlen");
grub_uint8_t crc32_context[GRUB_MD_CRC32->contextsize];
/* compute CRC32 of runtime_services */
err = grub_efiemu_resolve_symbol ("efiemu_runtime_services",
@@ -137,11 +134,12 @@ SUFFIX (grub_efiemu_crc) (void)
((grub_uint8_t *) grub_efiemu_mm_obtain_request (handle) + off);
runtime_services->hdr.crc32 = 0;
GRUB_MD_CRC32->init(crc32_context);
GRUB_MD_CRC32->write(crc32_context, runtime_services, runtime_services->hdr.header_size);
GRUB_MD_CRC32->final(crc32_context);
grub_crypto_hash (GRUB_MD_CRC32, &crc32_val,
runtime_services, runtime_services->hdr.header_size);
runtime_services->hdr.crc32 =
grub_be_to_cpu32(crc32_val);
grub_be_to_cpu32(*(grub_uint32_t*)GRUB_MD_CRC32->read(crc32_context));
err = grub_efiemu_resolve_symbol ("efiemu_system_table", &handle, &off);
if (err)
@@ -149,11 +147,12 @@ SUFFIX (grub_efiemu_crc) (void)
/* compute CRC32 of system table */
SUFFIX (grub_efiemu_system_table)->hdr.crc32 = 0;
grub_crypto_hash (GRUB_MD_CRC32, &crc32_val,
SUFFIX (grub_efiemu_system_table),
SUFFIX (grub_efiemu_system_table)->hdr.header_size);
GRUB_MD_CRC32->init(crc32_context);
GRUB_MD_CRC32->write(crc32_context, SUFFIX (grub_efiemu_system_table),
SUFFIX (grub_efiemu_system_table)->hdr.header_size);
GRUB_MD_CRC32->final(crc32_context);
SUFFIX (grub_efiemu_system_table)->hdr.crc32 =
grub_be_to_cpu32(crc32_val);
grub_be_to_cpu32(*(grub_uint32_t*)GRUB_MD_CRC32->read(crc32_context));
grub_dprintf ("efiemu","system_table = %p, runtime_services = %p\n",
SUFFIX (grub_efiemu_system_table), runtime_services);

6
grub-core/efiemu/runtime/config.h
View File

@@ -19,18 +19,16 @@
#define GRUB_TYPES_CPU_HEADER 1
#ifdef __i386__
#ifdef ELF32
# define SIZEOF_VOID_P 4
# define SIZEOF_LONG 4
# define GRUB_TARGET_SIZEOF_VOID_P 4
# define GRUB_TARGET_SIZEOF_LONG 4
# define EFI_FUNC(x) x
#elif defined (__x86_64__)
#else
# define SIZEOF_VOID_P 8
# define SIZEOF_LONG 8
# define GRUB_TARGET_SIZEOF_VOID_P 8
# define GRUB_TARGET_SIZEOF_LONG 8
# define EFI_FUNC(x) x ## _real
#else
#error "Unknown architecture"
#endif

76
grub-core/font/font.c
View File

@@ -33,7 +33,7 @@
GRUB_MOD_LICENSE ("GPLv3+");
#if HAVE_FONT_SOURCE
#ifdef USE_ASCII_FALLBACK
#include "ascii.h"
#endif
@@ -110,65 +110,43 @@ static struct grub_font null_font;
/* Flag to ensure module is initialized only once. */
static grub_uint8_t font_loader_initialized;
#if HAVE_FONT_SOURCE
static struct grub_font_glyph *ascii_font_glyph[ASCII_NUM];
static struct grub_font_glyph *arrows_font_glyph[ARROWS_NUM];
static struct grub_font_glyph *lines_font_glyph[LINES_NUM];
static void
init_fallback (struct grub_font_glyph **glyphs, const unsigned char *stored,
grub_uint32_t len)
{
grub_uint32_t current;
for (current = 0; current < len; current++)
{
glyphs[current] =
grub_malloc (sizeof (struct grub_font_glyph) + ASCII_BITMAP_SIZE);
if (!glyphs[current])
{
grub_errno = GRUB_ERR_NONE;
continue;
}
glyphs[current]->width = 8;
glyphs[current]->height = 16;
glyphs[current]->offset_x = 0;
glyphs[current]->offset_y = -2;
glyphs[current]->device_width = 8;
glyphs[current]->font = NULL;
grub_memcpy (glyphs[current]->bitmap,
&stored[current * ASCII_BITMAP_SIZE],
ASCII_BITMAP_SIZE);
}
}
#ifdef USE_ASCII_FALLBACK
static struct grub_font_glyph *ascii_font_glyph[0x80];
#endif
static struct grub_font_glyph *
ascii_glyph_lookup (grub_uint32_t code)
{
#if HAVE_FONT_SOURCE
static int ascii_fallback_initialized = 0;
struct grub_font_glyph **p;
#ifdef USE_ASCII_FALLBACK
static int ascii_failback_initialized = 0;
if (code < ASCII_NUM)
p = &ascii_font_glyph[code];
else if (code >= ARROWS_START && code < ARROWS_START + ARROWS_NUM)
p = &arrows_font_glyph[code - ARROWS_START];
else if (code >= LINES_START && code < LINES_START + LINES_NUM)
p = &lines_font_glyph[code - LINES_START];
else
if (code >= 0x80)
return NULL;
if (ascii_fallback_initialized == 0)
if (ascii_failback_initialized == 0)
{
init_fallback (ascii_font_glyph, ascii_bitmaps, ASCII_NUM);
init_fallback (arrows_font_glyph, arrows_bitmaps, ARROWS_NUM);
init_fallback (lines_font_glyph, lines_bitmaps, LINES_NUM);
ascii_fallback_initialized = 1;
int current;
for (current = 0; current < 0x80; current++)
{
ascii_font_glyph[current] =
grub_malloc (sizeof (struct grub_font_glyph) + ASCII_BITMAP_SIZE);
ascii_font_glyph[current]->width = 8;
ascii_font_glyph[current]->height = 16;
ascii_font_glyph[current]->offset_x = 0;
ascii_font_glyph[current]->offset_y = -2;
ascii_font_glyph[current]->device_width = 8;
ascii_font_glyph[current]->font = NULL;
grub_memcpy (ascii_font_glyph[current]->bitmap,
&ascii_bitmaps[current * ASCII_BITMAP_SIZE],
ASCII_BITMAP_SIZE);
}
ascii_failback_initialized = 1;
}
return *p;
return ascii_font_glyph[code];
#else
(void) code;
return NULL;

1
grub-core/fs/affs.c
View File

@@ -565,6 +565,7 @@ grub_affs_dir_iter (const char *filename, enum grub_fshelp_filetype filetype,
info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
info.mtimeset = 1;
info.mtime = aftime2ctime (&node->di.mtime);
info.size = grub_be_to_cpu32 (node->di.size);
grub_free (node);
return ctx->hook (filename, &info, ctx->hook_data);
}

13
grub-core/fs/archelp.c
View File

@@ -67,7 +67,6 @@ handle_symlink (struct grub_archelp_data *data,
grub_size_t prefixlen;
char *rest;
char *linktarget;
grub_size_t linktarget_len;
*restart = 0;
@@ -97,8 +96,7 @@ handle_symlink (struct grub_archelp_data *data,
return grub_errno;
if (linktarget[0] == '\0')
return GRUB_ERR_NONE;
linktarget_len = grub_strlen (linktarget);
target = grub_malloc (linktarget_len + grub_strlen (*name) + 2);
target = grub_malloc (grub_strlen (linktarget) + grub_strlen (*name) + 2);
if (!target)
return grub_errno;
@@ -123,7 +121,7 @@ handle_symlink (struct grub_archelp_data *data,
grub_memcpy (target, *name, prefixlen);
target[prefixlen-1] = '/';
}
grub_strcpy (target + prefixlen + linktarget_len, rest);
grub_strcat (target, rest);
grub_dprintf ("archelp", "symlink redirected %s to %s\n",
*name, target);
grub_free (*name);
@@ -157,9 +155,10 @@ grub_archelp_dir (struct grub_archelp_data *data,
{
grub_int32_t mtime;
grub_uint32_t mode;
grub_uint64_t size;
grub_err_t err;
if (arcops->find_file (data, &name, &mtime, &mode))
if (arcops->find_file (data, &name, &mtime, &mode, &size))
goto fail;
if (mode == GRUB_ARCHELP_ATTR_END)
@@ -191,6 +190,7 @@ grub_archelp_dir (struct grub_archelp_data *data,
info.mtime = mtime;
info.mtimeset = 1;
}
info.size = size;
if (hook (n, &info, hook_data))
{
grub_free (name);
@@ -250,8 +250,9 @@ grub_archelp_open (struct grub_archelp_data *data,
{
grub_uint32_t mode;
int restart;
grub_uint64_t size;
if (arcops->find_file (data, &fn, NULL, &mode))
if (arcops->find_file (data, &fn, NULL, &mode, &size))
goto fail;
if (mode == GRUB_ARCHELP_ATTR_END)

1
grub-core/fs/bfs.c
View File

@@ -889,6 +889,7 @@ grub_bfs_dir_iter (const char *name, grub_uint64_t value,
info.mtime = grub_bfs_to_cpu64 (ino.mtime) >> 16;
#endif
info.dir = ((grub_bfs_to_cpu32 (ino.mode) & ATTR_TYPE) == ATTR_DIR);
info.size = grub_bfs_to_cpu64 (ino.size);
return ctx->hook (name, &info, ctx->hook_data);
}

136
grub-core/fs/btrfs.c
View File

@@ -1,7 +1,7 @@
/* btrfs.c - B-tree file system. */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2010,2011,2012,2013 Free Software Foundation, Inc.
* Copyright (C) 2010 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
@@ -28,7 +28,6 @@
#include <grub/deflate.h>
#include <minilzo.h>
#include <grub/i18n.h>
#include <grub/btrfs.h>
GRUB_MOD_LICENSE ("GPLv3+");
@@ -107,6 +106,24 @@ struct grub_btrfs_data
struct grub_btrfs_extent_data *extent;
};
enum
{
GRUB_BTRFS_ITEM_TYPE_INODE_ITEM = 0x01,
GRUB_BTRFS_ITEM_TYPE_INODE_REF = 0x0c,
GRUB_BTRFS_ITEM_TYPE_DIR_ITEM = 0x54,
GRUB_BTRFS_ITEM_TYPE_EXTENT_ITEM = 0x6c,
GRUB_BTRFS_ITEM_TYPE_ROOT_ITEM = 0x84,
GRUB_BTRFS_ITEM_TYPE_DEVICE = 0xd8,
GRUB_BTRFS_ITEM_TYPE_CHUNK = 0xe4
};
struct grub_btrfs_key
{
grub_uint64_t object_id;
grub_uint8_t type;
grub_uint64_t offset;
} __attribute__ ((packed));
struct grub_btrfs_chunk_item
{
grub_uint64_t size;
@@ -171,6 +188,13 @@ struct grub_btrfs_leaf_descriptor
} *data;
};
struct grub_btrfs_root_item
{
grub_uint8_t dummy[0xb0];
grub_uint64_t tree;
grub_uint64_t inode;
};
struct grub_btrfs_time
{
grub_int64_t sec;
@@ -911,6 +935,7 @@ grub_btrfs_lzo_decompress(char *ibuf, grub_size_t isize, grub_off_t off,
{
grub_uint32_t total_size, cblock_size;
grub_size_t ret = 0;
unsigned char buf[GRUB_BTRFS_LZO_BLOCK_SIZE];
char *ibuf0 = ibuf;
total_size = grub_le_to_cpu32 (grub_get_unaligned32 (ibuf));
@@ -954,21 +979,13 @@ grub_btrfs_lzo_decompress(char *ibuf, grub_size_t isize, grub_off_t off,
if (off > 0 || osize < GRUB_BTRFS_LZO_BLOCK_SIZE)
{
grub_size_t to_copy = GRUB_BTRFS_LZO_BLOCK_SIZE - off;
grub_uint8_t *buf;
if (to_copy > osize)
to_copy = osize;
buf = grub_malloc (GRUB_BTRFS_LZO_BLOCK_SIZE);
if (!buf)
return -1;
if (lzo1x_decompress_safe ((lzo_bytep)ibuf, cblock_size, buf, &usize,
NULL) != LZO_E_OK)
{
grub_free (buf);
return -1;
}
return -1;
if (to_copy > usize)
to_copy = usize;
@@ -979,8 +996,6 @@ grub_btrfs_lzo_decompress(char *ibuf, grub_size_t isize, grub_off_t off,
obuf += to_copy;
ibuf += cblock_size;
off = 0;
grub_free (buf);
continue;
}
@@ -1181,40 +1196,6 @@ grub_btrfs_extent_read (struct grub_btrfs_data *data,
return pos - pos0;
}
static grub_err_t
get_root (struct grub_btrfs_data *data, struct grub_btrfs_key *key,
grub_uint64_t *tree, grub_uint8_t *type)
{
grub_err_t err;
grub_disk_addr_t elemaddr;
grub_size_t elemsize;
struct grub_btrfs_key key_out, key_in;
struct grub_btrfs_root_item ri;
key_in.object_id = GRUB_BTRFS_ROOT_VOL_OBJECTID;
key_in.offset = 0;
key_in.type = GRUB_BTRFS_ITEM_TYPE_ROOT_ITEM;
err = lower_bound (data, &key_in, &key_out,
data->sblock.root_tree,
&elemaddr, &elemsize, NULL, 0);
if (err)
return err;
if (key_in.object_id != key_out.object_id
|| key_in.type != key_out.type
|| key_in.offset != key_out.offset)
return grub_error (GRUB_ERR_BAD_FS, "no root");
err = grub_btrfs_read_logical (data, elemaddr, &ri,
sizeof (ri), 0);
if (err)
return err;
key->type = GRUB_BTRFS_ITEM_TYPE_DIR_ITEM;
key->offset = 0;
key->object_id = grub_cpu_to_le64_compile_time (GRUB_BTRFS_OBJECT_ID_CHUNK);
*tree = ri.tree;
*type = GRUB_BTRFS_DIR_ITEM_TYPE_DIRECTORY;
return GRUB_ERR_NONE;
}
static grub_err_t
find_path (struct grub_btrfs_data *data,
const char *path, struct grub_btrfs_key *key,
@@ -1227,31 +1208,42 @@ find_path (struct grub_btrfs_data *data,
grub_size_t allocated = 0;
struct grub_btrfs_dir_item *direl = NULL;
struct grub_btrfs_key key_out;
int skip_default;
const char *ctoken;
grub_size_t ctokenlen;
char *path_alloc = NULL;
char *origpath = NULL;
unsigned symlinks_max = 32;
err = get_root (data, key, tree, type);
if (err)
return err;
*type = GRUB_BTRFS_DIR_ITEM_TYPE_DIRECTORY;
*tree = data->sblock.root_tree;
key->object_id = data->sblock.root_dir_objectid;
key->type = GRUB_BTRFS_ITEM_TYPE_DIR_ITEM;
key->offset = 0;
skip_default = 1;
origpath = grub_strdup (path);
if (!origpath)
return grub_errno;
while (1)
{
while (path[0] == '/')
path++;
if (!path[0])
break;
slash = grub_strchr (path, '/');
if (!slash)
slash = path + grub_strlen (path);
ctoken = path;
ctokenlen = slash - path;
if (!skip_default)
{
while (path[0] == '/')
path++;
if (!path[0])
break;
slash = grub_strchr (path, '/');
if (!slash)
slash = path + grub_strlen (path);
ctoken = path;
ctokenlen = slash - path;
}
else
{
ctoken = "default";
ctokenlen = sizeof ("default") - 1;
}
if (*type != GRUB_BTRFS_DIR_ITEM_TYPE_DIRECTORY)
{
@@ -1262,8 +1254,10 @@ find_path (struct grub_btrfs_data *data,
if (ctokenlen == 1 && ctoken[0] == '.')
{
path = slash;
continue;
if (!skip_default)
path = slash;
skip_default = 0;
continue;
}
if (ctokenlen == 2 && ctoken[0] == '.' && ctoken[1] == '.')
{
@@ -1293,7 +1287,9 @@ find_path (struct grub_btrfs_data *data,
*type = GRUB_BTRFS_DIR_ITEM_TYPE_DIRECTORY;
key->object_id = key_out.offset;
path = slash;
if (!skip_default)
path = slash;
skip_default = 0;
continue;
}
@@ -1363,7 +1359,9 @@ find_path (struct grub_btrfs_data *data,
return err;
}
path = slash;
if (!skip_default)
path = slash;
skip_default = 0;
if (cdirel->type == GRUB_BTRFS_DIR_ITEM_TYPE_SYMLINK)
{
struct grub_btrfs_inode inode;
@@ -1413,9 +1411,12 @@ find_path (struct grub_btrfs_data *data,
path = path_alloc = tmp;
if (path[0] == '/')
{
err = get_root (data, key, tree, type);
if (err)
return err;
*type = GRUB_BTRFS_DIR_ITEM_TYPE_DIRECTORY;
*tree = data->sblock.root_tree;
key->object_id = data->sblock.root_dir_objectid;
key->type = GRUB_BTRFS_ITEM_TYPE_DIR_ITEM;
key->offset = 0;
skip_default = 1;
}
continue;
}
@@ -1579,6 +1580,7 @@ grub_btrfs_dir (grub_device_t device, const char *path,
else
{
info.mtime = grub_le_to_cpu64 (inode.mtime.sec);
info.size = grub_le_to_cpu64 (inode.size);
info.mtimeset = 1;
}
c = cdirel->name[grub_le_to_cpu16 (cdirel->n)];

12
grub-core/fs/cbfs.c
View File

@@ -44,7 +44,8 @@ struct grub_archelp_data
static grub_err_t
grub_cbfs_find_file (struct grub_archelp_data *data, char **name,
grub_int32_t *mtime,
grub_uint32_t *mode)
grub_uint32_t *mode,
grub_uint64_t *size)
{
grub_size_t offset;
for (;;
@@ -71,6 +72,7 @@ grub_cbfs_find_file (struct grub_archelp_data *data, char **name,
return GRUB_ERR_NONE;
}
data->size = grub_be_to_cpu32 (hd.len);
*size = grub_be_to_cpu32 (hd.len);
(void) mtime;
offset = grub_be_to_cpu32 (hd.offset);
@@ -267,8 +269,7 @@ grub_cbfs_close (grub_file_t file)
return grub_errno;
}
#if (defined (__i386__) || defined (__x86_64__)) && !defined (GRUB_UTIL) \
&& !defined (GRUB_MACHINE_EMU) && !defined (GRUB_MACHINE_XEN)
#if (defined (__i386__) || defined (__x86_64__)) && !defined (GRUB_UTIL) && !defined (GRUB_MACHINE_EMU)
static char *cbfsdisk_addr;
static grub_off_t cbfsdisk_size = 0;
@@ -290,7 +291,6 @@ grub_cbfsdisk_open (const char *name, grub_disk_t disk)
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "not a cbfsdisk");
disk->total_sectors = cbfsdisk_size / GRUB_DISK_SECTOR_SIZE;
disk->max_agglomerate = GRUB_DISK_MAX_MAX_AGGLOMERATE;
disk->id = (unsigned long) "cbfs";
return GRUB_ERR_NONE;
@@ -376,7 +376,7 @@ static struct grub_fs grub_cbfs_fs = {
GRUB_MOD_INIT (cbfs)
{
#if (defined (__i386__) || defined (__x86_64__)) && !defined (GRUB_UTIL) && !defined (GRUB_MACHINE_EMU) && !defined (GRUB_MACHINE_XEN)
#if (defined (__i386__) || defined (__x86_64__)) && !defined (GRUB_UTIL) && !defined (GRUB_MACHINE_EMU)
init_cbfsdisk ();
#endif
grub_fs_register (&grub_cbfs_fs);
@@ -385,7 +385,7 @@ GRUB_MOD_INIT (cbfs)
GRUB_MOD_FINI (cbfs)
{
grub_fs_unregister (&grub_cbfs_fs);
#if (defined (__i386__) || defined (__x86_64__)) && !defined (GRUB_UTIL) && !defined (GRUB_MACHINE_EMU) && !defined (GRUB_MACHINE_XEN)
#if (defined (__i386__) || defined (__x86_64__)) && !defined (GRUB_UTIL) && !defined (GRUB_MACHINE_EMU)
fini_cbfsdisk ();
#endif
}

4
grub-core/fs/cpio_common.c
View File

@@ -38,7 +38,8 @@ struct grub_archelp_data
static grub_err_t
grub_cpio_find_file (struct grub_archelp_data *data, char **name,
grub_int32_t *mtime, grub_uint32_t *mode)
grub_int32_t *mtime, grub_uint32_t *mode,
grub_uint64_t *size)
{
struct head hd;
grub_size_t namesize;
@@ -86,6 +87,7 @@ grub_cpio_find_file (struct grub_archelp_data *data, char **name,
data->dofs = data->hofs + ALIGN_CPIO (sizeof (hd) + namesize);
data->next_hofs = data->dofs + ALIGN_CPIO (data->size);
*size = data->size;
return GRUB_ERR_NONE;
}

160
grub-core/fs/ext2.c
View File

@@ -247,7 +247,6 @@ struct ext2_dirent
{
grub_uint32_t inode;
grub_uint16_t direntlen;
#define MAX_NAMELEN 255
grub_uint8_t namelen;
grub_uint8_t filetype;
};
@@ -345,12 +344,11 @@ grub_ext2_blockgroup (struct grub_ext2_data *data, int group,
}
static struct grub_ext4_extent_header *
grub_ext4_find_leaf (struct grub_ext2_data *data,
grub_ext4_find_leaf (struct grub_ext2_data *data, grub_properly_aligned_t *buf,
struct grub_ext4_extent_header *ext_block,
grub_uint32_t fileblock)
{
struct grub_ext4_extent_idx *index;
void *buf = NULL;
while (1)
{
@@ -359,8 +357,8 @@ grub_ext4_find_leaf (struct grub_ext2_data *data,
index = (struct grub_ext4_extent_idx *) (ext_block + 1);
if (ext_block->magic != grub_cpu_to_le16_compile_time (EXT4_EXT_MAGIC))
goto fail;
if (grub_le_to_cpu16(ext_block->magic) != EXT4_EXT_MAGIC)
return 0;
if (ext_block->depth == 0)
return ext_block;
@@ -372,24 +370,17 @@ grub_ext4_find_leaf (struct grub_ext2_data *data,
}
if (--i < 0)
goto fail;
return 0;
block = grub_le_to_cpu16 (index[i].leaf_hi);
block = (block << 32) | grub_le_to_cpu32 (index[i].leaf);
if (!buf)
buf = grub_malloc (EXT2_BLOCK_SIZE(data));
if (!buf)
goto fail;
if (grub_disk_read (data->disk,
block << LOG2_EXT2_BLOCK_SIZE (data),
0, EXT2_BLOCK_SIZE(data), buf))
goto fail;
return 0;
ext_block = buf;
ext_block = (struct grub_ext4_extent_header *) buf;
}
fail:
grub_free (buf);
return 0;
}
static grub_disk_addr_t
@@ -397,21 +388,20 @@ grub_ext2_read_block (grub_fshelp_node_t node, grub_disk_addr_t fileblock)
{
struct grub_ext2_data *data = node->data;
struct grub_ext2_inode *inode = &node->inode;
grub_disk_addr_t blknr = -1;
unsigned int blksz = EXT2_BLOCK_SIZE (data);
grub_disk_addr_t blksz_quarter = blksz / 4;
int log2_blksz = LOG2_EXT2_BLOCK_SIZE (data);
int log_perblock = log2_blksz + 9 - 2;
grub_uint32_t indir;
int shift;
if (inode->flags & grub_cpu_to_le32_compile_time (EXT4_EXTENTS_FLAG))
{
GRUB_PROPERLY_ALIGNED_ARRAY (buf, EXT2_BLOCK_SIZE(data));
struct grub_ext4_extent_header *leaf;
struct grub_ext4_extent *ext;
int i;
grub_disk_addr_t ret;
leaf = grub_ext4_find_leaf (data, (struct grub_ext4_extent_header *) inode->blocks.dir_blocks, fileblock);
leaf = grub_ext4_find_leaf (data, buf,
(struct grub_ext4_extent_header *) inode->blocks.dir_blocks,
fileblock);
if (! leaf)
{
grub_error (GRUB_ERR_BAD_FS, "invalid extent");
@@ -429,7 +419,7 @@ grub_ext2_read_block (grub_fshelp_node_t node, grub_disk_addr_t fileblock)
{
fileblock -= grub_le_to_cpu32 (ext[i].block);
if (fileblock >= grub_le_to_cpu16 (ext[i].len))
ret = 0;
return 0;
else
{
grub_disk_addr_t start;
@@ -437,64 +427,98 @@ grub_ext2_read_block (grub_fshelp_node_t node, grub_disk_addr_t fileblock)
start = grub_le_to_cpu16 (ext[i].start_hi);
start = (start << 32) + grub_le_to_cpu32 (ext[i].start);
ret = fileblock + start;
return fileblock + start;
}
}
else
{
grub_error (GRUB_ERR_BAD_FS, "something wrong with extent");
ret = -1;
return -1;
}
if (leaf != (struct grub_ext4_extent_header *) inode->blocks.dir_blocks)
grub_free (leaf);
return ret;
}
/* Direct blocks. */
if (fileblock < INDIRECT_BLOCKS)
return grub_le_to_cpu32 (inode->blocks.dir_blocks[fileblock]);
fileblock -= INDIRECT_BLOCKS;
blknr = grub_le_to_cpu32 (inode->blocks.dir_blocks[fileblock]);
/* Indirect. */
if (fileblock < blksz_quarter)
else if (fileblock < INDIRECT_BLOCKS + blksz / 4)
{
indir = inode->blocks.indir_block;
shift = 0;
goto indirect;
grub_uint32_t indir[blksz / 4];
if (grub_disk_read (data->disk,
((grub_disk_addr_t)
grub_le_to_cpu32 (inode->blocks.indir_block))
<< log2_blksz,
0, blksz, indir))
return grub_errno;
blknr = grub_le_to_cpu32 (indir[fileblock - INDIRECT_BLOCKS]);
}
fileblock -= blksz_quarter;
/* Double indirect. */
if (fileblock < blksz_quarter * blksz_quarter)
else if (fileblock < INDIRECT_BLOCKS
+ blksz / 4 * ((grub_disk_addr_t) blksz / 4 + 1))
{
indir = inode->blocks.double_indir_block;
shift = 1;
goto indirect;
int log_perblock = log2_blksz + 9 - 2;
grub_disk_addr_t rblock = fileblock - (INDIRECT_BLOCKS
+ blksz / 4);
grub_uint32_t indir[blksz / 4];
if (grub_disk_read (data->disk,
((grub_disk_addr_t)
grub_le_to_cpu32 (inode->blocks.double_indir_block))
<< log2_blksz,
0, blksz, indir))
return grub_errno;
if (grub_disk_read (data->disk,
((grub_disk_addr_t)
grub_le_to_cpu32 (indir[rblock >> log_perblock]))
<< log2_blksz,
0, blksz, indir))
return grub_errno;
blknr = grub_le_to_cpu32 (indir[rblock & ((1 << log_perblock) - 1)]);
}
fileblock -= blksz_quarter * blksz_quarter;
/* Triple indirect. */
if (fileblock < blksz_quarter * blksz_quarter * (blksz_quarter + 1))
/* triple indirect. */
else if (fileblock < INDIRECT_BLOCKS + blksz / 4 * ((grub_disk_addr_t) blksz / 4 + 1)
+ ((grub_disk_addr_t) blksz / 4) * ((grub_disk_addr_t) blksz / 4)
* ((grub_disk_addr_t) blksz / 4 + 1))
{
indir = inode->blocks.triple_indir_block;
shift = 2;
goto indirect;
int log_perblock = log2_blksz + 9 - 2;
grub_disk_addr_t rblock = fileblock - (INDIRECT_BLOCKS + blksz / 4
* (blksz / 4 + 1));
grub_uint32_t indir[blksz / 4];
if (grub_disk_read (data->disk,
((grub_disk_addr_t)
grub_le_to_cpu32 (inode->blocks.triple_indir_block))
<< log2_blksz,
0, blksz, indir))
return grub_errno;
if (grub_disk_read (data->disk,
((grub_disk_addr_t)
grub_le_to_cpu32 (indir[(rblock >> log_perblock) >> log_perblock]))
<< log2_blksz,
0, blksz, indir))
return grub_errno;
if (grub_disk_read (data->disk,
((grub_disk_addr_t)
grub_le_to_cpu32 (indir[(rblock >> log_perblock) & ((1 << log_perblock) - 1)]))
<< log2_blksz,
0, blksz, indir))
return grub_errno;
blknr = grub_le_to_cpu32 (indir[rblock & ((1 << log_perblock) - 1)]);
}
else
{
grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
"ext2fs doesn't support quadruple indirect blocks");
}
return grub_error (GRUB_ERR_BAD_FS,
"ext2fs doesn't support quadruple indirect blocks");
indirect:
do {
if (grub_disk_read (data->disk,
((grub_disk_addr_t) grub_le_to_cpu32 (indir))
<< log2_blksz,
((fileblock >> (log_perblock * shift))
& ((1 << log_perblock) - 1))
* sizeof (indir),
sizeof (indir), &indir))
return grub_errno;
} while (shift--);
return grub_le_to_cpu32 (indir);
return blknr;
}
/* Read LEN bytes from the file described by DATA starting with byte
@@ -646,10 +670,10 @@ grub_ext2_read_symlink (grub_fshelp_node_t node)
/* If the filesize of the symlink is bigger than
60 the symlink is stored in a separate block,
otherwise it is stored in the inode. */
if (grub_le_to_cpu32 (diro->inode.size) <= sizeof (diro->inode.symlink))
grub_memcpy (symlink,
diro->inode.symlink,
grub_le_to_cpu32 (diro->inode.size));
if (grub_le_to_cpu32 (diro->inode.size) <= 60)
grub_strncpy (symlink,
diro->inode.symlink,
grub_le_to_cpu32 (diro->inode.size));
else
{
grub_ext2_read_file (diro, 0, 0, 0,
@@ -695,7 +719,7 @@ grub_ext2_iterate_dir (grub_fshelp_node_t dir,
if (dirent.inode != 0 && dirent.namelen != 0)
{
char filename[MAX_NAMELEN + 1];
char filename[dirent.namelen + 1];
struct grub_fshelp_node *fdiro;
enum grub_fshelp_filetype type = GRUB_FSHELP_UNKNOWN;
@@ -860,6 +884,8 @@ grub_ext2_dir_iter (const char *filename, enum grub_fshelp_filetype filetype,
{
info.mtimeset = 1;
info.mtime = grub_le_to_cpu32 (node->inode.mtime);
info.size = grub_le_to_cpu32 (node->inode.size);
info.size |= ((grub_off_t) grub_le_to_cpu32 (node->inode.size_high)) << 32;
}
info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);

2
grub-core/fs/fat.c
View File

@@ -938,6 +938,8 @@ grub_fat_find_dir (grub_disk_t disk, struct grub_fat_data *data,
#endif
data->cur_cluster_num = ~0U;
info.size = data->file_size;
if (call_hook)
hook (ctxt.filename, &info, hook_data);

3
grub-core/fs/fshelp.c
View File

@@ -133,7 +133,6 @@ find_file (const char *currpath, grub_fshelp_node_t currroot,
if (ctx->type == GRUB_FSHELP_SYMLINK)
{
char *symlink;
const char *next;
/* Test if the symlink does not loop. */
if (++ctx->symlinknest == 8)
@@ -165,10 +164,8 @@ find_file (const char *currpath, grub_fshelp_node_t currroot,
}
/* Lookup the node the symlink points to. */
next = ctx->next;
find_file (symlink, ctx->oldnode, &ctx->currnode,
iterate_dir, read_symlink, ctx);
ctx->next = next;
ctx->type = ctx->foundtype;
grub_free (symlink);

1
grub-core/fs/hfs.c
View File

@@ -1237,6 +1237,7 @@ grub_hfs_dir_hook (struct grub_hfs_record *rec, void *hook_arg)
info.dir = 0;
info.mtimeset = 1;
info.mtime = grub_be_to_cpu32 (frec->mtime) - 2082844800;
info.size = grub_be_to_cpu32 (frec->size);
return ctx->hook (fname, &info, ctx->hook_data);
}

3
grub-core/fs/hfsplus.c
View File

@@ -888,8 +888,6 @@ grub_hfsplus_read (grub_file_t file, char *buf, grub_size_t len)
struct grub_hfsplus_data *data =
(struct grub_hfsplus_data *) file->data;
data->opened_file.file = file;
if (grub_hfsplus_read_compressed && data->opened_file.compressed)
return grub_hfsplus_read_compressed (&data->opened_file,
file->offset, len, buf);
@@ -919,6 +917,7 @@ grub_hfsplus_dir_iter (const char *filename,
info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
info.mtimeset = 1;
info.mtime = node->mtime;
info.size = node->size;
info.case_insensitive = !! (filetype & GRUB_FSHELP_CASE_INSENSITIVE);
grub_free (node);
return ctx->hook (filename, &info, ctx->hook_data);

5
grub-core/fs/hfspluscomp.c
View File

@@ -23,7 +23,6 @@
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/deflate.h>
#include <grub/file.h>
GRUB_MOD_LICENSE ("GPLv3+");
@@ -122,8 +121,6 @@ hfsplus_read_compressed_real (struct grub_hfsplus_file *node,
if (node->compressed == 1)
{
grub_memcpy (buf, node->cbuf + pos, len);
if (grub_file_progress_hook && node->file)
grub_file_progress_hook (0, 0, len, node->file);
return len;
}
@@ -165,8 +162,6 @@ hfsplus_read_compressed_real (struct grub_hfsplus_file *node,
}
grub_memcpy (buf, node->cbuf + (pos % HFSPLUS_COMPRESS_BLOCK_SIZE),
curlen);
if (grub_file_progress_hook && node->file)
grub_file_progress_hook (0, 0, curlen, node->file);
buf += curlen;
pos += curlen;
len -= curlen;

2
grub-core/fs/iso9660.c
View File

@@ -861,7 +861,7 @@ grub_iso9660_dir_iter (const char *filename,
grub_memset (&info, 0, sizeof (info));
info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
info.mtimeset = !!iso9660_to_unixtime2 (&node->dirents[0].mtime, &info.mtime);
info.size = get_node_size (node);
grub_free (node);
return ctx->hook (filename, &info, ctx->hook_data);
}

38
grub-core/fs/jfs.c
View File

@@ -72,13 +72,10 @@ struct grub_jfs_extent
grub_uint32_t blk2;
} __attribute__ ((packed));
#define GRUB_JFS_IAG_INODES_OFFSET 3072
#define GRUB_JFS_IAG_INODES_COUNT 128
struct grub_jfs_iag
{
grub_uint8_t unused[GRUB_JFS_IAG_INODES_OFFSET];
struct grub_jfs_extent inodes[GRUB_JFS_IAG_INODES_COUNT];
grub_uint8_t unused[3072];
struct grub_jfs_extent inodes[128];
} __attribute__ ((packed));
@@ -286,25 +283,20 @@ getblk (struct grub_jfs_treehead *treehead,
if (found != -1)
{
grub_int64_t ret = -1;
struct
{
struct grub_jfs_treehead treehead;
struct grub_jfs_tree_extent extents[254];
} *tree;
} tree;
tree = grub_zalloc (sizeof (*tree));
if (!tree)
if (grub_disk_read (data->disk,
((grub_disk_addr_t) grub_le_to_cpu32 (extents[found].extent.blk2))
<< (grub_le_to_cpu16 (data->sblock.log2_blksz)
- GRUB_DISK_SECTOR_BITS), 0,
sizeof (tree), (char *) &tree))
return -1;
if (!grub_disk_read (data->disk,
((grub_disk_addr_t) grub_le_to_cpu32 (extents[found].extent.blk2))
<< (grub_le_to_cpu16 (data->sblock.log2_blksz)
- GRUB_DISK_SECTOR_BITS), 0,
sizeof (*tree), (char *) tree))
ret = getblk (&tree->treehead, &tree->extents[0], data, blk);
grub_free (tree);
return ret;
return getblk (&tree.treehead, &tree.extents[0], data, blk);
}
return -1;
@@ -324,7 +316,7 @@ static grub_err_t
grub_jfs_read_inode (struct grub_jfs_data *data, grub_uint32_t ino,
struct grub_jfs_inode *inode)
{
struct grub_jfs_extent iag_inodes[GRUB_JFS_IAG_INODES_COUNT];
struct grub_jfs_iag iag;
grub_uint32_t iagnum = ino / 4096;
unsigned inoext = (ino % 4096) / 32;
unsigned inonum = (ino % 4096) % 32;
@@ -338,12 +330,11 @@ grub_jfs_read_inode (struct grub_jfs_data *data, grub_uint32_t ino,
/* Read in the IAG. */
if (grub_disk_read (data->disk,
iagblk << (grub_le_to_cpu16 (data->sblock.log2_blksz)
- GRUB_DISK_SECTOR_BITS),
GRUB_JFS_IAG_INODES_OFFSET,
sizeof (iag_inodes), &iag_inodes))
- GRUB_DISK_SECTOR_BITS), 0,
sizeof (struct grub_jfs_iag), &iag))
return grub_errno;
inoblk = grub_le_to_cpu32 (iag_inodes[inoext].blk2);
inoblk = grub_le_to_cpu32 (iag.inodes[inoext].blk2);
inoblk <<= (grub_le_to_cpu16 (data->sblock.log2_blksz)
- GRUB_DISK_SECTOR_BITS);
inoblk += inonum;
@@ -732,7 +723,7 @@ grub_jfs_lookup_symlink (struct grub_jfs_data *data, grub_uint32_t ino)
if (!symlink)
return grub_errno;
if (size <= sizeof (data->currinode.symlink.path))
grub_memcpy (symlink, (char *) (data->currinode.symlink.path), size);
grub_strncpy (symlink, (char *) (data->currinode.symlink.path), size);
else if (grub_jfs_read_file (data, 0, 0, 0, size, symlink) < 0)
{
grub_free (symlink);
@@ -787,6 +778,7 @@ grub_jfs_dir (grub_device_t device, const char *path,
& GRUB_JFS_FILETYPE_MASK) == GRUB_JFS_FILETYPE_DIR;
info.mtimeset = 1;
info.mtime = grub_le_to_cpu32 (inode.mtime.sec);
info.size = grub_le_to_cpu64 (inode.size);
if (hook (diro->name, &info, hook_data))
goto fail;
}

1
grub-core/fs/minix.c
View File

@@ -576,6 +576,7 @@ grub_minix_dir (grub_device_t device, const char *path,
& GRUB_MINIX_IFDIR) == GRUB_MINIX_IFDIR);
info.mtimeset = 1;
info.mtime = grub_minix_to_cpu32 (data->inode.mtime);
info.size = GRUB_MINIX_INODE_SIZE (data);
if (hook (filename, &info, hook_data) ? 1 : 0)
break;

1
grub-core/fs/nilfs2.c
View File

@@ -1066,6 +1066,7 @@ grub_nilfs2_dir_iter (const char *filename, enum grub_fshelp_filetype filetype,
{
info.mtimeset = 1;
info.mtime = grub_le_to_cpu64 (node->inode.i_mtime);
info.size = grub_le_to_cpu64 (node->inode.i_size);
}
info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);

6
grub-core/fs/ntfs.c
View File

@@ -378,9 +378,6 @@ read_data (struct grub_ntfs_attr *at, grub_uint8_t *pa, grub_uint8_t *dest,
ctx->comp.log_spc = at->mft->data->log_spc;
ctx->comp.disk = at->mft->data->disk;
if (read_hook == grub_file_progress_hook)
ctx->file = read_hook_data;
if (pa[8] == 0)
{
if (ofs + len > u32at (pa, 0x10))
@@ -984,10 +981,13 @@ grub_ntfs_dir_iter (const char *filename, enum grub_fshelp_filetype filetype,
grub_memset (&info, 0, sizeof (info));
info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
init_file (node, node->ino);
info.mtimeset = 1;
info.mtime = grub_divmod64 (node->mtime, 10000000, 0)
- 86400ULL * 365 * (1970 - 1601)
- 86400ULL * ((1970 - 1601) / 4) + 86400ULL * ((1970 - 1601) / 100);
info.mtime = node->size;
free_file (node);
grub_free (node);
return ctx->hook (filename, &info, ctx->hook_data);
}

29
grub-core/fs/ntfscomp.c
View File

@@ -226,9 +226,6 @@ read_block (struct grub_ntfs_rlst *ctx, grub_uint8_t *buf, grub_size_t num)
{
grub_memset (buf, 0, nn * GRUB_NTFS_COM_LEN);
buf += nn * GRUB_NTFS_COM_LEN;
if (grub_file_progress_hook && ctx->file)
grub_file_progress_hook (0, 0, nn * GRUB_NTFS_COM_LEN,
ctx->file);
}
}
else
@@ -239,9 +236,6 @@ read_block (struct grub_ntfs_rlst *ctx, grub_uint8_t *buf, grub_size_t num)
return grub_errno;
if (buf)
buf += GRUB_NTFS_COM_LEN;
if (grub_file_progress_hook && ctx->file)
grub_file_progress_hook (0, 0, GRUB_NTFS_COM_LEN,
ctx->file);
nn--;
}
}
@@ -268,11 +262,6 @@ read_block (struct grub_ntfs_rlst *ctx, grub_uint8_t *buf, grub_size_t num)
ctx->target_vcn)) << ctx->comp.log_spc, 0,
tt << (ctx->comp.log_spc + GRUB_NTFS_BLK_SHR), buf))
return grub_errno;
if (grub_file_progress_hook && ctx->file)
grub_file_progress_hook (0, 0,
tt << (ctx->comp.log_spc
+ GRUB_NTFS_BLK_SHR),
ctx->file);
buf += tt << (ctx->comp.log_spc + GRUB_NTFS_BLK_SHR);
}
nn -= tt;
@@ -291,11 +280,6 @@ read_block (struct grub_ntfs_rlst *ctx, grub_uint8_t *buf, grub_size_t num)
nn << (ctx->comp.log_spc + GRUB_NTFS_BLK_SHR), buf))
return grub_errno;
buf += nn << (ctx->comp.log_spc + GRUB_NTFS_BLK_SHR);
if (grub_file_progress_hook && ctx->file)
grub_file_progress_hook (0, 0,
nn << (ctx->comp.log_spc
+ GRUB_NTFS_BLK_SHR),
ctx->file);
}
ctx->target_vcn += nn;
}
@@ -322,8 +306,6 @@ ntfscomp (grub_uint8_t *dest, grub_disk_addr_t ofs,
n = len;
grub_memcpy (dest, ctx->attr->sbuf + ofs - ctx->attr->save_pos, n);
if (grub_file_progress_hook && ctx->file)
grub_file_progress_hook (0, 0, n, ctx->file);
if (n == len)
return 0;
@@ -369,9 +351,6 @@ ntfscomp (grub_uint8_t *dest, grub_disk_addr_t ofs,
if (ofs % GRUB_NTFS_COM_LEN)
{
grub_uint32_t t, n, o;
void *file = ctx->file;
ctx->file = 0;
t = ctx->target_vcn << (ctx->comp.log_spc + GRUB_NTFS_BLK_SHR);
if (read_block (ctx, ctx->attr->sbuf, 1))
@@ -380,8 +359,6 @@ ntfscomp (grub_uint8_t *dest, grub_disk_addr_t ofs,
goto quit;
}
ctx->file = file;
ctx->attr->save_pos = t;
o = ofs % GRUB_NTFS_COM_LEN;
@@ -389,8 +366,6 @@ ntfscomp (grub_uint8_t *dest, grub_disk_addr_t ofs,
if (n > len)
n = len;
grub_memcpy (dest, &ctx->attr->sbuf[o], n);
if (grub_file_progress_hook && ctx->file)
grub_file_progress_hook (0, 0, n, ctx->file);
if (n == len)
goto quit;
dest += n;
@@ -408,9 +383,7 @@ ntfscomp (grub_uint8_t *dest, grub_disk_addr_t ofs,
if (len)
{
grub_uint32_t t;
void *file = ctx->file;
ctx->file = 0;
t = ctx->target_vcn << (ctx->comp.log_spc + GRUB_NTFS_BLK_SHR);
if (read_block (ctx, ctx->attr->sbuf, 1))
{
@@ -421,8 +394,6 @@ ntfscomp (grub_uint8_t *dest, grub_disk_addr_t ofs,
ctx->attr->save_pos = t;
grub_memcpy (dest, ctx->attr->sbuf, len);
if (grub_file_progress_hook && file)
grub_file_progress_hook (0, 0, len, file);
}
quit:

5
grub-core/fs/proc.c
View File

@@ -128,11 +128,10 @@ grub_procfs_open (struct grub_file *file, const char *path)
FOR_LIST_ELEMENTS((entry), (grub_procfs_entries))
if (grub_strcmp (pathptr, entry->name) == 0)
{
grub_size_t sz;
file->data = entry->get_contents (&sz);
file->data = entry->get_contents ();
if (!file->data)
return grub_errno;
file->size = sz;
file->size = grub_strlen (file->data);
return GRUB_ERR_NONE;
}

3
grub-core/fs/reiserfs.c
View File

@@ -781,7 +781,7 @@ grub_reiserfs_iterate_dir (grub_fshelp_node_t item,
= grub_le_to_cpu16 (directory_header->state);
grub_fshelp_node_t entry_item;
struct grub_reiserfs_key entry_key;
enum grub_fshelp_filetype entry_type;
enum grub_reiserfs_item_type entry_type;
char *entry_name;
if (!(entry_state & GRUB_REISERFS_VISIBLE_MASK))
@@ -1271,6 +1271,7 @@ grub_reiserfs_dir_iter (const char *filename,
info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
info.mtimeset = 1;
info.mtime = node->mtime;
info.size = node->size;
grub_free (node);
return ctx->hook (filename, &info, ctx->hook_data);
}

1
grub-core/fs/romfs.c
View File

@@ -331,6 +331,7 @@ grub_romfs_dir_iter (const char *filename, enum grub_fshelp_filetype filetype,
grub_memset (&info, 0, sizeof (info));
info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
info.size = grub_be_to_cpu32 (node->file.size);
grub_free (node);
return ctx->hook (filename, &info, ctx->hook_data);
}

1
grub-core/fs/sfs.c
View File

@@ -671,6 +671,7 @@ grub_sfs_dir_iter (const char *filename, enum grub_fshelp_filetype filetype,
info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
info.mtime = node->mtime + 8 * 365 * 86400 + 86400 * 2;
info.mtimeset = 1;
info.size = node->size;
grub_free (node->cache);
grub_free (node);
return ctx->hook (filename, &info, ctx->hook_data);

9
grub-core/fs/squash4.c
View File

@@ -656,6 +656,15 @@ grub_squash_dir_iter (const char *filename, enum grub_fshelp_filetype filetype,
info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
info.mtimeset = 1;
info.mtime = grub_le_to_cpu32 (node->ino.mtime);
switch (node->ino.type)
{
case grub_cpu_to_le16_compile_time (SQUASH_TYPE_LONG_REGULAR):
info.size = grub_le_to_cpu64 (node->ino.long_file.size);
break;
case grub_cpu_to_le16_compile_time (SQUASH_TYPE_REGULAR):
info.size = grub_le_to_cpu32 (node->ino.file.size);
break;
}
grub_free (node);
return ctx->hook (filename, &info, ctx->hook_data);
}

15
grub-core/fs/tar.c
View File

@@ -72,7 +72,8 @@ struct grub_archelp_data
static grub_err_t
grub_cpio_find_file (struct grub_archelp_data *data, char **name,
grub_int32_t *mtime,
grub_uint32_t *mode)
grub_uint32_t *mode,
grub_uint64_t *size)
{
struct head hd;
int reread = 0, have_longname = 0, have_longlink = 0;
@@ -200,6 +201,7 @@ grub_cpio_find_file (struct grub_archelp_data *data, char **name,
grub_memcpy (data->linkname, hd.linkname, sizeof (hd.linkname));
data->linkname[100] = 0;
}
*size = data->size;
return GRUB_ERR_NONE;
}
return GRUB_ERR_NONE;
@@ -297,17 +299,10 @@ static grub_ssize_t
grub_cpio_read (grub_file_t file, char *buf, grub_size_t len)
{
struct grub_archelp_data *data;
grub_ssize_t ret;
data = file->data;
data->disk->read_hook = file->read_hook;
data->disk->read_hook_data = file->read_hook_data;
ret = (grub_disk_read (data->disk, 0, data->dofs + file->offset,
len, buf)) ? -1 : (grub_ssize_t) len;
data->disk->read_hook = 0;
return ret;
return (grub_disk_read (data->disk, 0, data->dofs + file->offset,
len, buf)) ? -1 : (grub_ssize_t) len;
}
static grub_err_t

1
grub-core/fs/udf.c
View File

@@ -1072,6 +1072,7 @@ grub_udf_dir_iter (const char *filename, enum grub_fshelp_filetype filetype,
info.mtimeset = !!grub_datetime2unixtime (&datetime, &info.mtime);
info.mtime -= 60 * tz;
info.size = U64 (node->block.fe.file_size);
}
grub_free (node);
return ctx->hook (filename, &info, ctx->hook_data);

2
grub-core/fs/ufs.c
View File

@@ -711,6 +711,8 @@ grub_ufs_dir (grub_device_t device, const char *path,
#endif
info.mtimeset = 1;
info.size = grub_ufs_to_cpu64 (inode.size);
if (hook (filename, &info, hook_data))
{
grub_free (filename);

1
grub-core/fs/xfs.c
View File

@@ -732,6 +732,7 @@ grub_xfs_dir_iter (const char *filename, enum grub_fshelp_filetype filetype,
{
info.mtimeset = 1;
info.mtime = grub_be_to_cpu32 (node->inode.mtime.sec);
info.size = grub_be_to_cpu64 (node->inode.size);
}
info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
grub_free (node);

36
grub-core/fs/zfs/zfs.c
View File

@@ -129,7 +129,7 @@ LEAF_HASH (int bs, grub_uint64_t h, zap_leaf_phys_t *l)
static inline int
ZAP_LEAF_NUMCHUNKS (int bs)
{
return (((1U << bs) - 2 * ZAP_LEAF_HASH_NUMENTRIES (bs)) /
return (((1 << bs) - 2 * ZAP_LEAF_HASH_NUMENTRIES (bs)) /
ZAP_LEAF_CHUNKSIZE - 2);
}
@@ -877,13 +877,18 @@ nvlist_next_nvpair (const char *nvl, const char *nvpair)
* containing the name of nvpair is saved in buf.
*/
static int
nvpair_name (const char *nvp, char **buf, grub_size_t *buflen)
nvpair_name (const char *nvp, char **buf, int *buflen)
{
int len;
/* skip over encode/decode size */
nvp += 4 * 2;
len = grub_be_to_cpu32 (grub_get_unaligned32 (nvp));
nvp=nvp+4;
*buf = (char *) (nvp + 4);
*buflen = grub_be_to_cpu32 (grub_get_unaligned32 (nvp));
*buf=(char*)nvp;
*buflen=len;
return 0;
}
@@ -1108,15 +1113,15 @@ check_pool_label (struct grub_zfs_data *data,
const char *nvp=NULL;
char name[MAX_SUPPORTED_FEATURE_STRLEN + 1];
char *nameptr;
grub_size_t namelen;
int namelen;
while ((nvp = nvlist_next_nvpair(features, nvp)) != NULL)
{
nvpair_name (nvp, &nameptr, &namelen);
nvpair_name(nvp, &nameptr,&namelen);
if(namelen > MAX_SUPPORTED_FEATURE_STRLEN)
namelen = MAX_SUPPORTED_FEATURE_STRLEN;
grub_memcpy (name, nameptr, namelen);
name[namelen] = '\0';
grub_dprintf("zfs","str=%s\n",name);
grub_strncpy(name,nameptr,namelen);
name[namelen]=0;
grub_dprintf("zfs","namelen=%u str=%s\n",namelen,name);
if (check_feature(name,1, NULL) != 0)
{
grub_dprintf("zfs","feature missing in check_pool_label:%s\n",name);
@@ -3303,8 +3308,7 @@ nvlist_find_value (const char *nvlist_in, const char *name,
int valtype, char **val,
grub_size_t *size_out, grub_size_t *nelm_out)
{
grub_size_t nvp_name_len, name_len = grub_strlen(name);
int type;
int name_len, type ;
const char *nvpair=NULL,*nvlist=nvlist_in;
char *nvp_name;
@@ -3325,12 +3329,9 @@ nvlist_find_value (const char *nvlist_in, const char *name,
*/
while ((nvpair=nvlist_next_nvpair(nvlist,nvpair)))
{
nvpair_name(nvpair,&nvp_name, &nvp_name_len);
nvpair_name(nvpair,&nvp_name,&name_len);
type = nvpair_type(nvpair);
if (type == valtype
&& (nvp_name_len == name_len
|| (nvp_name_len > name_len && nvp_name[name_len] == '\0'))
&& grub_memcmp (nvp_name, name, name_len) == 0)
if ((grub_strncmp (nvp_name, name, grub_strlen(name)) == 0) && type == valtype)
{
return nvpair_value(nvpair,val,size_out,nelm_out);
}
@@ -3998,6 +3999,8 @@ iterate_zap (const char *name, grub_uint64_t val, struct grub_zfs_dir_ctx *ctx)
info.mtimeset = 1;
info.mtime = grub_zfs_to_cpu64 (grub_get_unaligned64 ((char *) sahdrp + hdrsize + SA_MTIME_OFFSET), dn.endian);
info.case_insensitive = ctx->data->subvol.case_insensitive;
info.size = grub_zfs_to_cpu64 (grub_get_unaligned64 ((char *) sahdrp + hdrsize + SA_SIZE_OFFSET), dn.endian);
}
if (dn.dn.dn_bonustype == DMU_OT_ZNODE)
@@ -4005,6 +4008,7 @@ iterate_zap (const char *name, grub_uint64_t val, struct grub_zfs_dir_ctx *ctx)
info.mtimeset = 1;
info.mtime = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dn.dn))->zp_mtime[0],
dn.endian);
info.size = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dn.dn))->zp_size, dn.endian);
}
info.dir = (dn.dn.dn_type == DMU_OT_DIRECTORY_CONTENTS);
grub_dprintf ("zfs", "type=%d, name=%s\n",

17
grub-core/fs/zfs/zfscrypt.c
View File

@@ -143,7 +143,7 @@ grub_ccm_decrypt (grub_crypto_cipher_handle_t cipher,
return err;
if (mac_out)
grub_crypto_xor (mac_out, mac, mul, m);
return GPG_ERR_NO_ERROR;
return GRUB_ERR_NONE;
}
static void
@@ -244,7 +244,7 @@ grub_gcm_decrypt (grub_crypto_cipher_handle_t cipher,
if (mac_out)
grub_crypto_xor (mac_out, mac, mac_xor, m);
return GPG_ERR_NO_ERROR;
return GRUB_ERR_NONE;
}
@@ -258,14 +258,13 @@ algo_decrypt (grub_crypto_cipher_handle_t cipher, grub_uint64_t algo,
switch (algo)
{
case 0:
return grub_ccm_decrypt (cipher, out, in, psize,
mac_out, nonce, l, m);
return grub_ccm_decrypt (cipher, out, in, psize, mac_out, nonce, l, m);
case 1:
return grub_gcm_decrypt (cipher, out, in, psize,
mac_out, nonce,
return grub_gcm_decrypt (cipher, out, in, psize, mac_out, nonce,
15 - l, m);
default:
return GPG_ERR_CIPHER_ALGO;
return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, "algorithm %lld is not supported yet",
(long long) algo);
}
}
@@ -280,7 +279,7 @@ grub_zfs_decrypt_real (grub_crypto_cipher_handle_t cipher,
grub_uint32_t mac[4];
unsigned i;
grub_uint32_t sw[4];
gcry_err_code_t err;
grub_err_t err;
grub_memcpy (sw, nonce, 16);
if (endian != GRUB_ZFS_BIG_ENDIAN)
@@ -296,7 +295,7 @@ grub_zfs_decrypt_real (grub_crypto_cipher_handle_t cipher,
size, mac,
sw + 1, 3, 12);
if (err)
return grub_crypto_gcry_error (err);
return err;
for (i = 0; i < 3; i++)
if (grub_zfs_to_cpu32 (expected_mac[i], endian)

2
grub-core/gdb/cstub.c
View File

@@ -201,7 +201,7 @@ grub_gdb_hex2int (char **ptr, grub_uint64_t *int_value)
}
/* This function does all command procesing for interfacing to gdb. */
void __attribute__ ((regparm(3)))
void
grub_gdb_trap (int trap_no)
{
unsigned int sig_no;

10
grub-core/gdb/i386/machdep.S
View File

@@ -71,7 +71,11 @@ VARIABLE(grub_gdb_stack)
#define REG \reg
#define NDX \ndx
#endif
#ifdef __APPLE__
xorl %eax, %eax
#else
movl $0, %eax
#endif
movw REG, EXT_C(grub_gdb_regs)+(NDX * 4)
movw %ax, EXT_C(grub_gdb_regs)+(NDX * 4 + 2)
movl EXT_C(grub_gdb_regs)+(EAX * 4), %eax
@@ -186,7 +190,11 @@ VARIABLE(grub_gdb_stack)
.text
1:
.if EC
add MACRO_DOLLAR(4), %esp
#ifdef __APPLE__
add $$4, %esp
#else
add $4, %esp
#endif
.endif
save_context

2
grub-core/genmod.sh.in
View File

@@ -35,7 +35,7 @@ deps=`grep ^$modname: $moddep | sed s@^.*:@@`
# remove old files if any
rm -f $tmpfile $outfile
if test x@TARGET_APPLE_LINKER@ != x1; then
if test x@TARGET_APPLE_CC@ != x1; then
# stripout .modname and .moddeps sections from input module
@TARGET_OBJCOPY@ -R .modname -R .moddeps $infile $tmpfile

2
grub-core/genmoddep.awk
View File

@@ -23,7 +23,7 @@ BEGIN {
} else if ($1 == "undefined") {
if ($3 in symtab)
modtab[$2] = modtab[$2] " " symtab[$3];
else if ($3 != "__gnu_local_gp" && $3 != "_gp_disp") {
else if ($3 != "__gnu_local_gp") {
printf "%s in %s is not defined\n", $3, $2 >"/dev/stderr";
error++;
}

7
grub-core/gensyminfo.sh.in
View File

@@ -22,12 +22,9 @@ module=$1
modname=`echo $module | sed -e 's@\.module.*$@@'`
# Print all symbols defined by module
if test x"@TARGET_NMFLAGS_DEFINED_ONLY@" = x && test x"@TARGET_NMFLAGS_MINUS_P@" = x; then
@TARGET_NM@ -g -p $module | \
sed -n "s@^\([0-9a-fA-F]*\) *[TBRDS] *\([^ ]*\).*@defined $modname \2@p"
elif test x"@TARGET_NMFLAGS_DEFINED_ONLY@" = x; then
if test x"@TARGET_NMFLAGS_DEFINED_ONLY@" = x; then
@TARGET_NM@ -g @TARGET_NMFLAGS_MINUS_P@ -p $module | \
sed -n "s@^\([^ ]*\) *[TBRDS] *\([0-9a-fA-F]*\).*@defined $modname \1@p"
sed -n "s@^\([0-9a-fA-F]*\) *[TBRDS] *\([^ ]*\).*@defined $modname \2@p"
else
@TARGET_NM@ -g --defined-only @TARGET_NMFLAGS_MINUS_P@ -p $module | \
sed "s@^\([^ ]*\).*@defined $modname \1@g"

8
grub-core/gettext/gettext.c
View File

@@ -34,6 +34,8 @@ GRUB_MOD_LICENSE ("GPLv3+");
http://www.gnu.org/software/autoconf/manual/gettext/MO-Files.html .
*/
static struct grub_gettext_context main_context, secondary_context;
static const char *(*grub_gettext_original) (const char *s);
struct grub_gettext_msg
@@ -67,8 +69,6 @@ struct grub_gettext_context
struct grub_gettext_msg *grub_gettext_msg_list;
};
static struct grub_gettext_context main_context, secondary_context;
#define MO_MAGIC_NUMBER 0x950412de
static grub_err_t
@@ -423,10 +423,6 @@ grub_gettext_init_ext (struct grub_gettext_context *ctx,
grub_free (lang);
}
if (locale[0] == 'e' && locale[1] == 'n'
&& (locale[2] == '\0' || locale[2] == '_'))
grub_errno = err = GRUB_ERR_NONE;
return err;
}

16
grub-core/gfxmenu/gui_box.c
View File

@@ -234,30 +234,14 @@ static void
box_paint (void *vself, const grub_video_rect_t *region)
{
grub_gui_box_t self = vself;
struct component_node *cur;
grub_video_rect_t vpsave;
grub_video_area_status_t box_area_status;
grub_video_get_area_status (&box_area_status);
grub_gui_set_viewport (&self->bounds, &vpsave);
for (cur = self->chead.next; cur != &self->ctail; cur = cur->next)
{
grub_gui_component_t comp = cur->component;
grub_video_rect_t r;
comp->ops->get_bounds(comp, &r);
if (!grub_video_have_common_points (region, &r))
continue;
/* Paint the child. */
if (box_area_status == GRUB_VIDEO_AREA_ENABLED
&& grub_video_bounds_inside_region (&r, region))
grub_video_set_area_status (GRUB_VIDEO_AREA_DISABLED);
comp->ops->paint (comp, region);
if (box_area_status == GRUB_VIDEO_AREA_ENABLED)
grub_video_set_area_status (GRUB_VIDEO_AREA_ENABLED);
}
grub_gui_restore_viewport (&vpsave);
}

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