From 4d53f0a22442d69cd4e631ce251af615120be5be Mon Sep 17 00:00:00 2001 From: lanruo Date: Thu, 17 Aug 2023 15:56:14 +0800 Subject: [PATCH 1/2] add the grub parameter crashkernel=512M for sw --- ...le-kernel.kss.img-build-for-sw64_efi.patch | 127 + 9000-Add-sw_64-support.patch | 3578 +++++++++++++++++ grub2.spec | 105 +- grubsw_64.efi | Bin 0 -> 712624 bytes 4 files changed, 3806 insertions(+), 4 deletions(-) create mode 100644 0021-grub-enable-kernel.kss.img-build-for-sw64_efi.patch create mode 100644 9000-Add-sw_64-support.patch create mode 100755 grubsw_64.efi diff --git a/0021-grub-enable-kernel.kss.img-build-for-sw64_efi.patch b/0021-grub-enable-kernel.kss.img-build-for-sw64_efi.patch new file mode 100644 index 0000000..8e36b2b --- /dev/null +++ b/0021-grub-enable-kernel.kss.img-build-for-sw64_efi.patch @@ -0,0 +1,127 @@ +From 42f4e1ab7fbecfbb4ba6832a0875d72aafc4f76a Mon Sep 17 00:00:00 2001 +From: Wang Zhijiang +Date: Thu, 1 Jun 2023 09:53:15 +0800 +Subject: [PATCH] grub: enable kernel.kss.img build for sw64_efi + +--- + grub-core/Makefile.core.def | 16 ++++++++++++++++ + grub-core/loader/sw64/efi/linux.c | 30 ++++++++++++++++++++++++++---- + 2 files changed, 42 insertions(+), 4 deletions(-) + +diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def +index 1157f3736..d4c477f54 100644 +--- a/grub-core/Makefile.core.def ++++ b/grub-core/Makefile.core.def +@@ -464,6 +464,8 @@ kernel = { + sparc64_ieee1275_ldflags = '-Wl,-Ttext,0x4400'; + mips_arc_ldflags = '-Wl,-Ttext,$(TARGET_LINK_ADDR)'; + mips_qemu_mips_ldflags = '-Wl,-Ttext,0x80200000'; ++ sw_64_efi_ldflags = '-Wl,-r,-d'; ++ sw_64_efi_stripflags = '--strip-unneeded -K start -R .note -R .comment -R .note.gnu.gold-version'; + + mips_arc_cppflags = '-DGRUB_DECOMPRESSOR_LINK_ADDR=$(TARGET_DECOMPRESSOR_LINK_ADDR)'; + i386_qemu_cppflags = '-DGRUB_BOOT_MACHINE_LINK_ADDR=$(GRUB_BOOT_MACHINE_LINK_ADDR)'; +@@ -478,6 +480,7 @@ kernel = { + i386_efi_cflags = '-DKSS'; + x86_64_efi_cflags = '-DKSS'; + arm64_efi_cflags = '-DKSS'; ++ sw_64_efi_cflags = '-DKSS'; + + i386_pc_startup = kern/i386/pc/startup.S; + i386_efi_startup = kern/i386/efi/startup.S; +@@ -498,6 +501,7 @@ kernel = { + arm64_efi_startup = kern/arm64/efi/startup.S; + riscv32_efi_startup = kern/riscv/efi/startup.S; + riscv64_efi_startup = kern/riscv/efi/startup.S; ++ sw_64_efi_startup = kern/sw64/efi/startup.S; + + common = kern/buffer.c; + common = kern/command.c; +@@ -703,6 +707,17 @@ kernel = { + extra_dist = video/sis315_init.c; + mips_loongson = commands/keylayouts.c; + ++ sw_64_efi = kern/sw64/dl.c; ++ sw_64_efi = kern/sw64/dl_helper.c; ++ sw_64_efi = kern/sw64/efi/init.c; ++ sw_64_efi = kern/efi/fdt.c; ++ sw_64_efi = lib/sw64/divide.S; ++ sw_64_efi = kern/sw64/efi/callwrap.S; ++ sw_64_efi = kern/sw64/cache.c; ++ sw_64_efi = kern/sw64/cache_flush.S; ++ sw_64_efi = commands/keylayouts.c; ++ sw_64_efi = kern/sw64/debug.c; ++ + powerpc_ieee1275 = kern/powerpc/cache.S; + powerpc_ieee1275 = kern/powerpc/dl.c; + powerpc_ieee1275 = kern/powerpc/compiler-rt.S; +@@ -785,6 +800,7 @@ kernel = { + enable = x86_64_efi; + enable = i386_efi; + enable = arm64_efi; ++ enable = sw_64_efi; + }; + + module = { +diff --git a/grub-core/loader/sw64/efi/linux.c b/grub-core/loader/sw64/efi/linux.c +index 51c2a98b7..5fad51230 100644 +--- a/grub-core/loader/sw64/efi/linux.c ++++ b/grub-core/loader/sw64/efi/linux.c +@@ -40,6 +40,7 @@ + #include + #include + #include ++#include + + GRUB_MOD_LICENSE ("GPLv3+"); + +@@ -200,6 +201,9 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)), + { + grub_ssize_t size; + grub_elf_t elf = 0; ++ unsigned char digest[32]; ++ char *filename = argv[0]; ++ + + grub_dl_ref (my_mod); + +@@ -211,14 +215,32 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)), + goto fail; + } + +- elf = grub_elf_open (argv[0], GRUB_FILE_TYPE_LINUX_KERNEL); ++ if (grub_kss_verify(argv[0], digest)) ++ { ++ /* We should clear the errno so that the next call of grub_file_open will ++ * not failed abnormally. ++ */ ++ grub_errno = GRUB_ERR_NONE; ++ grub_printf ("fallback to bakcup kernel\n"); ++ ++ if (grub_kss_verify(KSS_FALLBACK_KERNEL, digest)) { ++ grub_error (GRUB_ERR_FILE_READ_ERROR, N_("failed to verify the signature of backup kernel")); ++ goto fail; ++ } ++ ++ filename = KSS_FALLBACK_KERNEL; ++ } ++ ++ grub_kss_log_kernel_hash(digest); ++ ++ elf = grub_elf_open (filename, GRUB_FILE_TYPE_LINUX_KERNEL); + if (! elf) + goto fail; + +- grub_dprintf ("linux", "Loading linux: %s\n", argv[0]); +- grub_printk ("Loading linux: %s\n", argv[0]); ++ grub_dprintf ("linux", "Loading linux: %s\n", filename); ++ grub_printk ("Loading linux: %s\n", filename); + +- if (grub_load_elf64 (elf, argv[0])) ++ if (grub_load_elf64 (elf, filename)) + goto fail; + + grub_memset (sunway_boot_params, 0, sizeof(*sunway_boot_params)); +-- +2.33.0 + diff --git a/9000-Add-sw_64-support.patch b/9000-Add-sw_64-support.patch new file mode 100644 index 0000000..3696984 --- /dev/null +++ b/9000-Add-sw_64-support.patch @@ -0,0 +1,3578 @@ +From dcfac5c50b988c3a535005ae6f2ce79281c9195d Mon Sep 17 00:00:00 2001 +From: Yang Qiang +Date: Thu, 29 Sep 2022 18:29:57 +0800 +Subject: [PATCH] Release GRUB 2.06-100.50.2.2.0 for SW64 + +Signed-off-by: Yang Qiang +--- + include/grub/fdt.h | 4 +- + grub-core/loader/efi/chainloader.c | 2 + + Makefile.util.def | 1 + + bootstrap | 6 + + bootstrap.conf | 6 + + conf/Makefile.common | 3 + + configure.ac | 8 +- + gentpl.py | 8 +- + grub-core/Makefile.am | 7 + + grub-core/Makefile.core.def | 20 + + grub-core/commands/file.c | 11 +- + grub-core/kern/compiler-rt.c | 2 +- + grub-core/kern/efi/mm.c | 2 +- + grub-core/kern/misc.c | 57 ++ + grub-core/kern/sw64/cache.c | 63 ++ + grub-core/kern/sw64/cache_flush.S | 44 ++ + grub-core/kern/sw64/debug.c | 38 + + grub-core/kern/sw64/dl.c | 214 ++++++ + grub-core/kern/sw64/dl_helper.c | 72 ++ + grub-core/kern/sw64/efi/callwrap.S | 261 +++++++ + grub-core/kern/sw64/efi/init.c | 75 ++ + grub-core/kern/sw64/efi/startup.S | 35 + + .../lib/gnulib-patches/add-sw64-support.patch | 40 ++ + grub-core/lib/setjmp.S | 2 + + grub-core/lib/sw64/divide.S | 677 ++++++++++++++++++ + grub-core/lib/sw64/setjmp.S | 75 ++ + grub-core/loader/sw64/efi/linux.c | 330 +++++++++ + include/grub/compiler-rt.h | 2 +- + include/grub/dl.h | 14 +- + include/grub/efi/api.h | 2 +- + include/grub/efi/efi.h | 2 +- + include/grub/efi/pe32.h | 1 + + include/grub/elf.h | 42 ++ + include/grub/misc.h | 11 +- + include/grub/sw64/divide.h | 11 + + include/grub/sw64/efi/memory.h | 6 + + include/grub/sw64/efi/time.h | 23 + + include/grub/sw64/io.h | 62 ++ + include/grub/sw64/jmpbuf-offsets.h | 35 + + include/grub/sw64/kernel.h | 25 + + include/grub/sw64/linux.h | 50 ++ + include/grub/sw64/pal.h | 49 ++ + include/grub/sw64/regdef.h | 44 ++ + include/grub/sw64/setjmp.h | 28 + + include/grub/sw64/time.h | 28 + + include/grub/sw64/types.h | 32 + + include/grub/util/install.h | 1 + + include/grub/util/misc.h | 4 + + util/grub-install-common.c | 1 + + util/grub-install.c | 16 + + util/grub-mkimagexx.c | 151 +++- + util/grub-module-verifier.c | 18 + + util/misc.c | 6 + + util/mkimage.c | 16 + + 52 files changed, 2721 insertions(+), 16 deletions(-) + create mode 100644 grub-core/kern/sw64/cache.c + create mode 100644 grub-core/kern/sw64/cache_flush.S + create mode 100644 grub-core/kern/sw64/debug.c + create mode 100644 grub-core/kern/sw64/dl.c + create mode 100644 grub-core/kern/sw64/dl_helper.c + create mode 100644 grub-core/kern/sw64/efi/callwrap.S + create mode 100644 grub-core/kern/sw64/efi/init.c + create mode 100644 grub-core/kern/sw64/efi/startup.S + create mode 100644 grub-core/lib/gnulib-patches/add-sw64-support.patch + create mode 100644 grub-core/lib/sw64/divide.S + create mode 100644 grub-core/lib/sw64/setjmp.S + create mode 100644 grub-core/loader/sw64/efi/linux.c + create mode 100644 include/grub/sw64/divide.h + create mode 100644 include/grub/sw64/efi/memory.h + create mode 100644 include/grub/sw64/efi/time.h + create mode 100644 include/grub/sw64/io.h + create mode 100644 include/grub/sw64/jmpbuf-offsets.h + create mode 100644 include/grub/sw64/kernel.h + create mode 100644 include/grub/sw64/linux.h + create mode 100644 include/grub/sw64/pal.h + create mode 100644 include/grub/sw64/regdef.h + create mode 100644 include/grub/sw64/setjmp.h + create mode 100644 include/grub/sw64/time.h + create mode 100644 include/grub/sw64/types.h + +diff --git a/include/grub/fdt.h b/include/grub/fdt.h +index 3514aa4..ba2f9a9 100644 +--- a/include/grub/fdt.h ++++ b/include/grub/fdt.h +@@ -20,7 +20,7 @@ + #define GRUB_FDT_HEADER 1 + + #if !defined(GRUB_MACHINE_EMU) && \ +- (defined(__arm__) || defined(__aarch64__) || defined(__riscv)) ++ (defined(__arm__) || defined(__aarch64__) || defined(__riscv) || defined(__sw_64__)) + + #include + #include +@@ -148,6 +148,6 @@ int EXPORT_FUNC(grub_fdt_set_prop) (void *fdt, unsigned int nodeoffset, const ch + }) + + #endif /* !defined(GRUB_MACHINE_EMU) && \ +- (defined(__arm__) || defined(__aarch64__) || defined(__riscv)) */ ++ (defined(__arm__) || defined(__aarch64__) || defined(__riscv) || defined(__sw_64__)) */ + + #endif /* ! GRUB_FDT_HEADER */ +diff --git a/grub-core/loader/efi/chainloader.c b/grub-core/loader/efi/chainloader.c +index fb874f1..faf60ef 100644 +--- a/grub-core/loader/efi/chainloader.c ++++ b/grub-core/loader/efi/chainloader.c +@@ -345,6 +345,8 @@ static const grub_uint16_t machine_type __attribute__((__unused__)) = + GRUB_PE32_MACHINE_I386; + #elif defined(__ia64__) + GRUB_PE32_MACHINE_IA64; ++#elif defined(__sw_64__) ++ GRUB_PE32_MACHINE_SW_64; + #elif defined(__riscv) && (__riscv_xlen == 32) + GRUB_PE32_MACHINE_RISCV32; + #elif defined(__riscv) && (__riscv_xlen == 64) +diff --git a/Makefile.util.def b/Makefile.util.def +index f8b356cc1..ebe86f06e 100644 +--- a/Makefile.util.def ++++ b/Makefile.util.def +@@ -161,6 +161,7 @@ library = { + common = grub-core/io/xzio.c; + common = grub-core/io/lzopio.c; + common = grub-core/kern/ia64/dl_helper.c; ++ common = grub-core/kern/sw64/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; +diff --git a/bootstrap b/bootstrap +index 5b08e7e2d..fe7557afe 100755 +--- a/bootstrap ++++ b/bootstrap +@@ -162,6 +162,11 @@ bootstrap_post_import_hook() { :; } + # Override it via your own definition in bootstrap.conf. + bootstrap_epilogue() { :; } + ++# A function to be called after bootstrap_epilogue. It adds support ++# for SW64. ++# Override it via your own definition in bootstrap.conf. ++bootstrap_sunway() { :; } ++ + # The command to download all .po files for a specified domain into a + # specified directory. Fill in the first %s with the destination + # directory and the second with the domain name. +@@ -1061,6 +1066,7 @@ if test $with_gettext = yes; then + fi + + bootstrap_epilogue ++bootstrap_sunway + + echo "$0: done. Now you can run './configure'." + +diff --git a/bootstrap.conf b/bootstrap.conf +index 6b043fc35..badc90633 100644 +--- a/bootstrap.conf ++++ b/bootstrap.conf +@@ -99,3 +99,9 @@ bootstrap_post_import_hook () { + bootstrap_epilogue () { + mv INSTALL.grub INSTALL + } ++ ++bootstrap_sunway () { ++ set -e ++ patch -p1 < "grub-core/lib/gnulib-patches/add-sw64-support.patch" ++ set +e ++} +diff --git a/conf/Makefile.common b/conf/Makefile.common +index 2a1a886f6..1fe0761ea 100644 +--- a/conf/Makefile.common ++++ b/conf/Makefile.common +@@ -9,6 +9,9 @@ unexport LC_ALL + if COND_sparc64_ieee1275 + LDFLAGS_PLATFORM = -Wl,-melf64_sparc + endif ++if COND_sw_64_efi ++ CFLAGS_PLATFORM += -Wno-packed-not-aligned -Wno-cast-align -Wno-sign-compare ++endif + if COND_arm + if !COND_emu + LDFLAGS_PLATFORM = -Wl,--wrap=__clear_cache +diff --git a/configure.ac b/configure.ac +index 7517fc49d..49efcb635 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -80,7 +80,7 @@ grub_TRANSFORM([grub-file]) + + # Optimization flag. Allow user to override. + if test "x$TARGET_CFLAGS" = x; then +- TARGET_CFLAGS=-Os ++ TARGET_CFLAGS=-O2 + fi + + # Enable support for "restrict" keyword and other +@@ -119,6 +119,9 @@ case "$target_cpu" in + riscv64*) + target_cpu=riscv64 + ;; ++ sw_64*) ++ target_cpu=sw64 ++ ;; + esac + + # Specify the platform (such as firmware). +@@ -144,6 +147,7 @@ if test "x$with_platform" = x; then + arm64-*) platform=efi ;; + riscv32-*) platform=efi ;; + riscv64-*) platform=efi ;; ++ sw64-*) platform=efi ;; + *) + AC_MSG_WARN([unsupported CPU: "$target_cpu" - only building utilities]) + platform=none +@@ -194,6 +198,7 @@ case "$target_cpu"-"$platform" in + arm64-efi) ;; + riscv32-efi) ;; + riscv64-efi) ;; ++ sw64-efi) ;; + *-emu) ;; + *-none) ;; + *) AC_MSG_ERROR([platform "$platform" is not supported for target CPU "$target_cpu"]) ;; +@@ -1999,6 +2004,7 @@ AM_CONDITIONAL([COND_riscv32], [test x$target_cpu = xriscv32 ]) + AM_CONDITIONAL([COND_riscv64], [test x$target_cpu = xriscv64 ]) + AM_CONDITIONAL([COND_riscv32_efi], [test x$target_cpu = xriscv32 -a x$platform = xefi]) + AM_CONDITIONAL([COND_riscv64_efi], [test x$target_cpu = xriscv64 -a x$platform = xefi]) ++AM_CONDITIONAL([COND_sw_64_efi], [test x$target_cpu = xsw64 -a x$platform = xefi]) + + AM_CONDITIONAL([COND_HOST_HURD], [test x$host_kernel = xhurd]) + AM_CONDITIONAL([COND_HOST_LINUX], [test x$host_kernel = xlinux]) +diff --git a/gentpl.py b/gentpl.py +index c86550d4f..1a088e72c 100644 +--- a/gentpl.py ++++ b/gentpl.py +@@ -32,7 +32,8 @@ GRUB_PLATFORMS = [ "emu", "i386_pc", "i386_efi", "i386_qemu", "i386_coreboot", + "mips_loongson", "sparc64_ieee1275", + "powerpc_ieee1275", "mips_arc", "ia64_efi", + "mips_qemu_mips", "arm_uboot", "arm_efi", "arm64_efi", +- "arm_coreboot", "riscv32_efi", "riscv64_efi" ] ++ "arm_coreboot", "riscv32_efi", "riscv64_efi", ++ "sw_64_efi" ] + + GROUPS = {} + +@@ -49,11 +50,12 @@ GROUPS["arm"] = [ "arm_uboot", "arm_efi", "arm_coreboot" ] + GROUPS["arm64"] = [ "arm64_efi" ] + GROUPS["riscv32"] = [ "riscv32_efi" ] + GROUPS["riscv64"] = [ "riscv64_efi" ] ++GROUPS["sw_64"] = [ "sw_64_efi" ] + + # Groups based on firmware + GROUPS["pc"] = [ "i386_pc" ] + GROUPS["efi"] = [ "i386_efi", "x86_64_efi", "ia64_efi", "arm_efi", "arm64_efi", +- "riscv32_efi", "riscv64_efi" ] ++ "riscv32_efi", "riscv64_efi", "sw_64_efi" ] + GROUPS["ieee1275"] = [ "i386_ieee1275", "sparc64_ieee1275", "powerpc_ieee1275" ] + GROUPS["uboot"] = [ "arm_uboot" ] + GROUPS["xen"] = [ "i386_xen", "x86_64_xen" ] +@@ -79,7 +81,7 @@ GROUPS["terminfomodule"] = GRUB_PLATFORMS[:]; + for i in GROUPS["terminfoinkernel"]: GROUPS["terminfomodule"].remove(i) + + # Flattened Device Trees (FDT) +-GROUPS["fdt"] = [ "arm64_efi", "arm_uboot", "arm_efi", "riscv32_efi", "riscv64_efi" ] ++GROUPS["fdt"] = [ "arm64_efi", "arm_uboot", "arm_efi", "riscv32_efi", "riscv64_efi", "sw_64_efi" ] + + # Needs software helpers for division + # Must match GRUB_DIVISION_IN_SOFTWARE in misc.h +diff --git a/grub-core/Makefile.am b/grub-core/Makefile.am +index ee88e44e9..817efa054 100644 +--- a/grub-core/Makefile.am ++++ b/grub-core/Makefile.am +@@ -198,6 +198,13 @@ if COND_mips + KERNEL_HEADER_FILES += $(top_builddir)/include/grub/cpu/kernel.h + endif + ++if COND_sw_64_efi ++KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/efi/efi.h ++KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/efi/disk.h ++KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/sw64/divide.h ++KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/acpi.h ++endif ++ + if COND_mips_arc + KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/extcmd.h + KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/arc/arc.h +diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def +index 8022e1c0a..692e649e0 100644 +--- a/grub-core/Makefile.core.def ++++ b/grub-core/Makefile.core.def +@@ -93,6 +93,8 @@ kernel = { + sparc64_ieee1275_ldflags = '-Wl,-Ttext,0x4400'; + mips_arc_ldflags = '-Wl,-Ttext,$(TARGET_LINK_ADDR)'; + mips_qemu_mips_ldflags = '-Wl,-Ttext,0x80200000'; ++ sw_64_efi_ldflags = '-Wl,-r,-d'; ++ sw_64_efi_stripflags = '--strip-unneeded -K start -R .note -R .comment -R .note.gnu.gold-version'; + + mips_arc_cppflags = '-DGRUB_DECOMPRESSOR_LINK_ADDR=$(TARGET_DECOMPRESSOR_LINK_ADDR)'; + i386_qemu_cppflags = '-DGRUB_BOOT_MACHINE_LINK_ADDR=$(GRUB_BOOT_MACHINE_LINK_ADDR)'; +@@ -122,6 +124,7 @@ kernel = { + arm64_efi_startup = kern/arm64/efi/startup.S; + riscv32_efi_startup = kern/riscv/efi/startup.S; + riscv64_efi_startup = kern/riscv/efi/startup.S; ++ sw_64_efi_startup = kern/sw64/efi/startup.S; + + common = kern/buffer.c; + common = kern/command.c; +@@ -314,6 +317,17 @@ kernel = { + extra_dist = video/sis315_init.c; + mips_loongson = commands/keylayouts.c; + ++ sw_64_efi = kern/sw64/dl.c; ++ sw_64_efi = kern/sw64/dl_helper.c; ++ sw_64_efi = kern/sw64/efi/init.c; ++ sw_64_efi = kern/efi/fdt.c; ++ sw_64_efi = lib/sw64/divide.S; ++ sw_64_efi = kern/sw64/efi/callwrap.S; ++ sw_64_efi = kern/sw64/cache.c; ++ sw_64_efi = kern/sw64/cache_flush.S; ++ sw_64_efi = commands/keylayouts.c; ++ sw_64_efi = kern/sw64/debug.c; ++ + powerpc_ieee1275 = kern/powerpc/cache.S; + powerpc_ieee1275 = kern/powerpc/dl.c; + powerpc_ieee1275 = kern/powerpc/compiler-rt.S; +@@ -829,6 +843,7 @@ module = { + enable = arm_coreboot; + enable = riscv32_efi; + enable = riscv64_efi; ++ enable = sw_64_efi; + }; + + module = { +@@ -906,6 +921,7 @@ module = { + i386_multiboot = commands/acpihalt.c; + i386_efi = commands/acpihalt.c; + x86_64_efi = commands/acpihalt.c; ++ sw_64_efi = commands/acpihalt.c; + i386_multiboot = lib/i386/halt.c; + i386_coreboot = lib/i386/halt.c; + i386_qemu = lib/i386/halt.c; +@@ -1708,6 +1724,8 @@ module = { + extra_dist = lib/arm/setjmp.S; + extra_dist = lib/arm64/setjmp.S; + extra_dist = lib/riscv/setjmp.S; ++ extra_dist = lib/sw64/setjmp.S; ++ extra_dist = lib/sw64/divide.S; + }; + + module = { +@@ -1811,6 +1829,7 @@ module = { + arm64 = loader/arm64/linux.c; + riscv32 = loader/riscv/linux.c; + riscv64 = loader/riscv/linux.c; ++ sw_64_efi = loader/sw64/efi/linux.c; + emu = loader/emu/linux.c; + + common = loader/linux.c; +@@ -1908,6 +1927,7 @@ module = { + enable = riscv32_efi; + enable = riscv64_efi; + enable = mips; ++ enable = sw_64; + }; + + module = { +diff --git a/grub-core/commands/file.c b/grub-core/commands/file.c +index 9de00061e..868930bda 100644 +--- a/grub-core/commands/file.c ++++ b/grub-core/commands/file.c +@@ -94,6 +94,8 @@ static const struct grub_arg_option options[] = { + N_("Check if FILE is RISC-V 32bit EFI file"), 0, 0}, + {"is-riscv64-efi", 0, 0, + N_("Check if FILE is RISC-V 64bit EFI file"), 0, 0}, ++ {"is-sw64-efi", 0, 0, ++ N_("Check if FILE is SW64 EFI file"), 0, 0}, + {"is-hibernated-hiberfil", 0, 0, + N_("Check if FILE is hiberfil.sys in hibernated state"), 0, 0}, + {"is-x86_64-xnu", 0, 0, +@@ -136,6 +138,7 @@ enum + IS_ARM_EFI, + IS_RISCV32_EFI, + IS_RISCV64_EFI, ++ IS_SW64_EFI, + IS_HIBERNATED, + IS_XNU64, + IS_XNU32, +@@ -579,6 +582,7 @@ grub_cmd_file (grub_extcmd_context_t ctxt, int argc, char **args) + case IS_ARM_EFI: + case IS_RISCV32_EFI: + case IS_RISCV64_EFI: ++ case IS_SW64_EFI: + { + char signature[4]; + grub_uint32_t pe_offset; +@@ -629,8 +633,13 @@ grub_cmd_file (grub_extcmd_context_t ctxt, int argc, char **args) + grub_cpu_to_le16_compile_time (GRUB_PE32_MACHINE_RISCV64)) + /* TODO: Determine bitness dynamically */ + break; ++ if (type == IS_SW64_EFI ++ && coff_head.machine != ++ grub_cpu_to_le16_compile_time (GRUB_PE32_MACHINE_SW_64)) ++ /* TODO: Determine bitness dynamically */ ++ break; + if (type == IS_IA_EFI || type == IS_64_EFI || type == IS_ARM64_EFI || +- type == IS_RISCV32_EFI || type == IS_RISCV64_EFI) ++ type == IS_RISCV32_EFI || type == IS_RISCV64_EFI || type == IS_SW64_EFI) + { + struct grub_pe64_optional_header o64; + if (grub_file_read (file, &o64, sizeof (o64)) != sizeof (o64)) +diff --git a/grub-core/kern/compiler-rt.c b/grub-core/kern/compiler-rt.c +index 2057c2e0c..aac8742bc 100644 +--- a/grub-core/kern/compiler-rt.c ++++ b/grub-core/kern/compiler-rt.c +@@ -345,7 +345,7 @@ __ucmpdi2 (grub_uint64_t a, grub_uint64_t b) + #endif + + #if defined (__powerpc__) || defined(__mips__) || defined(__sparc__) || \ +- defined(__arm__) || defined(__riscv) ++ defined(__arm__) || defined(__riscv) || defined(__sw_64__) + + /* Based on libgcc2.c from gcc suite. */ + grub_uint32_t +diff --git a/grub-core/kern/efi/mm.c b/grub-core/kern/efi/mm.c +index 9838fb2f5..5c0b108a6 100644 +--- a/grub-core/kern/efi/mm.c ++++ b/grub-core/kern/efi/mm.c +@@ -659,7 +659,7 @@ grub_efi_mm_init (void) + 2 * BYTES_TO_PAGES (MEMORY_MAP_SIZE)); + } + +-#if defined (__aarch64__) || defined (__arm__) || defined (__riscv) ++#if defined (__aarch64__) || defined (__arm__) || defined (__riscv) || defined (__sw_64__) + grub_err_t + grub_efi_get_ram_base(grub_addr_t *base_addr) + { +diff --git a/grub-core/kern/misc.c b/grub-core/kern/misc.c +index 3af336ee2..fdb91ecd9 100644 +--- a/grub-core/kern/misc.c ++++ b/grub-core/kern/misc.c +@@ -133,6 +133,21 @@ grub_printf_ (const char *fmt, ...) + return ret; + } + ++#ifdef __sw_64__ ++int ++grub_printk (const char *fmt, ...) ++{ ++ va_list ap; ++ int ret; ++ ++ va_start (ap, fmt); ++ ret = grub_vprintk (fmt, ap); ++ va_end (ap); ++ ++ return ret; ++} ++#endif ++ + int + grub_puts_ (const char *s) + { +@@ -221,6 +236,9 @@ grub_vprintf (const char *fmt, va_list ap) + + free_printf_args (&args); + ++#ifdef __sw_64__ ++ sunway_debug_delegate(curbuf); ++#endif + grub_xputs (curbuf); + + if (curbuf != buf) +@@ -229,6 +247,45 @@ grub_vprintf (const char *fmt, va_list ap) + return s; + } + ++#ifdef __sw_64__ ++int ++grub_vprintk (const char *fmt, va_list ap) ++{ ++ grub_size_t s; ++ static char buf[PREALLOC_SIZE + 1]; ++ char *curbuf = buf; ++ struct printf_args args; ++ ++ parse_printf_args (fmt, &args, ap); ++ ++ s = grub_vsnprintf_real (buf, PREALLOC_SIZE, fmt, &args); ++ if (s > PREALLOC_SIZE) ++ { ++ curbuf = grub_malloc (s + 1); ++ if (!curbuf) ++ { ++ grub_errno = GRUB_ERR_NONE; ++ buf[PREALLOC_SIZE - 3] = '.'; ++ buf[PREALLOC_SIZE - 2] = '.'; ++ buf[PREALLOC_SIZE - 1] = '.'; ++ buf[PREALLOC_SIZE] = 0; ++ curbuf = buf; ++ } ++ else ++ s = grub_vsnprintf_real (curbuf, s, fmt, &args); ++ } ++ ++ free_printf_args (&args); ++ ++ sunway_debug_delegate(curbuf); ++ ++ if (curbuf != buf) ++ grub_free (curbuf); ++ ++ return s; ++} ++#endif ++ + int + grub_memcmp (const void *s1, const void *s2, grub_size_t n) + { +diff --git a/grub-core/kern/sw64/cache.c b/grub-core/kern/sw64/cache.c +new file mode 100644 +index 000000000..9278dda83 +--- /dev/null ++++ b/grub-core/kern/sw64/cache.c +@@ -0,0 +1,63 @@ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2018 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 . ++ */ ++ ++#include ++#include ++ ++static grub_int64_t dlinesz; ++static grub_int64_t ilinesz; ++ ++/* Prototypes for asm functions. */ ++void grub_arch_clean_dcache_range (grub_addr_t beg, grub_addr_t end, ++ grub_size_t line_size); ++void grub_arch_invalidate_icache_range (grub_addr_t beg, grub_addr_t end, ++ grub_size_t line_size); ++ ++static void ++probe_caches (void) ++{ ++ /* TODO */ ++ dlinesz = 128; ++ ilinesz = 128; ++} ++ ++void ++grub_arch_sync_caches (void *address, grub_size_t len) ++{ ++ grub_size_t start, end, max_align; ++ ++ if (dlinesz == 0) ++ probe_caches(); ++ if (dlinesz == 0) ++ grub_fatal ("Unknown cache line size!"); ++ ++ max_align = dlinesz > ilinesz ? dlinesz : ilinesz; ++ ++ start = ALIGN_DOWN ((grub_size_t) address, max_align); ++ end = ALIGN_UP ((grub_size_t) address + len, max_align); ++ ++ grub_arch_clean_dcache_range (start, end, dlinesz); ++ grub_arch_invalidate_icache_range (start, end, ilinesz); ++} ++ ++void ++grub_arch_sync_dma_caches (volatile void *address __attribute__((unused)), ++ grub_size_t len __attribute__((unused))) ++{ ++ /* DMA incoherent devices not supported yet */ ++} +diff --git a/grub-core/kern/sw64/cache_flush.S b/grub-core/kern/sw64/cache_flush.S +new file mode 100644 +index 000000000..dde3e5c3e +--- /dev/null ++++ b/grub-core/kern/sw64/cache_flush.S +@@ -0,0 +1,44 @@ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2018 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 . ++ */ ++ ++#include ++ ++ .file "cache_flush.S" ++ .text ++ ++/* ++ * Simple cache maintenance functions ++ */ ++ ++/* ++ * a0 - *beg (inclusive) ++ * a1 - *end (exclusive) ++ * a2 - line size ++*/ ++FUNCTION(grub_arch_clean_dcache_range) ++ /* TODO */ ++ ret ++ ++/* ++ * a0 - *beg (inclusive) ++ * a1 - *end (exclusive) ++ * a2 - line size ++ */ ++FUNCTION(grub_arch_invalidate_icache_range) ++ memb ++ ret +diff --git a/grub-core/kern/sw64/debug.c b/grub-core/kern/sw64/debug.c +new file mode 100644 +index 000000000..2d9fe240c +--- /dev/null ++++ b/grub-core/kern/sw64/debug.c +@@ -0,0 +1,38 @@ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2018 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 . ++ */ ++ ++#include ++#include ++ ++void sunway_debug_delegate(char *buffer) ++{ ++ unsigned int *print_base = (unsigned int *)(GRUB_PRINTK_START + GRUB_PRINTK_SIZE - sizeof(int)); ++ unsigned int bytes_written = *print_base; ++ int num_bytes = grub_strlen(buffer); ++ ++ if ((bytes_written + num_bytes) > (GRUB_PRINTK_SIZE - sizeof(unsigned int))) ++ { ++ grub_memset((void *)GRUB_PRINTK_START, 0, GRUB_PRINTK_SIZE); ++ bytes_written = *print_base = 0; ++ } ++ ++ grub_memcpy((void *)(GRUB_PRINTK_START + bytes_written), (void *)buffer, num_bytes); ++ *print_base += num_bytes; ++ ++ return ; ++} +diff --git a/grub-core/kern/sw64/dl.c b/grub-core/kern/sw64/dl.c +new file mode 100644 +index 000000000..8e3cac26b +--- /dev/null ++++ b/grub-core/kern/sw64/dl.c +@@ -0,0 +1,214 @@ ++/* dl.c - arch-dependent part of loadable module support */ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2018 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 . ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++/* ++ * Check if EHDR is a valid ELF header. ++ */ ++grub_err_t ++grub_arch_dl_check_header (void *ehdr) ++{ ++ Elf_Ehdr *e = ehdr; ++ ++ /* Check the magic numbers. */ ++ if (e->e_ident[EI_DATA] != ELFDATA2LSB || e->e_machine != EM_SW_64) ++ return grub_error (GRUB_ERR_BAD_OS, ++ N_("invalid arch-dependent ELF magic")); ++ ++ return GRUB_ERR_NONE; ++} ++ ++#pragma GCC diagnostic ignored "-Wcast-align" ++ ++/* Relocate symbols. */ ++grub_err_t ++grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr, ++ Elf_Shdr *s, grub_dl_segment_t seg) ++{ ++ Elf_Rela *rel, *max; ++ grub_uint64_t *gpptr, *gotptr; ++ ++ gotptr = (grub_uint64_t *) mod->got; ++ gpptr = (grub_uint64_t *) ((grub_uint64_t) mod->got + 0x8000); ++ ++ for (rel = (Elf_Rela *) ((char *) ehdr + s->sh_offset), ++ max = (Elf_Rela *) ((char *) rel + s->sh_size); ++ rel < max; ++ rel = (Elf_Rela *) ((char *) rel + s->sh_entsize)) ++ { ++ grub_addr_t addr; ++ Elf_Sym *sym; ++ grub_uint64_t value; ++ ++ if (seg->size < (rel->r_offset & ~3)) ++ return grub_error (GRUB_ERR_BAD_MODULE, ++ "reloc offset is out of the segment"); ++ ++ addr = (grub_addr_t) seg->addr + rel->r_offset; ++ sym = (Elf_Sym *) ((char *) mod->symtab ++ + mod->symsize * ELF_R_SYM (rel->r_info)); ++ ++ /* On the PPC the value does not have an explicit ++ addend, add it. */ ++ value = sym->st_value + rel->r_addend; ++ ++ switch (ELF_R_TYPE (rel->r_info)) ++ { ++ case R_SW64_NONE: ++ break; ++ case R_SW64_REFLONG: ++ *(grub_uint32_t *)addr = value; ++ break; ++ case R_SW64_REFQUAD: ++ { ++ *(grub_uint32_t *)addr = value; ++ *((grub_uint32_t *)addr + 1) = value >> 32; ++ break; ++ } ++ case R_SW64_GPREL32: ++ { ++ value -= (grub_uint64_t)gpptr; ++ if ((grub_int32_t)value != value) ++ return grub_error (GRUB_ERR_BAD_MODULE, ++ "R_SW64_GPREL32 relocation out of range"); ++ *(grub_uint32_t *) addr = value; ++ break; ++ } ++ case R_SW64_LITERAL: ++ { ++ grub_uint64_t li_hi; ++ grub_uint64_t li_lo; ++ ++ li_hi = (grub_uint64_t) gotptr + (((grub_uint64_t)ELF_R_TYPE(rel->r_info)) >> 8 ); ++ li_lo = li_hi - ((grub_uint64_t) gpptr); ++ if ((grub_int16_t)li_lo != li_lo) ++ return grub_error (GRUB_ERR_BAD_MODULE, ++ "R_SW64_LITERAL relocation out of range"); ++ ++ *(grub_uint16_t *) addr = (li_lo & 0xffff); ++ *(grub_uint64_t *) (li_hi) = value; ++ gotptr++; ++ break; ++ } ++ case R_SW64_LITERAL_GOT: ++ break; ++ case R_SW64_LITUSE: ++ break; ++ case R_SW64_GPDISP: ++ { ++ grub_uint64_t hi; ++ grub_uint64_t lo; ++ grub_uint64_t gpoffset = (grub_int64_t)gpptr - addr; ++ lo = (grub_int16_t) gpoffset; ++ hi = (grub_int32_t) (gpoffset - lo); ++ if (hi + lo != gpoffset) ++ return grub_error (GRUB_ERR_BAD_MODULE, ++ "R_SW64_GPDISP relocation out of range"); ++ ++ if (gpoffset & 0x8000) { ++ hi = ((gpoffset + 0x8000) >> 16) & 0xffff; ++ lo = gpoffset & 0xffff; ++ } else { ++ hi = (gpoffset >> 16) & 0xffff; ++ lo = gpoffset & 0xffff; ++ } ++ ++ *(grub_uint32_t *) addr = ( *(grub_uint32_t *)addr & 0xffff0000) | (hi & 0xffff); ++ *(grub_uint32_t *) ((unsigned long)addr + rel->r_addend) = ++ (((*(grub_uint32_t *)((unsigned long)addr + rel->r_addend)) & 0xffff0000) | (lo & 0xffff)); ++ break; ++ } ++ case R_SW64_BRADDR: ++ { ++ grub_uint64_t braddr = (*(grub_uint64_t *)addr) + value - ((grub_uint64_t)addr + 4); ++ braddr = (grub_int64_t)braddr >> 2; ++ if (braddr + (1<<21) >= 1<<21) ++ return grub_error (GRUB_ERR_BAD_MODULE, ++ "R_SW64_BRADDR relocation out of range"); ++ ++ *(grub_uint32_t *) addr = (*(grub_uint32_t *)addr & (~0x1fffff)) | (braddr & 0x1fffff); ++ break; ++ } ++ case R_SW64_HINT: ++ break; ++ case R_SW64_SREL32: ++ { ++ value -= (grub_uint64_t)addr; ++ if ((grub_int32_t)value != value) ++ return grub_error (GRUB_ERR_BAD_MODULE, ++ "R_SW64_SREL32 relocation out of range"); ++ ++ *(grub_uint32_t *) addr = value; ++ break; ++ } ++ case R_SW64_SREL64: ++ { ++ grub_uint64_t srel64 = *(grub_uint64_t *)addr + value;; ++ srel64 -= (grub_uint64_t)addr; ++ *(grub_uint64_t *) addr = srel64; ++ break; ++ } ++ case R_SW64_GPRELHIGH: ++ { ++ grub_uint64_t gprel_hi = (grub_int64_t)(value - (grub_uint64_t)gpptr); ++ ++ if (gprel_hi & 0x8000) ++ gprel_hi = (grub_int64_t)(((grub_int64_t)gprel_hi + 0x8000) >> 16); ++ else ++ gprel_hi = (grub_int64_t)gprel_hi >> 16; ++ ++ if ((grub_int16_t)gprel_hi != gprel_hi) ++ return grub_error (GRUB_ERR_BAD_MODULE, ++ "GPRELHIGH out of range\n"); ++ ++ *(grub_uint32_t *) addr = (*(grub_uint32_t *)addr & 0xffff0000) | (gprel_hi & 0xffff); ++ break; ++ } ++ case R_SW64_GPRELLOW: ++ { ++ grub_uint64_t gprel_lo = value - (grub_uint64_t)gpptr; ++ *(grub_uint32_t *) addr = (*(grub_uint32_t *)addr & 0xffff0000) | (gprel_lo & 0xffff); ++ break; ++ } ++ case R_SW64_GPREL16: ++ { ++ grub_uint64_t gprel16 = (*(grub_uint64_t *)addr + value); ++ gprel16 = (grub_uint64_t)(gprel16 - (grub_uint64_t)gpptr); ++ if ((grub_int16_t)gprel16 != gprel16) ++ return grub_error (GRUB_ERR_BAD_MODULE, ++ "R_SW64_GPREL16 relocation out of range"); ++ *(grub_uint16_t *) addr = gprel16; ++ break; ++ } ++ default: ++ return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, ++ N_("relocation 0x%lx is not implemented yet"), ++ ELF_R_TYPE (rel->r_info)); ++ } ++ } ++ ++ return GRUB_ERR_NONE; ++} +diff --git a/grub-core/kern/sw64/dl_helper.c b/grub-core/kern/sw64/dl_helper.c +new file mode 100644 +index 000000000..9628ddf7b +--- /dev/null ++++ b/grub-core/kern/sw64/dl_helper.c +@@ -0,0 +1,72 @@ ++/* dl.c - arch-dependent part of loadable module support */ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2002,2004,2005,2007,2009 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 . ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++ ++#pragma GCC diagnostic ignored "-Wcast-align" ++ ++grub_err_t ++grub_sw64_dl_get_tramp_got_size (const void *ehdr, grub_size_t *tramp, ++ grub_size_t *got) ++{ ++ const Elf64_Ehdr *e = ehdr; ++ grub_size_t cntt = 0, cntg = 0;; ++ const Elf64_Shdr *s; ++ unsigned i; ++ ++ *tramp = 0; ++ *got = 0; ++ ++ /* Find a symbol table. */ ++ for (i = 0, s = (Elf64_Shdr *) ((char *) e + grub_le_to_cpu32 (e->e_shoff)); ++ i < grub_le_to_cpu16 (e->e_shnum); ++ i++, s = (Elf64_Shdr *) ((char *) s + grub_le_to_cpu16 (e->e_shentsize))) ++ if (grub_le_to_cpu32 (s->sh_type) == SHT_SYMTAB) ++ break; ++ ++ if (i == grub_le_to_cpu16 (e->e_shnum)) ++ return GRUB_ERR_NONE; ++ ++ for (i = 0, s = (Elf64_Shdr *) ((char *) e + grub_le_to_cpu32 (e->e_shoff)); ++ i < grub_le_to_cpu16 (e->e_shnum); ++ i++, s = (Elf64_Shdr *) ((char *) s + grub_le_to_cpu16 (e->e_shentsize))) ++ if (grub_le_to_cpu32 (s->sh_type) == SHT_RELA) ++ { ++ Elf64_Rela *rel, *max; ++ ++ for (rel = (Elf64_Rela *) ((char *) e + grub_le_to_cpu32 (s->sh_offset)), ++ max = rel + grub_le_to_cpu32 (s->sh_size) / grub_le_to_cpu16 (s->sh_entsize); ++ rel < max; rel++) ++ switch (ELF64_R_TYPE (grub_le_to_cpu32 (rel->r_info))) ++ { ++ case R_SW64_LITERAL: ++ cntg++; ++ break; ++ } ++ } ++ *tramp = cntt; ++ *got = cntg * sizeof (grub_uint64_t); ++ ++ return GRUB_ERR_NONE; ++} ++ +diff --git a/grub-core/kern/sw64/efi/callwrap.S b/grub-core/kern/sw64/efi/callwrap.S +new file mode 100644 +index 000000000..13ee13d68 +--- /dev/null ++++ b/grub-core/kern/sw64/efi/callwrap.S +@@ -0,0 +1,261 @@ ++ .file "callwrap.S" ++ .text ++ .align 4 ++ .globl sw_efi_wrap_0 ++ .globl sw_efi_wrap_1 ++ .globl sw_efi_wrap_2 ++ .globl sw_efi_wrap_3 ++ .globl sw_efi_wrap_4 ++ .globl sw_efi_wrap_5 ++ .globl sw_efi_wrap_6 ++ .globl sw_efi_wrap_7 ++ .globl sw_efi_wrap_10 ++ ++ .ent sw_efi_wrap_0 ++sw_efi_wrap_0: ++ ++ ldi $30,-32($30) ++ stl $26,0($30) ++ stl $15,8($30) ++ mov $30,$15 ++ .prologue 1 ++ stl $16,16($15) ++ ldl $27,16($15) ++ call $26,($27),0 ++ #ldi $29,0($29) !gpdisp!29 ++ mov $15,$30 ++ ldl $26,0($30) ++ ldl $15,8($30) ++ ldi $30,32($30) ++ ret $31,($26),1 ++ ++ .end sw_efi_wrap_0 ++ ++ .ent sw_efi_wrap_1 ++sw_efi_wrap_1: ++ ++ ldi $30,-32($30) ++ stl $26,0($30) ++ stl $15,8($30) ++ mov $30,$15 ++ .prologue 1 ++ stl $16,16($15) ++ stl $17,24($15) ++ ldl $27,16($15) ++ ldl $16,24($15) ++ call $26,($27),0 ++ #ldih $29,0($26) !gpdisp!31 ++ #ldi $29,0($29) !gpdisp!31 ++ mov $15,$30 ++ ldl $26,0($30) ++ ldl $15,8($30) ++ ldi $30,32($30) ++ ret $31,($26),1 ++ .end sw_efi_wrap_1 ++ ++ .ent sw_efi_wrap_2 ++sw_efi_wrap_2: ++ ldi $30,-48($30) ++ stl $26,0($30) ++ stl $15,8($30) ++ mov $30,$15 ++ .prologue 1 ++ stl $16,16($15) ++ stl $17,24($15) ++ stl $18,32($15) ++ ldl $27,16($15) ++ ldl $16,24($15) ++ ldl $17,32($15) ++ call $26,($27),0 ++ #ldih $29,0($26) !gpdisp!33 ++ #ldi $29,0($29) !gpdisp!33 ++ mov $15,$30 ++ ldl $26,0($30) ++ ldl $15,8($30) ++ ldi $30,48($30) ++ ret $31,($26),1 ++ .end sw_efi_wrap_2 ++ ++ .ent sw_efi_wrap_3 ++sw_efi_wrap_3: ++ ldi $30,-48($30) ++ stl $26,0($30) ++ stl $15,8($30) ++ mov $30,$15 ++ .prologue 1 ++ stl $16,16($15) ++ stl $17,24($15) ++ stl $18,32($15) ++ stl $19,40($15) ++ ldl $27,16($15) ++ ldl $16,24($15) ++ ldl $17,32($15) ++ ldl $18,40($15) ++ call $26,($27),0 ++ #ldih $29,0($26) !gpdisp!35 ++ #ldi $29,0($29) !gpdisp!35 ++ mov $15,$30 ++ ldl $26,0($30) ++ ldl $15,8($30) ++ ldi $30,48($30) ++ ret $31,($26),1 ++ .end sw_efi_wrap_3 ++ ++ .ent sw_efi_wrap_4 ++sw_efi_wrap_4: ++ ldi $30,-64($30) ++ stl $26,0($30) ++ stl $15,8($30) ++ mov $30,$15 ++ .prologue 1 ++ stl $16,16($15) ++ stl $17,24($15) ++ stl $18,32($15) ++ stl $19,40($15) ++ stl $20,48($15) ++ ldl $27,16($15) ++ ldl $16,24($15) ++ ldl $17,32($15) ++ ldl $18,40($15) ++ ldl $19,48($15) ++ call $26,($27),0 ++ #ldih $29,0($26) !gpdisp!37 ++ #ldi $29,0($29) !gpdisp!37 ++ mov $15,$30 ++ ldl $26,0($30) ++ ldl $15,8($30) ++ ldi $30,64($30) ++ ret $31,($26),1 ++ .end sw_efi_wrap_4 ++ ++ .ent sw_efi_wrap_5 ++sw_efi_wrap_5: ++ ldi $30,-64($30) ++ stl $26,0($30) ++ stl $15,8($30) ++ mov $30,$15 ++ .prologue 1 ++ stl $16,16($15) ++ stl $17,24($15) ++ stl $18,32($15) ++ stl $19,40($15) ++ stl $20,48($15) ++ stl $21,56($15) ++ ldl $27,16($15) ++ ldl $16,24($15) ++ ldl $17,32($15) ++ ldl $18,40($15) ++ ldl $19,48($15) ++ ldl $20,56($15) ++ call $26,($27),0 ++ #ldih $29,0($26) !gpdisp!39 ++ #ldi $29,0($29) !gpdisp!39 ++ mov $15,$30 ++ ldl $26,0($30) ++ ldl $15,8($30) ++ ldi $30,64($30) ++ ret $31,($26),1 ++ .end sw_efi_wrap_5 ++ ++ ++ .ent sw_efi_wrap_6 ++sw_efi_wrap_6: ++ ldi $30,-64($30) ++ stl $26,0($30) ++ stl $15,8($30) ++ mov $30,$15 ++ .prologue 1 ++ stl $16,16($15) ++ stl $17,24($15) ++ stl $18,32($15) ++ stl $19,40($15) ++ stl $20,48($15) ++ stl $21,56($15) ++ ldl $27,16($15) ++ ldl $16,24($15) ++ ldl $17,32($15) ++ ldl $18,40($15) ++ ldl $19,48($15) ++ ldl $20,56($15) ++ ldl $21,64($15) ++ call $26,($27),0 ++ #ldih $29,0($26) !gpdisp!41 ++ #ldi $29,0($29) !gpdisp!41 ++ mov $15,$30 ++ ldl $26,0($30) ++ ldl $15,8($30) ++ ldi $30,64($30) ++ ret $31,($26),1 ++ .end sw_efi_wrap_6 ++ ++ .ent sw_efi_wrap_7 ++sw_efi_wrap_7: ++ ldi $30,-80($30) ++ stl $26,16($30) ++ stl $15,24($30) ++ mov $30,$15 ++ .prologue 1 ++ stl $16,32($15) ++ stl $17,40($15) ++ stl $18,48($15) ++ stl $19,56($15) ++ stl $20,64($15) ++ stl $21,72($15) ++ ldl $1,88($15) ++ stl $1,0($30) ++ ldl $27,32($15) ++ ldl $16,40($15) ++ ldl $17,48($15) ++ ldl $18,56($15) ++ ldl $19,64($15) ++ ldl $20,72($15) ++ ldl $21,80($15) ++ call $26,($27),0 ++ #ldih $29,0($26) !gpdisp!43 ++ #ldi $29,0($29) !gpdisp!43 ++ mov $15,$30 ++ ldl $26,16($30) ++ ldl $15,24($30) ++ ldi $30,80($30) ++ ret $31,($26),1 ++ .end sw_efi_wrap_7 ++ ++ ++ .ent sw_efi_wrap_10 ++sw_efi_wrap_10: ++ ldi $30,-96($30) ++ stl $26,32($30) ++ stl $15,40($30) ++ mov $30,$15 ++ .prologue 1 ++ stl $16,48($15) ++ stl $17,56($15) ++ stl $18,64($15) ++ stl $19,72($15) ++ stl $20,80($15) ++ stl $21,88($15) ++ ldl $1,104($15) ++ stl $1,0($30) ++ ldl $1,112($15) ++ stl $1,8($30) ++ ldl $1,120($15) ++ stl $1,16($30) ++ ldl $1,128($15) ++ stl $1,24($30) ++ ldl $27,48($15) ++ ldl $16,56($15) ++ ldl $17,64($15) ++ ldl $18,72($15) ++ ldl $19,80($15) ++ ldl $20,88($15) ++ ldl $21,96($15) ++ call $26,($27),0 ++ #ldih $29,0($26) !gpdisp!45 ++ #ldi $29,0($29) !gpdisp!45 ++ mov $15,$30 ++ ldl $26,32($30) ++ ldl $15,40($30) ++ ldi $30,96($30) ++ ret $31,($26),1 ++ ++ .end sw_efi_wrap_10 +diff --git a/grub-core/kern/sw64/efi/init.c b/grub-core/kern/sw64/efi/init.c +new file mode 100644 +index 000000000..1a1b2392b +--- /dev/null ++++ b/grub-core/kern/sw64/efi/init.c +@@ -0,0 +1,75 @@ ++/* init.c - initialize a riscv-based EFI system */ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2018 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 . ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++grub_uint64_t cycle_freq; ++ ++static grub_uint64_t ++rpcc(void) ++{ ++ grub_uint64_t result; ++ ++ asm volatile ("rtc %0" : "=r"(result)); ++ ++ return result; ++} ++ ++static grub_uint64_t ++grub_efi_get_time_ms(void) ++{ ++ cycle_freq = cpuid(GET_CPU_FREQ, 0) * 1000UL * 1000UL; ++ ++ return rpcc() * 1000 / cycle_freq; ++} ++ ++static void ++grub_print_info (void) ++{ ++ grub_printk ("GNU %s %s\n", PACKAGE_NAME, PACKAGE_VERSION); ++ grub_printk ("CPU freq: %ld Mhz\n", cpuid(GET_CPU_FREQ, 0)); ++ grub_printk ("Build Time: %s %s\n", __DATE__, __TIME__); ++} ++ ++void ++grub_machine_init (void) ++{ ++ grub_efi_init (); ++ grub_print_info (); ++ grub_install_get_time_ms (grub_efi_get_time_ms); ++} ++ ++void ++grub_machine_fini (int flags) ++{ ++ if (!(flags & GRUB_LOADER_FLAG_NORETURN)) ++ return; ++ ++ grub_efi_fini (); ++ ++ if (!(flags & GRUB_LOADER_FLAG_EFI_KEEP_ALLOCATED_MEMORY)) ++ grub_efi_memory_fini (); ++} +diff --git a/grub-core/kern/sw64/efi/startup.S b/grub-core/kern/sw64/efi/startup.S +new file mode 100644 +index 000000000..a78cf5cf3 +--- /dev/null ++++ b/grub-core/kern/sw64/efi/startup.S +@@ -0,0 +1,35 @@ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2018 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 . ++ */ ++ ++#include ++#include ++ .file "startup.S" ++ .text ++FUNCTION(start) ++FUNCTION(_start) ++ /* ++ * EFI_SYSTEM_TABLE and EFI_HANDLE are passed in a1/a0. ++ */ ++ ldih $29,0($27) !gpdisp!1 ++ ldi $29,0($29) !gpdisp!1 ++ ldi $20, EXT_C(grub_efi_image_handle) ++ stl a0, 0($20) ++ ldi $20, EXT_C(grub_efi_system_table) ++ stl a1, 0($20) ++ call $31, grub_main ++ ret +diff --git a/grub-core/lib/gnulib-patches/add-sw64-support.patch b/grub-core/lib/gnulib-patches/add-sw64-support.patch +new file mode 100644 +index 000000000..e5d9d4974 +--- /dev/null ++++ b/grub-core/lib/gnulib-patches/add-sw64-support.patch +@@ -0,0 +1,40 @@ ++diff --git a/build-aux/config.guess b/build-aux/config.guess ++index 8e2a58b86..d664f14cf 100755 ++--- a/build-aux/config.guess +++++ b/build-aux/config.guess ++@@ -930,6 +930,10 @@ EOF ++ UNAME_MACHINE=aarch64_be ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; +++ sw_64:Linux:*:*) +++ UNAME_MACHINE=sw_64 +++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +++ exit ;; ++ alpha:Linux:*:*) ++ case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in ++ EV5) UNAME_MACHINE=alphaev5 ;; ++diff --git a/build-aux/config.sub b/build-aux/config.sub ++index 1fc4cde1d..4bc0f8dbf 100755 ++--- a/build-aux/config.sub +++++ b/build-aux/config.sub ++@@ -917,6 +917,10 @@ case $basic_machine in ++ cpu=sparc ++ vendor=`echo "$basic_machine" | sed 's/-.*//'` ++ ;; +++ sw_64*) +++ cpu=sw_64 +++ vendor=sunway +++ ;; ++ ++ *-*) ++ # shellcheck disable=SC2162 ++@@ -1150,6 +1154,9 @@ case $cpu-$vendor in ++ tile*-*) ++ os=${os:-linux-gnu} ++ ;; +++ sw_64-*) +++ os=${os:-linux-gnu} +++ ;; ++ ++ *) ++ # Recognize the canonical CPU types that are allowed with any +diff --git a/grub-core/lib/setjmp.S b/grub-core/lib/setjmp.S +index aa297ab0a..483ba1223 100644 +--- a/grub-core/lib/setjmp.S ++++ b/grub-core/lib/setjmp.S +@@ -17,6 +17,8 @@ + #include "./arm64/setjmp.S" + #elif defined(__riscv) + #include "./riscv/setjmp.S" ++#elif defined(__sw_64__) ++#include "./sw64/setjmp.S" + #else + #error "Unknown target cpu type" + #endif +diff --git a/grub-core/lib/sw64/divide.S b/grub-core/lib/sw64/divide.S +new file mode 100644 +index 000000000..980aba670 +--- /dev/null ++++ b/grub-core/lib/sw64/divide.S +@@ -0,0 +1,677 @@ ++/* ++ * divide.S ++ * ++ * (C) 1995 Linus Torvalds ++ * ++ * Alpha division.. ++ */ ++ ++/* ++ * The alpha chip doesn't provide hardware division, so we have to do it ++ * by hand. The compiler expects the functions ++ * ++ * __divqu: 64-bit unsigned long divide ++ * __remqu: 64-bit unsigned long remainder ++ * __divqs/__remqs: signed 64-bit ++ * __divlu/__remlu: unsigned 32-bit ++ * __divls/__remls: signed 32-bit ++ * ++ * These are not normal C functions: instead of the normal ++ * calling sequence, these expect their arguments in registers ++ * $24 and $25, and return the result in $27. Register $28 may ++ * be clobbered (assemembly temporary), anything else must be saved. ++ * ++ * In short: painful. ++ * ++ * This is a rather simple bit-at-a-time algorithm: it's very good ++ * at dividing random 64-bit numembers, but the more usual case where ++ * the divisor is small is handled better by the DEC algorithm ++ * using lookup tables. This uses much less memory, though, and is ++ * nicer on the cache.. Besides, I don't know the copyright status ++ * of the DEC code. ++ */ ++ ++/* ++ * My temporaries: ++ * $0 - current bit ++ * $1 - shifted divisor ++ * $2 - modulus/quotient ++ * ++ * $23 - return address ++ * $24 - dividend ++ * $25 - divisor ++ * ++ * $27 - quotient/modulus ++ * $28 - compare status ++ */ ++ ++#define halt .long 0 ++ ++/* ++ * Select function type and registers ++ */ ++#define mask $0 ++#define divisor $1 ++#define compare $28 ++#define tmp1 $3 ++#define tmp2 $4 ++ ++#define DIV ++#define INTSIZE ++ ++#undef DIV_ONLY ++#undef MOD_ONLY ++#undef func ++#undef modulus ++#undef quotient ++#undef GETSIGN ++#undef STACK ++#undef ufunction ++#undef sfunction ++#undef LONGIFY ++#undef SLONGIFY ++ ++#ifdef DIV ++#define DIV_ONLY(x,y...) x,##y ++#define MOD_ONLY(x,y...) ++#define func(x) __div##x ++#define modulus $2 ++#define quotient $27 ++#define GETSIGN(x) xor $24,$25,x ++#define STACK 48 ++#else ++#define DIV_ONLY(x,y...) ++#define MOD_ONLY(x,y...) x,##y ++#define func(x) __rem##x ++#define modulus $27 ++#define quotient $2 ++#define GETSIGN(x) bis $24,$24,x ++#define STACK 32 ++#endif ++ ++/* ++ * For 32-bit operations, we need to extend to 64-bit ++ */ ++#ifdef INTSIZE ++#define ufunction func(wu) ++#define sfunction func(w) ++#define LONGIFY(x) zapnot x,15,x ++/* define SLONGIFY(x) addw x,0,x */ ++#define SLONGIFY(x) ++#else ++#define ufunction func(lu) ++#define sfunction func(l) ++#define LONGIFY(x) ++#define SLONGIFY(x) ++#endif ++ ++.set noat ++.align 3 ++.globl ufunction ++.ent ufunction ++ufunction: ++ subl $30,STACK,$30 ++ .frame $30,STACK,$23 ++ .prologue 0 ++ ++7: stl $1, 0($30) ++ bis $25,$25,divisor ++ stl $2, 8($30) ++ bis $24,$24,modulus ++ stl $0,16($30) ++ bis $31,$31,quotient ++ LONGIFY(divisor) ++ stl tmp1,24($30) ++ LONGIFY(modulus) ++ bis $31,1,mask ++ DIV_ONLY(stl tmp2,32($30)) ++ beq divisor, 9f /* div by zero */ ++ ++#ifdef INTSIZE ++ /* ++ * shift divisor left, using 3-bit shifts for ++ * 32-bit divides as we can't overflow. Three-bit ++ * shifts will result in looping three times less ++ * here, but can result in two loops more later. ++ * Thus using a large shift isn't worth it (and ++ * s8add pairs better than a sll..) ++ */ ++1: cmpult divisor,modulus,compare ++ s8addl divisor,$31,divisor ++ s8addl mask,$31,mask ++ bne compare,1b ++#else ++1: cmpult divisor,modulus,compare ++ blt divisor, 2f ++ addl divisor,divisor,divisor ++ addl mask,mask,mask ++ bne compare,1b ++ nop ++#endif ++ ++ /* ok, start to go right again.. */ ++2: DIV_ONLY(addl quotient,mask,tmp2) ++ srl mask,1,mask ++ cmpule divisor,modulus,compare ++ subl modulus,divisor,tmp1 ++ DIV_ONLY(selne compare,tmp2,quotient,quotient) ++ srl divisor,1,divisor ++ selne compare,tmp1,modulus,modulus ++ bne mask,2b ++ ++9: ldl $1, 0($30) ++ ldl $2, 8($30) ++ ldl $0,16($30) ++ ldl tmp1,24($30) ++ DIV_ONLY(ldl tmp2,32($30)) ++ addl $30,STACK,$30 ++ ret $31,($23),1 ++ .end ufunction ++ ++/* ++ * Uhh.. Ugly signed division. I'd rather not have it at all, but ++ * it's needed in some circumstances. There are different ways to ++ * handle this, really. This does: ++ * -a / b = a / -b = -(a / b) ++ * -a % b = -(a % b) ++ * a % -b = a % b ++ * which is probably not the best solution, but at least should ++ * have the property that (x/y)*y + (x%y) = x. ++ */ ++.align 3 ++.globl sfunction ++.ent sfunction ++sfunction: ++ subl $30,STACK,$30 ++ .frame $30,STACK,$23 ++ .prologue 0 ++ bis $24,$25,$28 ++ SLONGIFY($28) ++ bge $28,7b ++ stl $24,0($30) ++ subl $31,$24,$28 ++ stl $25,8($30) ++ sellt $24,$28,$24,$24 /* abs($24) */ ++ stl $23,16($30) ++ subl $31,$25,$28 ++ stl tmp1,24($30) ++ sellt $25,$28,$25,$25 /* abs($25) */ ++ nop ++ bsr $23,ufunction ++ ldl $24,0($30) ++ ldl $25,8($30) ++ GETSIGN($28) ++ subl $31,$27,tmp1 ++ SLONGIFY($28) ++ ldl $23,16($30) ++ sellt $28,tmp1,$27,$27 ++ ldl tmp1,24($30) ++ addl $30,STACK,$30 ++ ret $31,($23),1 ++ .end sfunction ++ ++/*rem 32 */ ++ ++#undef DIV_ONLY ++#undef MOD_ONLY ++#undef func ++#undef modulus ++#undef quotient ++#undef GETSIGN ++#undef STACK ++#undef ufunction ++#undef sfunction ++#undef LONGIFY ++#undef SLONGIFY ++ ++ ++#undef DIV ++ ++ ++#ifdef DIV ++#define DIV_ONLY(x,y...) x,##y ++#define MOD_ONLY(x,y...) ++#define func(x) __div##x ++#define modulus $2 ++#define quotient $27 ++#define GETSIGN(x) xor $24,$25,x ++#define STACK 48 ++#else ++#define DIV_ONLY(x,y...) ++#define MOD_ONLY(x,y...) x,##y ++#define func(x) __rem##x ++#define modulus $27 ++#define quotient $2 ++#define GETSIGN(x) bis $24,$24,x ++#define STACK 32 ++#endif ++ ++/* ++ * For 32-bit operations, we need to extend to 64-bit ++ */ ++#ifdef INTSIZE ++#define ufunction func(wu) ++#define sfunction func(w) ++#define LONGIFY(x) zapnot x,15,x ++#define SLONGIFY(x) ++#else ++#define ufunction func(lu) ++#define sfunction func(l) ++#define LONGIFY(x) ++#define SLONGIFY(x) ++#endif ++ ++.align 3 ++.globl ufunction ++.ent ufunction ++ufunction: ++ subl $30,STACK,$30 ++ .frame $30,STACK,$23 ++ .prologue 0 ++ ++7: stl $1, 0($30) ++ bis $25,$25,divisor ++ stl $2, 8($30) ++ bis $24,$24,modulus ++ stl $0,16($30) ++ bis $31,$31,quotient ++ LONGIFY(divisor) ++ stl tmp1,24($30) ++ LONGIFY(modulus) ++ bis $31,1,mask ++ DIV_ONLY(stl tmp2,32($30)) ++ beq divisor, 9f /* div by zero */ ++ ++#ifdef INTSIZE ++ /* ++ * shift divisor left, using 3-bit shifts for ++ * 32-bit divides as we can't overflow. Three-bit ++ * shifts will result in looping three times less ++ * here, but can result in two loops more later. ++ * Thus using a large shift isn't worth it (and ++ * s8add pairs better than a sll..) ++ */ ++1: cmpult divisor,modulus,compare ++ s8addl divisor,$31,divisor ++ s8addl mask,$31,mask ++ bne compare,1b ++#else ++1: cmpult divisor,modulus,compare ++ blt divisor, 2f ++ addl divisor,divisor,divisor ++ addl mask,mask,mask ++ bne compare,1b ++ nop ++#endif ++ ++ /* ok, start to go right again.. */ ++2: DIV_ONLY(addl quotient,mask,tmp2) ++ srl mask,1,mask ++ cmpule divisor,modulus,compare ++ subl modulus,divisor,tmp1 ++ DIV_ONLY(selne compare,tmp2,quotient,quotient) ++ srl divisor,1,divisor ++ selne compare,tmp1,modulus,modulus ++ bne mask,2b ++ ++9: ldl $1, 0($30) ++ ldl $2, 8($30) ++ ldl $0,16($30) ++ ldl tmp1,24($30) ++ DIV_ONLY(ldl tmp2,32($30)) ++ addl $30,STACK,$30 ++ ret $31,($23),1 ++ .end ufunction ++ ++/* ++ * Uhh.. Ugly signed division. I'd rather not have it at all, but ++ * it's needed in some circumstances. There are different ways to ++ * handle this, really. This does: ++ * -a / b = a / -b = -(a / b) ++ * -a % b = -(a % b) ++ * a % -b = a % b ++ * which is probably not the best solution, but at least should ++ * have the property that (x/y)*y + (x%y) = x. ++ */ ++.align 3 ++.globl sfunction ++.ent sfunction ++sfunction: ++ subl $30,STACK,$30 ++ .frame $30,STACK,$23 ++ .prologue 0 ++ bis $24,$25,$28 ++ SLONGIFY($28) ++ bge $28,7b ++ stl $24,0($30) ++ subl $31,$24,$28 ++ stl $25,8($30) ++ sellt $24,$28,$24,$24 /* abs($24) */ ++ stl $23,16($30) ++ subl $31,$25,$28 ++ stl tmp1,24($30) ++ sellt $25,$28,$25,$25 /* abs($25) */ ++ nop ++ bsr $23,ufunction ++ ldl $24,0($30) ++ ldl $25,8($30) ++ GETSIGN($28) ++ subl $31,$27,tmp1 ++ SLONGIFY($28) ++ ldl $23,16($30) ++ sellt $28,tmp1,$27,$27 ++ ldl tmp1,24($30) ++ addl $30,STACK,$30 ++ ret $31,($23),1 ++ .end sfunction ++ ++/*div 64*/ ++ ++#undef DIV_ONLY ++#undef MOD_ONLY ++#undef func ++#undef modulus ++#undef quotient ++#undef GETSIGN ++#undef STACK ++#undef ufunction ++#undef sfunction ++#undef LONGIFY ++#undef SLONGIFY ++ ++ ++#define DIV ++#undef INTSIZE ++ ++#ifdef DIV ++#define DIV_ONLY(x,y...) x,##y ++#define MOD_ONLY(x,y...) ++#define func(x) __div##x ++#define modulus $2 ++#define quotient $27 ++#define GETSIGN(x) xor $24,$25,x ++#define STACK 48 ++#else ++#define DIV_ONLY(x,y...) ++#define MOD_ONLY(x,y...) x,##y ++#define func(x) __rem##x ++#define modulus $27 ++#define quotient $2 ++#define GETSIGN(x) bis $24,$24,x ++#define STACK 32 ++#endif ++ ++/* ++ * For 32-bit operations, we need to extend to 64-bit ++ */ ++#ifdef INTSIZE ++#define ufunction func(wu) ++#define sfunction func(w) ++#define LONGIFY(x) zapnot x,15,x ++#define SLONGIFY(x) ++#else ++#define ufunction func(lu) ++#define sfunction func(l) ++#define LONGIFY(x) ++#define SLONGIFY(x) ++#endif ++ ++.align 3 ++.globl ufunction ++.ent ufunction ++ufunction: ++ subl $30,STACK,$30 ++ .frame $30,STACK,$23 ++ .prologue 0 ++ ++7: stl $1, 0($30) ++ bis $25,$25,divisor ++ stl $2, 8($30) ++ bis $24,$24,modulus ++ stl $0,16($30) ++ bis $31,$31,quotient ++ LONGIFY(divisor) ++ stl tmp1,24($30) ++ LONGIFY(modulus) ++ bis $31,1,mask ++ DIV_ONLY(stl tmp2,32($30)) ++ beq divisor, 9f /* div by zero */ ++ ++#ifdef INTSIZE ++ /* ++ * shift divisor left, using 3-bit shifts for ++ * 32-bit divides as we can't overflow. Three-bit ++ * shifts will result in looping three times less ++ * here, but can result in two loops more later. ++ * Thus using a large shift isn't worth it (and ++ * s8add pairs better than a sll..) ++ */ ++1: cmpult divisor,modulus,compare ++ s8addl divisor,$31,divisor ++ s8addl mask,$31,mask ++ bne compare,1b ++#else ++1: cmpult divisor,modulus,compare ++ blt divisor, 2f ++ addl divisor,divisor,divisor ++ addl mask,mask,mask ++ bne compare,1b ++ nop ++#endif ++ ++ /* ok, start to go right again.. */ ++2: DIV_ONLY(addl quotient,mask,tmp2) ++ srl mask,1,mask ++ cmpule divisor,modulus,compare ++ subl modulus,divisor,tmp1 ++ DIV_ONLY(selne compare,tmp2,quotient,quotient) ++ srl divisor,1,divisor ++ selne compare,tmp1,modulus,modulus ++ bne mask,2b ++ ++9: ldl $1, 0($30) ++ ldl $2, 8($30) ++ ldl $0,16($30) ++ ldl tmp1,24($30) ++ DIV_ONLY(ldl tmp2,32($30)) ++ addl $30,STACK,$30 ++ ret $31,($23),1 ++ .end ufunction ++ ++/* ++ * Uhh.. Ugly signed division. I'd rather not have it at all, but ++ * it's needed in some circumstances. There are different ways to ++ * handle this, really. This does: ++ * -a / b = a / -b = -(a / b) ++ * -a % b = -(a % b) ++ * a % -b = a % b ++ * which is probably not the best solution, but at least should ++ * have the property that (x/y)*y + (x%y) = x. ++ */ ++.align 3 ++.globl sfunction ++.ent sfunction ++sfunction: ++ subl $30,STACK,$30 ++ .frame $30,STACK,$23 ++ .prologue 0 ++ bis $24,$25,$28 ++ SLONGIFY($28) ++ bge $28,7b ++ stl $24,0($30) ++ subl $31,$24,$28 ++ stl $25,8($30) ++ sellt $24,$28,$24,$24 /* abs($24) */ ++ stl $23,16($30) ++ subl $31,$25,$28 ++ stl tmp1,24($30) ++ sellt $25,$28,$25,$25 /* abs($25) */ ++ nop ++ bsr $23,ufunction ++ ldl $24,0($30) ++ ldl $25,8($30) ++ GETSIGN($28) ++ subl $31,$27,tmp1 ++ SLONGIFY($28) ++ ldl $23,16($30) ++ sellt $28,tmp1,$27,$27 ++ ldl tmp1,24($30) ++ addl $30,STACK,$30 ++ ret $31,($23),1 ++ .end sfunction ++ ++ ++/*rem 64*/ ++ ++#undef DIV_ONLY ++#undef MOD_ONLY ++#undef func ++#undef modulus ++#undef quotient ++#undef GETSIGN ++#undef STACK ++#undef ufunction ++#undef sfunction ++#undef LONGIFY ++#undef SLONGIFY ++ ++ ++#undef DIV ++ ++#ifdef DIV ++#define DIV_ONLY(x,y...) x,##y ++#define MOD_ONLY(x,y...) ++#define func(x) __div##x ++#define modulus $2 ++#define quotient $27 ++#define GETSIGN(x) xor $24,$25,x ++#define STACK 48 ++#else ++#define DIV_ONLY(x,y...) ++#define MOD_ONLY(x,y...) x,##y ++#define func(x) __rem##x ++#define modulus $27 ++#define quotient $2 ++#define GETSIGN(x) bis $24,$24,x ++#define STACK 32 ++#endif ++ ++/* ++ * For 32-bit operations, we need to extend to 64-bit ++ */ ++#ifdef INTSIZE ++#define ufunction func(wu) ++#define sfunction func(w) ++#define LONGIFY(x) zapnot x,15,x ++#define SLONGIFY(x) ++#else ++#define ufunction func(lu) ++#define sfunction func(l) ++#define LONGIFY(x) ++#define SLONGIFY(x) ++#endif ++ ++ ++.align 3 ++.globl ufunction ++.ent ufunction ++ufunction: ++ subl $30,STACK,$30 ++ .frame $30,STACK,$23 ++ .prologue 0 ++ ++7: stl $1, 0($30) ++ bis $25,$25,divisor ++ stl $2, 8($30) ++ bis $24,$24,modulus ++ stl $0,16($30) ++ bis $31,$31,quotient ++ LONGIFY(divisor) ++ stl tmp1,24($30) ++ LONGIFY(modulus) ++ bis $31,1,mask ++ DIV_ONLY(stl tmp2,32($30)) ++ beq divisor, 9f /* div by zero */ ++ ++#ifdef INTSIZE ++ /* ++ * shift divisor left, using 3-bit shifts for ++ * 32-bit divides as we can't overflow. Three-bit ++ * shifts will result in looping three times less ++ * here, but can result in two loops more later. ++ * Thus using a large shift isn't worth it (and ++ * s8add pairs better than a sll..) ++ */ ++1: cmpult divisor,modulus,compare ++ s8addl divisor,$31,divisor ++ s8addl mask,$31,mask ++ bne compare,1b ++#else ++1: cmpult divisor,modulus,compare ++ blt divisor, 2f ++ addl divisor,divisor,divisor ++ addl mask,mask,mask ++ bne compare,1b ++ nop ++#endif ++ ++ /* ok, start to go right again.. */ ++2: DIV_ONLY(addl quotient,mask,tmp2) ++ srl mask,1,mask ++ cmpule divisor,modulus,compare ++ subl modulus,divisor,tmp1 ++ DIV_ONLY(selne compare,tmp2,quotient,quotient) ++ srl divisor,1,divisor ++ selne compare,tmp1,modulus,modulus ++ bne mask,2b ++ ++9: ldl $1, 0($30) ++ ldl $2, 8($30) ++ ldl $0,16($30) ++ ldl tmp1,24($30) ++ DIV_ONLY(ldl tmp2,32($30)) ++ addl $30,STACK,$30 ++ ret $31,($23),1 ++ .end ufunction ++ ++/* ++ * Uhh.. Ugly signed division. I'd rather not have it at all, but ++ * it's needed in some circumstances. There are different ways to ++ * handle this, really. This does: ++ * -a / b = a / -b = -(a / b) ++ * -a % b = -(a % b) ++ * a % -b = a % b ++ * which is probably not the best solution, but at least should ++ * have the property that (x/y)*y + (x%y) = x. ++ */ ++.align 3 ++.globl sfunction ++.ent sfunction ++sfunction: ++ subl $30,STACK,$30 ++ .frame $30,STACK,$23 ++ .prologue 0 ++ bis $24,$25,$28 ++ SLONGIFY($28) ++ bge $28,7b ++ stl $24,0($30) ++ subl $31,$24,$28 ++ stl $25,8($30) ++ sellt $24,$28,$24,$24 /* abs($24) */ ++ stl $23,16($30) ++ subl $31,$25,$28 ++ stl tmp1,24($30) ++ sellt $25,$28,$25,$25 /* abs($25) */ ++ nop ++ bsr $23,ufunction ++ ldl $24,0($30) ++ ldl $25,8($30) ++ GETSIGN($28) ++ subl $31,$27,tmp1 ++ SLONGIFY($28) ++ ldl $23,16($30) ++ sellt $28,tmp1,$27,$27 ++ ldl tmp1,24($30) ++ addl $30,STACK,$30 ++ ret $31,($23),1 ++ .end sfunction +diff --git a/grub-core/lib/sw64/setjmp.S b/grub-core/lib/sw64/setjmp.S +new file mode 100644 +index 000000000..a04d6007b +--- /dev/null ++++ b/grub-core/lib/sw64/setjmp.S +@@ -0,0 +1,75 @@ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2018 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 . ++ */ ++ ++#include ++#include ++#include ++#include ++ ++ .file "setjmp.S" ++ ++GRUB_MOD_LICENSE "GPLv2+" ++ ++FUNCTION(grub_setjmp) ++ ldgp gp, 0(pv) ++#define FRAME 0 ++ .frame sp, FRAME, ra, 0 ++ ++ stl s0, JB_S0*8(a0) ++ stl s1, JB_S1*8(a0) ++ stl s2, JB_S2*8(a0) ++ stl s3, JB_S3*8(a0) ++ stl s4, JB_S4*8(a0) ++ stl s5, JB_S5*8(a0) ++ stl ra, JB_PC*8(a0) ++ addl sp, FRAME, t1 ++ stl t1, JB_SP*8(a0) ++ stl fp, JB_FP*8(a0) ++ fstd $f2, JB_F2*8(a0) ++ fstd $f3, JB_F3*8(a0) ++ fstd $f4, JB_F4*8(a0) ++ fstd $f5, JB_F5*8(a0) ++ fstd $f6, JB_F6*8(a0) ++ fstd $f7, JB_F7*8(a0) ++ fstd $f8, JB_F8*8(a0) ++ fstd $f9, JB_F9*8(a0) ++ ldi a0, 0($31) ++ ret ++ ++FUNCTION(grub_longjmp) ++ mov a1, v0 ++ ldl s0, JB_S0*8(a0) ++ ldl s1, JB_S1*8(a0) ++ ldl s2, JB_S2*8(a0) ++ ldl s3, JB_S3*8(a0) ++ ldl s4, JB_S4*8(a0) ++ ldl s5, JB_S5*8(a0) ++ ldl ra, JB_PC*8(a0) ++ ldl fp, JB_FP*8(a0) ++ ldl t0, JB_SP*8(a0) ++ fldd $f2, JB_F2*8(a0) ++ fldd $f3, JB_F3*8(a0) ++ fldd $f4, JB_F4*8(a0) ++ fldd $f5, JB_F5*8(a0) ++ fldd $f6, JB_F6*8(a0) ++ fldd $f7, JB_F7*8(a0) ++ fldd $f8, JB_F8*8(a0) ++ fldd $f9, JB_F9*8(a0) ++ seleq v0, 1, v0, v0 ++ mov t0, sp ++ ret +diff --git a/grub-core/loader/sw64/efi/linux.c b/grub-core/loader/sw64/efi/linux.c +new file mode 100644 +index 000000000..51c2a98b7 +--- /dev/null ++++ b/grub-core/loader/sw64/efi/linux.c +@@ -0,0 +1,330 @@ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2018 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 . ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++GRUB_MOD_LICENSE ("GPLv3+"); ++ ++#pragma GCC diagnostic ignored "-Wcast-align" ++ ++static grub_dl_t my_mod; ++static int loaded; ++static char *linux_args; ++ ++/* Initrd base and size. */ ++static void *initrd_mem; ++static grub_efi_uintn_t initrd_pages; ++static grub_addr_t initrd_start; ++static grub_efi_uintn_t initrd_size; ++ ++void *raw_fdt; ++static struct boot_param *sunway_boot_params = (struct boot_param *)BOOT_PARAM_START; ++ ++static grub_err_t ++finalize_params_linux (void) ++{ ++ grub_efi_uintn_t mmap_size; ++ grub_efi_uintn_t map_key; ++ grub_efi_uintn_t desc_size; ++ grub_efi_uint32_t desc_version; ++ grub_efi_memory_descriptor_t *mmap_buf; ++ grub_err_t err; ++ grub_efi_uintn_t i; ++ ++ /* Initrd. */ ++ sunway_boot_params->initrd_start = (grub_uint64_t)initrd_start; ++ sunway_boot_params->initrd_size = (grub_uint64_t)initrd_size; ++ ++ /* DTB. */ ++ raw_fdt = grub_fdt_load (GRUB_EFI_LINUX_FDT_EXTRA_SPACE); ++ ++ if (!raw_fdt) ++ { ++ sunway_boot_params->dtb_start = 0; ++ grub_dprintf ("linux", "not found registered FDT\n"); ++ } ++ ++ if (raw_fdt) ++ { ++ err = grub_fdt_check_header_nosize(raw_fdt); ++ if (err) ++ grub_dprintf ("linux", "illegal FDT file\n"); ++ ++ sunway_boot_params->dtb_start = (grub_uint64_t)raw_fdt; ++ grub_dprintf ("linux", "dtb: [addr=0x%lx, size=0x%x]\n", ++ (grub_uint64_t) raw_fdt, grub_fdt_get_totalsize(raw_fdt)); ++ grub_printk ("dtb: [addr=0x%lx, size=0x%x]\n", ++ (grub_uint64_t) raw_fdt, grub_fdt_get_totalsize(raw_fdt)); ++ } ++ ++ /* MDT. ++ Must be done after grub_machine_fini because map_key is used by ++ exit_boot_services. */ ++ mmap_size = grub_efi_find_mmap_size (); ++ if (! mmap_size) ++ return grub_errno; ++ mmap_buf = grub_efi_allocate_any_pages (GRUB_EFI_BYTES_TO_PAGES (mmap_size)); ++ if (! mmap_buf) ++ return grub_error (GRUB_ERR_IO, "cannot allocate memory map"); ++ err = grub_efi_finish_boot_services (&mmap_size, mmap_buf, &map_key, ++ &desc_size, &desc_version); ++ if (err) ++ return err; ++ ++ for (i = 0; i < mmap_size / desc_size; i++) ++ { ++ grub_efi_memory_descriptor_t *curdesc = (grub_efi_memory_descriptor_t *) ++ ((char *) mmap_buf + desc_size * i); ++ ++ /* Bypass the low address segment that used by OS */ ++ if (grub_virt_to_phys(curdesc->physical_start) < 0x2f00000UL) ++ curdesc->physical_start = 0x2f00000UL; ++ ++ curdesc->physical_start = grub_virt_to_phys(curdesc->physical_start); ++ } ++ ++ sunway_boot_params->efi_systab = grub_virt_to_phys((grub_uint64_t)grub_efi_system_table); ++ sunway_boot_params->efi_memmap = grub_virt_to_phys((grub_uint64_t)mmap_buf); ++ sunway_boot_params->efi_memmap_size = mmap_size; ++ sunway_boot_params->efi_memdesc_size = desc_size; ++ sunway_boot_params->efi_memdesc_version = desc_version; ++ ++ return GRUB_ERR_NONE; ++} ++static void ++start_kernel(void) ++{ ++ local_irq_disable (); ++ grub_dprintf ("linux", "Jump to entry: %lx\n", VMLINUX_ADDR); ++ grub_printk("Jump to entry: %lx\n", VMLINUX_ADDR); ++ ++ ret(VMLINUX_ADDR | 2); ++} ++ ++static grub_err_t ++grub_linux_boot (void) ++{ ++ finalize_params_linux (); ++ start_kernel (); ++ return GRUB_ERR_NONE; ++} ++ ++static grub_err_t ++grub_linux_unload (void) ++{ ++ grub_dl_unref (my_mod); ++ return GRUB_ERR_NONE; ++} ++ ++static grub_err_t ++grub_load_elf64 (grub_elf_t elf, const char *filename) ++{ ++ Elf64_Addr base_addr; ++ grub_size_t linux_size; ++ grub_uint64_t align; ++ ++ if (elf->ehdr.ehdr64.e_ident[EI_MAG0] != ELFMAG0 ++ || elf->ehdr.ehdr64.e_ident[EI_MAG1] != ELFMAG1 ++ || elf->ehdr.ehdr64.e_ident[EI_MAG2] != ELFMAG2 ++ || elf->ehdr.ehdr64.e_ident[EI_MAG3] != ELFMAG3 ++ || elf->ehdr.ehdr64.e_ident[EI_DATA] != ELFDATA2LSB) ++ return grub_error(GRUB_ERR_UNKNOWN_OS, ++ N_("invalid arch-independent ELF magic")); ++ ++ if (elf->ehdr.ehdr64.e_ident[EI_CLASS] != ELFCLASS64 ++ || elf->ehdr.ehdr64.e_version != EV_CURRENT ++ || elf->ehdr.ehdr64.e_machine != EM_SW_64) ++ return grub_error (GRUB_ERR_UNKNOWN_OS, ++ N_("invalid arch-dependent ELF magic")); ++ ++ if (elf->ehdr.ehdr64.e_type != ET_EXEC) ++ return grub_error (GRUB_ERR_UNKNOWN_OS, ++ N_("this ELF file is not of the right type")); ++ ++ /* FIXME: Should we support program headers at strange locations? */ ++ if (elf->ehdr.ehdr64.e_phoff + elf->ehdr.ehdr64.e_phnum * elf->ehdr.ehdr64.e_phentsize > GRUB_ELF_SEARCH) ++ return grub_error (GRUB_ERR_BAD_OS, "program header at a too high offset"); ++ ++ linux_size = grub_elf64_size (elf, &base_addr, &align); ++ if (linux_size == 0) ++ return grub_error (GRUB_ERR_BAD_OS, "linux size is 0"); ++ ++ grub_dprintf ("linux", "Segment phy_addr: %lx entry: %lx\n", (grub_uint64_t)base_addr,(grub_uint64_t)elf->ehdr.ehdr64.e_entry); ++ grub_printk ("Segment phy_addr: %lx entry: %lx\n", (grub_uint64_t)base_addr,(grub_uint64_t)elf->ehdr.ehdr64.e_entry); ++ ++ /* Now load the segments into the area we claimed. */ ++ return grub_elf64_load (elf, filename, (void *) (grub_addr_t) (0), GRUB_ELF_LOAD_FLAGS_NONE, 0, 0); ++} ++ ++static grub_err_t ++grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)), ++ int argc, char *argv[]) ++{ ++ grub_ssize_t size; ++ grub_elf_t elf = 0; ++ ++ grub_dl_ref (my_mod); ++ ++ grub_loader_unset (); ++ ++ if (argc == 0) ++ { ++ grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected")); ++ goto fail; ++ } ++ ++ elf = grub_elf_open (argv[0], GRUB_FILE_TYPE_LINUX_KERNEL); ++ if (! elf) ++ goto fail; ++ ++ grub_dprintf ("linux", "Loading linux: %s\n", argv[0]); ++ grub_printk ("Loading linux: %s\n", argv[0]); ++ ++ if (grub_load_elf64 (elf, argv[0])) ++ goto fail; ++ ++ grub_memset (sunway_boot_params, 0, sizeof(*sunway_boot_params)); ++ size = grub_loader_cmdline_size(argc, argv); ++ ++ linux_args = grub_malloc (size + sizeof (LINUX_IMAGE)); ++ if (!linux_args) ++ { ++ grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory")); ++ goto fail; ++ } ++ ++ sunway_boot_params->command_line = (grub_uint64_t) linux_args; ++ ++ /* Create kernel command line. */ ++ grub_memcpy (linux_args, LINUX_IMAGE, sizeof (LINUX_IMAGE)); ++ grub_create_loader_cmdline (argc, argv, linux_args + sizeof (LINUX_IMAGE) - 1, ++ size, GRUB_VERIFY_KERNEL_CMDLINE); ++ ++ grub_dprintf ("linux", "linux_args: '%s'\n", ((char *)((sunway_boot_params->command_line)))); ++ grub_printk ("linux_args: '%s'\n", ((char *)((sunway_boot_params->command_line)))); ++ grub_errno = GRUB_ERR_NONE; ++ ++ grub_loader_set (grub_linux_boot, grub_linux_unload, 0); ++ ++ fail: ++ if (elf) ++ grub_elf_close (elf); ++ ++ if (grub_errno != GRUB_ERR_NONE) ++ { ++ grub_dl_unref (my_mod); ++ loaded = 0; ++ } ++ else ++ loaded = 1; ++ ++ return grub_errno; ++} ++ ++static grub_err_t ++grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)), ++ int argc, char *argv[]) ++{ ++ struct grub_linux_initrd_context initrd_ctx = { 0, 0, 0 }; ++ ++ if (argc == 0) ++ { ++ grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected")); ++ goto fail; ++ } ++ ++ if (! loaded) ++ { ++ grub_error (GRUB_ERR_BAD_ARGUMENT, N_("you need to load the kernel first")); ++ goto fail; ++ } ++ ++ if (grub_initrd_init (argc, argv, &initrd_ctx)) ++ goto fail; ++ ++ initrd_size = grub_get_initrd_size (&initrd_ctx); ++ grub_dprintf ("linux", "Loading initrd %s\n", argv[0]); ++ grub_printk ("Loading initrd %s\n", argv[0]); ++ ++ initrd_pages = (GRUB_EFI_BYTES_TO_PAGES (initrd_size)); ++ initrd_mem = grub_efi_allocate_any_pages (initrd_pages); ++ if (! initrd_mem) ++ { ++ grub_error (GRUB_ERR_OUT_OF_MEMORY, "cannot allocate pages"); ++ goto fail; ++ } ++ ++ grub_dprintf ("linux", "initrd: [addr=0x%lx, size=0x%lx]\n", ++ (grub_uint64_t) initrd_mem, initrd_size); ++ grub_printk ("initrd: [addr=0x%lx, size=0x%lx]\n", ++ (grub_uint64_t) initrd_mem, initrd_size); ++ ++ if (grub_initrd_load (&initrd_ctx, argv, initrd_mem)) ++ goto fail; ++ ++ initrd_start = (grub_addr_t) initrd_mem; ++ ++ fail: ++ grub_initrd_close (&initrd_ctx); ++ if (initrd_mem && !initrd_start) ++ grub_efi_free_pages ((grub_addr_t) initrd_mem, initrd_pages); ++ ++ return grub_errno; ++} ++ ++static grub_command_t cmd_linux, cmd_initrd; ++ ++GRUB_MOD_INIT (linux) ++{ ++ cmd_linux = grub_register_command ("linux", grub_cmd_linux, ++ N_("FILE [ARGS...]"), N_("Load Linux.")); ++ ++ cmd_initrd = grub_register_command ("initrd", grub_cmd_initrd, ++ N_("FILE"), N_("Load initrd.")); ++ ++ my_mod = mod; ++} ++ ++GRUB_MOD_FINI (linux) ++{ ++ grub_unregister_command (cmd_linux); ++ grub_unregister_command (cmd_initrd); ++} +diff --git a/include/grub/compiler-rt.h b/include/grub/compiler-rt.h +index 17828b322..a8782fc80 100644 +--- a/include/grub/compiler-rt.h ++++ b/include/grub/compiler-rt.h +@@ -178,7 +178,7 @@ EXPORT_FUNC (__lshrdi3) (grub_uint64_t u, int b); + #endif + + #if defined (__powerpc__) || defined(__mips__) || defined(__sparc__) || \ +- defined (__arm__) || defined(__riscv) ++ defined (__arm__) || defined(__riscv) || defined(__sw_64__) + grub_uint32_t + EXPORT_FUNC(__bswapsi2) (grub_uint32_t u); + +diff --git a/include/grub/dl.h b/include/grub/dl.h +index b3753c9ca..32f365d48 100644 +--- a/include/grub/dl.h ++++ b/include/grub/dl.h +@@ -282,17 +282,29 @@ grub_err_t + grub_arm64_dl_get_tramp_got_size (const void *ehdr, grub_size_t *tramp, + grub_size_t *got); + ++#define GRUB_SW64_DL_TRAMP_ALIGN 16 ++#define GRUB_SW64_DL_GOT_ALIGN 16 ++ ++grub_err_t ++grub_sw64_dl_get_tramp_got_size (const void *ehdr, grub_size_t *tramp, ++ grub_size_t *got); ++ + #if defined (__ia64__) + #define GRUB_ARCH_DL_TRAMP_ALIGN GRUB_IA64_DL_TRAMP_ALIGN + #define GRUB_ARCH_DL_GOT_ALIGN GRUB_IA64_DL_GOT_ALIGN + #define grub_arch_dl_get_tramp_got_size grub_ia64_dl_get_tramp_got_size + #elif defined (__aarch64__) + #define grub_arch_dl_get_tramp_got_size grub_arm64_dl_get_tramp_got_size ++#elif defined (__sw_64__) ++#define GRUB_ARCH_DL_TRAMP_ALIGN GRUB_SW64_DL_TRAMP_ALIGN ++#define GRUB_ARCH_DL_GOT_ALIGN GRUB_SW64_DL_GOT_ALIGN ++#define grub_arch_dl_get_tramp_got_size grub_sw64_dl_get_tramp_got_size + #else + grub_err_t + grub_arch_dl_get_tramp_got_size (const void *ehdr, grub_size_t *tramp, + grub_size_t *got); + #endif ++#endif + + #if defined (__powerpc__) || defined (__mips__) || defined (__arm__) || \ + (defined(__riscv) && (__riscv_xlen == 32)) +@@ -306,6 +318,4 @@ grub_arch_dl_get_tramp_got_size (const void *ehdr, grub_size_t *tramp, + #define GRUB_ARCH_DL_GOT_ALIGN 8 + #endif + +-#endif +- + #endif /* ! GRUB_DL_H */ +diff --git a/include/grub/efi/api.h b/include/grub/efi/api.h +index f1a52210c..e571bd053 100644 +--- a/include/grub/efi/api.h ++++ b/include/grub/efi/api.h +@@ -1731,7 +1731,7 @@ typedef struct grub_efi_rng_protocol grub_efi_rng_protocol_t; + + #if (GRUB_TARGET_SIZEOF_VOID_P == 4) || defined (__ia64__) \ + || defined (__aarch64__) || defined (__MINGW64__) || defined (__CYGWIN__) \ +- || defined(__riscv) ++ || defined(__riscv) || defined(__sw_64__) + + #define efi_call_0(func) func() + #define efi_call_1(func, a) func(a) +diff --git a/include/grub/efi/efi.h b/include/grub/efi/efi.h +index 83d958f99..6f5fe163e 100644 +--- a/include/grub/efi/efi.h ++++ b/include/grub/efi/efi.h +@@ -96,7 +96,7 @@ extern void (*EXPORT_VAR(grub_efi_net_config)) (grub_efi_handle_t hnd, + char **device, + char **path); + +-#if defined(__arm__) || defined(__aarch64__) || defined(__riscv) ++#if defined(__arm__) || defined(__aarch64__) || defined(__riscv) || defined(__sw_64__) + void *EXPORT_FUNC(grub_efi_get_firmware_fdt)(void); + grub_err_t EXPORT_FUNC(grub_efi_get_ram_base)(grub_addr_t *); + #include +diff --git a/include/grub/efi/pe32.h b/include/grub/efi/pe32.h +index 0ed8781f0..2f50befc3 100644 +--- a/include/grub/efi/pe32.h ++++ b/include/grub/efi/pe32.h +@@ -79,6 +79,7 @@ struct grub_pe32_coff_header + #define GRUB_PE32_MACHINE_ARM64 0xAA64 + #define GRUB_PE32_MACHINE_RISCV32 0x5032 + #define GRUB_PE32_MACHINE_RISCV64 0x5064 ++#define GRUB_PE32_MACHINE_SW_64 0x284 + + #define GRUB_PE32_RELOCS_STRIPPED 0x0001 + #define GRUB_PE32_EXECUTABLE_IMAGE 0x0002 +diff --git a/include/grub/elf.h b/include/grub/elf.h +index c478933ee..f3727826e 100644 +--- a/include/grub/elf.h ++++ b/include/grub/elf.h +@@ -254,6 +254,7 @@ typedef struct + chances of collision with official or non-GNU unofficial values. */ + + #define EM_ALPHA 0x9026 ++#define EM_SW_64 0x9916 + + /* Legal values for e_version (version). */ + +@@ -2531,6 +2532,47 @@ typedef Elf32_Addr Elf32_Conflict; + #define R_RISCV_SET32 56 + #define R_RISCV_32_PCREL 57 + ++/* ++ * SW-64 ELF relocation types ++ */ ++#define R_SW64_NONE 0 /* No reloc */ ++#define R_SW64_REFLONG 1 /* Direct 32 bit */ ++#define R_SW64_REFQUAD 2 /* Direct 64 bit */ ++#define R_SW64_GPREL32 3 /* GP relative 32 bit */ ++#define R_SW64_LITERAL 4 /* GP relative 16 bit w/optimization */ ++#define R_SW64_LITUSE 5 /* Optimization hint for LITERAL */ ++#define R_SW64_GPDISP 6 /* Add displacement to GP */ ++#define R_SW64_BRADDR 7 /* PC+4 relative 23 bit shifted */ ++#define R_SW64_HINT 8 /* PC+4 relative 16 bit shifted */ ++#define R_SW64_SREL16 9 /* PC relative 16 bit */ ++#define R_SW64_SREL32 10 /* PC relative 32 bit */ ++#define R_SW64_SREL64 11 /* PC relative 64 bit */ ++#define R_SW64_GPRELHIGH 17 /* GP relative 32 bit, high 16 bits */ ++#define R_SW64_GPRELLOW 18 /* GP relative 32 bit, low 16 bits */ ++#define R_SW64_GPREL16 19 /* GP relative 16 bit */ ++#define R_SW64_COPY 24 /* Copy symbol at runtime */ ++#define R_SW64_GLOB_DAT 25 /* Create GOT entry */ ++#define R_SW64_JMP_SLOT 26 /* Create PLT entry */ ++#define R_SW64_RELATIVE 27 /* Adjust by program base */ ++#define R_SW64_BRSGP 28 ++#define R_SW64_TLSGD 29 ++#define R_SW64_TLS_LDM 30 ++#define R_SW64_DTPMOD64 31 ++#define R_SW64_GOTDTPREL 32 ++#define R_SW64_DTPREL64 33 ++#define R_SW64_DTPRELHI 34 ++#define R_SW64_DTPRELLO 35 ++#define R_SW64_DTPREL16 36 ++#define R_SW64_GOTTPREL 37 ++#define R_SW64_TPREL64 38 ++#define R_SW64_TPRELHI 39 ++#define R_SW64_TPRELLO 40 ++#define R_SW64_TPREL16 41 ++#define R_SW64_LITERAL_GOT 43 ++ ++#define STO_SW64_NOPV 0x80 ++#define STO_SW64_STD_GPLOAD 0x88 ++ + #ifdef GRUB_TARGET_WORDSIZE + #if GRUB_TARGET_WORDSIZE == 32 + +diff --git a/include/grub/misc.h b/include/grub/misc.h +index 7d2b55196..73fd47c1a 100644 +--- a/include/grub/misc.h ++++ b/include/grub/misc.h +@@ -306,7 +306,9 @@ void *EXPORT_FUNC(grub_memset) (void *s, int c, grub_size_t n); + grub_size_t EXPORT_FUNC(grub_strlen) (const char *s) WARN_UNUSED_RESULT; + int EXPORT_FUNC(grub_printf) (const char *fmt, ...) __attribute__ ((format (GNU_PRINTF, 1, 2))); + int EXPORT_FUNC(grub_printf_) (const char *fmt, ...) __attribute__ ((format (GNU_PRINTF, 1, 2))); +- ++#ifdef __sw_64__ ++int EXPORT_FUNC(grub_printk) (const char *fmt, ...) __attribute__ ((format (GNU_PRINTF, 1, 2))); ++#endif + /* Replace all `ch' characters of `input' with `with' and copy the + result into `output'; return EOS address of `output'. */ + static inline char * +@@ -346,6 +348,9 @@ void EXPORT_FUNC(grub_real_dprintf) (const char *file, + const char *condition, + const char *fmt, ...) __attribute__ ((format (GNU_PRINTF, 4, 5))); + int EXPORT_FUNC(grub_vprintf) (const char *fmt, va_list args); ++#ifdef __sw_64__ ++int EXPORT_FUNC(grub_vprintk) (const char *fmt, va_list args); ++#endif + int EXPORT_FUNC(grub_snprintf) (char *str, grub_size_t n, const char *fmt, ...) + __attribute__ ((format (GNU_PRINTF, 3, 4))); + int EXPORT_FUNC(grub_vsnprintf) (char *str, grub_size_t n, const char *fmt, +@@ -499,5 +504,7 @@ void EXPORT_FUNC(grub_real_boot_time) (const char *file, + #define grub_min(a, b) (((a) < (b)) ? (a) : (b)) + + #define grub_log2ull(n) (GRUB_TYPE_BITS (grub_uint64_t) - __builtin_clzll (n) - 1) +- ++#ifdef __sw_64__ ++void sunway_debug_delegate(char *buffer); ++#endif + #endif /* ! GRUB_MISC_HEADER */ +diff --git a/include/grub/sw64/divide.h b/include/grub/sw64/divide.h +new file mode 100644 +index 000000000..a6c8eae02 +--- /dev/null ++++ b/include/grub/sw64/divide.h +@@ -0,0 +1,11 @@ ++#ifndef __DIVIDE_H__ ++#define __DIVIDE_H__ ++void EXPORT_FUNC(__divw) (void); ++void EXPORT_FUNC(__remw) (void); ++void EXPORT_FUNC(__divl) (void); ++void EXPORT_FUNC(__reml) (void); ++void EXPORT_FUNC(__divwu) (void); ++void EXPORT_FUNC(__remwu) (void); ++void EXPORT_FUNC(__divlu) (void); ++void EXPORT_FUNC(__remlu) (void); ++#endif +diff --git a/include/grub/sw64/efi/memory.h b/include/grub/sw64/efi/memory.h +new file mode 100644 +index 000000000..3bc99d073 +--- /dev/null ++++ b/include/grub/sw64/efi/memory.h +@@ -0,0 +1,6 @@ ++#ifndef GRUB_MEMORY_CPU_HEADER ++#include ++ ++#define GRUB_EFI_MAX_USABLE_ADDRESS 0xffffffffffffffffULL ++#define GRUB_EFI_MAX_ALLOCATION_ADDRESS GRUB_EFI_MAX_USABLE_ADDRESS ++#endif /* ! GRUB_MEMORY_CPU_HEADER */ +diff --git a/include/grub/sw64/efi/time.h b/include/grub/sw64/efi/time.h +new file mode 100644 +index 000000000..897ce9c00 +--- /dev/null ++++ b/include/grub/sw64/efi/time.h +@@ -0,0 +1,23 @@ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2008 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 . ++ */ ++#ifndef GRUB_MACHINE_TIME_HEADER ++#define GRUB_MACHINE_TIME_HEADER 1 ++ ++#include ++ ++#endif /* ! GRUB_MACHINE_TIME_HEADER */ +diff --git a/include/grub/sw64/io.h b/include/grub/sw64/io.h +new file mode 100644 +index 000000000..dee76bde5 +--- /dev/null ++++ b/include/grub/sw64/io.h +@@ -0,0 +1,62 @@ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2009 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 . ++ */ ++ ++#ifndef GRUB_IO_H ++#define GRUB_IO_H 1 ++ ++#include ++ ++typedef grub_addr_t grub_port_t; ++ ++static __inline unsigned char ++grub_inb (grub_port_t port) ++{ ++ return *(volatile grub_uint8_t *) port; ++} ++ ++static __inline unsigned short int ++grub_inw (grub_port_t port) ++{ ++ return *(volatile grub_uint16_t *) port; ++} ++ ++static __inline unsigned int ++grub_inl (grub_port_t port) ++{ ++ return *(volatile grub_uint32_t *) port; ++} ++ ++static __inline void ++grub_outb (unsigned char value, grub_port_t port) ++{ ++ *(volatile grub_uint8_t *) port = value; ++} ++ ++static __inline void ++grub_outw (unsigned short int value, grub_port_t port) ++{ ++ *(volatile grub_uint16_t *) port = value; ++} ++ ++static __inline void ++grub_outl (unsigned int value, grub_port_t port) ++{ ++ *(volatile grub_uint32_t *) port = value; ++} ++ ++#endif /* _SYS_IO_H */ +diff --git a/include/grub/sw64/jmpbuf-offsets.h b/include/grub/sw64/jmpbuf-offsets.h +new file mode 100644 +index 000000000..86e8da2a1 +--- /dev/null ++++ b/include/grub/sw64/jmpbuf-offsets.h +@@ -0,0 +1,35 @@ ++/* Private macros for accessing __jmp_buf contents. Alpha version. ++ Copyright (C) 2006-2016 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GNU C Library 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 ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library. If not, see ++ . */ ++ ++#define JB_S0 0 ++#define JB_S1 1 ++#define JB_S2 2 ++#define JB_S3 3 ++#define JB_S4 4 ++#define JB_S5 5 ++#define JB_PC 6 ++#define JB_FP 7 ++#define JB_SP 8 ++#define JB_F2 9 ++#define JB_F3 10 ++#define JB_F4 11 ++#define JB_F5 12 ++#define JB_F6 13 ++#define JB_F7 14 ++#define JB_F8 15 ++#define JB_F9 16 +diff --git a/include/grub/sw64/kernel.h b/include/grub/sw64/kernel.h +new file mode 100644 +index 000000000..c5496a00b +--- /dev/null ++++ b/include/grub/sw64/kernel.h +@@ -0,0 +1,25 @@ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * 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 . ++ */ ++ ++#ifndef GRUB_CPU_KERNEL_HEADER ++#define GRUB_CPU_KERNEL_HEADER 1 ++ ++#define GRUB_MOD_ALIGN 0x1 ++#define GRUB_MOD_GAP 0x0 ++ ++#endif /* ! GRUB_CPU_KERNEL_HEADER */ +diff --git a/include/grub/sw64/linux.h b/include/grub/sw64/linux.h +new file mode 100644 +index 000000000..068e303d0 +--- /dev/null ++++ b/include/grub/sw64/linux.h +@@ -0,0 +1,50 @@ ++#ifndef GRUB_SW_H ++#define GRUB_SW_H 1 ++#define PAGE_OFFSET 0xfff0000000000000UL ++#define KTEXT_OFFSET 0xffffffff80000000UL ++#define GRUB_PRINTK_START (KTEXT_OFFSET | 0x800000) ++#define GRUB_PRINTK_SIZE (0x20000) ++#define BOOT_PARAM_START 0xfff000000090a100ULL ++#define VMLINUX_ADDR (KTEXT_OFFSET | 0x910000) ++ ++#define GRUB_ELF_SEARCH 1024 ++#define IPL_MIN 0 ++#define IPL_MAX 7 ++#define barrier() __asm__ __volatile__("": : :"memory") ++#define local_irq_disable() do { swpipl(IPL_MAX); barrier(); } while(0) ++#define local_irq_enable() do { barrier(); swpipl(IPL_MIN); } while(0) ++ ++static inline ++grub_uint64_t ++grub_virt_to_phys(grub_uint64_t x) ++{ ++ if (x >= KTEXT_OFFSET) ++ x -= KTEXT_OFFSET; ++ else if (x >= PAGE_OFFSET) ++ x -= PAGE_OFFSET; ++ else ++ grub_error (GRUB_ERR_BUG, "not an valid address"); ++ ++ return x; ++} ++ ++struct boot_param ++{ ++ grub_uint64_t initrd_start; /* logical address of initrd */ ++ grub_uint64_t initrd_size; /* size of initrd */ ++ grub_uint64_t dtb_start; /* logical address of dtb */ ++ grub_uint64_t efi_systab; /* logical address of EFI system table */ ++ grub_uint64_t efi_memmap; /* logical address of EFI memory map */ ++ grub_uint64_t efi_memmap_size; /* size of EFI memory map */ ++ grub_uint64_t efi_memdesc_size; /* size of an EFI memory map descriptor */ ++ grub_uint64_t efi_memdesc_version; /* memory descriptor version */ ++ grub_uint64_t command_line; /* logical address of cmdline */ ++}; ++ ++struct linux_sw64_kernel_header ++{ ++}; ++ ++#define linux_arch_kernel_header linux_sw64_kernel_header ++ ++#endif +diff --git a/include/grub/sw64/pal.h b/include/grub/sw64/pal.h +new file mode 100644 +index 000000000..274f07d3a +--- /dev/null ++++ b/include/grub/sw64/pal.h +@@ -0,0 +1,49 @@ ++#ifndef __SW64_PAL_H ++#define __SW64_PAL_H ++ ++#define HMC_cpuid 0x03 ++#define HMC_ret 0x1A ++#define HMC_swpipl 0x35 ++ ++#define GET_CPU_FREQ 4 ++ ++#define __CALL_HMC_W1(NAME, TYPE0) \ ++static inline void NAME(TYPE0 arg0) \ ++{ \ ++ register TYPE0 __r16 __asm__("$16") = arg0; \ ++ __asm__ __volatile__ ("sys_call %1 # "#NAME \ ++ : "=r"(__r16) \ ++ : "i"(HMC_ ## NAME), "0"(__r16) \ ++ : "$1", "$22", "$23", "$24", "$25"); \ ++} ++ ++#define __CALL_HMC_RW1(NAME, RTYPE, TYPE0) \ ++static inline RTYPE NAME(TYPE0 arg0) \ ++{ \ ++ register RTYPE __r0 __asm__("$0"); \ ++ register TYPE0 __r16 __asm__("$16") = arg0; \ ++ __asm__ __volatile__ ("sys_call %2 # "#NAME \ ++ : "=r"(__r16), "=r"(__r0) \ ++ : "i"(HMC_ ## NAME), "0"(__r16) \ ++ : "$1", "$22", "$23", "$24", "$25"); \ ++ return __r0; \ ++} ++ ++#define __CALL_HMC_RW2(NAME, RTYPE, TYPE0, TYPE1) \ ++static inline RTYPE NAME(TYPE0 arg0, TYPE1 arg1) \ ++{ \ ++ register RTYPE __r0 __asm__("$0"); \ ++ register TYPE0 __r16 __asm__("$16") = arg0; \ ++ register TYPE1 __r17 __asm__("$17") = arg1; \ ++ __asm__ __volatile__ ("sys_call %3 # "#NAME \ ++ : "=r"(__r16), "=r"(__r17), "=r"(__r0) \ ++ : "i"(HMC_ ## NAME), "0"(__r16), "1"(__r17) \ ++ : "$1", "$22", "$23", "$24", "$25"); \ ++ return __r0; \ ++} ++ ++__CALL_HMC_W1(ret, unsigned long); ++__CALL_HMC_RW1(swpipl, unsigned long, unsigned long); ++__CALL_HMC_RW2(cpuid, unsigned long, unsigned long, unsigned long); ++ ++#endif /* __SW_64_HMC_H */ +diff --git a/include/grub/sw64/regdef.h b/include/grub/sw64/regdef.h +new file mode 100644 +index 000000000..b30eb770e +--- /dev/null ++++ b/include/grub/sw64/regdef.h +@@ -0,0 +1,44 @@ ++#ifndef __sw_regdef_h__ ++#define __sw_regdef_h__ ++ ++#define v0 $0 /* function return value */ ++ ++#define t0 $1 /* temporary registers (caller-saved) */ ++#define t1 $2 ++#define t2 $3 ++#define t3 $4 ++#define t4 $5 ++#define t5 $6 ++#define t6 $7 ++#define t7 $8 ++ ++#define s0 $9 /* saved-registers (callee-saved registers) */ ++#define s1 $10 ++#define s2 $11 ++#define s3 $12 ++#define s4 $13 ++#define s5 $14 ++#define s6 $15 ++#define fp s6 /* frame-pointer (s6 in frame-less procedures) */ ++ ++#define a0 $16 /* argument registers (caller-saved) */ ++#define a1 $17 ++#define a2 $18 ++#define a3 $19 ++#define a4 $20 ++#define a5 $21 ++ ++#define t8 $22 /* more temps (caller-saved) */ ++#define t9 $23 ++#define t10 $24 ++#define t11 $25 ++#define ra $26 /* return address register */ ++#define t12 $27 ++ ++#define pv t12 /* procedure-variable register */ ++#define AT $at /* assembler temporary */ ++#define gp $29 /* global pointer */ ++#define sp $30 /* stack pointer */ ++#define zero $31 /* reads as zero, writes are noops */ ++ ++#endif /* __sw_64_regdef_h__ */ +diff --git a/include/grub/sw64/setjmp.h b/include/grub/sw64/setjmp.h +new file mode 100644 +index 000000000..a71c9c56d +--- /dev/null ++++ b/include/grub/sw64/setjmp.h +@@ -0,0 +1,28 @@ ++/* Define the machine-dependent type `jmp_buf'. Linux/IA-64 version. ++ Copyright (C) 1999, 2000, 2008 Free Software Foundation, Inc. ++ Contributed by David Mosberger-Tang . ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Library General Public License as ++ published by the Free Software Foundation; either version 2 of the ++ License, or (at your option) any later version. ++ ++ The GNU C Library 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 ++ Library General Public License for more details. ++ ++ You should have received a copy of the GNU Library General Public ++ License along with the GNU C Library; see the file COPYING.LIB. If not, ++ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, ++ Boston, MA 02111-1307, USA. */ ++ ++/* User code must not depend on the internal representation of jmp_buf. */ ++ ++#define _JBLEN 70 ++ ++/* the __jmp_buf element type should be __float80 per ABI... */ ++typedef long grub_jmp_buf[_JBLEN] __attribute__ ((aligned (16))); /* guarantees 128-bit alignment! */ ++ ++int grub_setjmp (grub_jmp_buf env); ++void grub_longjmp (grub_jmp_buf env, int val) __attribute__ ((noreturn)); +diff --git a/include/grub/sw64/time.h b/include/grub/sw64/time.h +new file mode 100644 +index 000000000..03ee79fa4 +--- /dev/null ++++ b/include/grub/sw64/time.h +@@ -0,0 +1,28 @@ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2007, 2008 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 . ++ */ ++ ++#ifndef KERNEL_CPU_TIME_HEADER ++#define KERNEL_CPU_TIME_HEADER 1 ++ ++static __inline void ++grub_cpu_idle (void) ++{ ++ /* FIXME: not implemented */ ++} ++ ++#endif /* ! KERNEL_CPU_TIME_HEADER */ +diff --git a/include/grub/sw64/types.h b/include/grub/sw64/types.h +new file mode 100644 +index 000000000..91a546dd2 +--- /dev/null ++++ b/include/grub/sw64/types.h +@@ -0,0 +1,32 @@ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2008 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 . ++ */ ++ ++#ifndef GRUB_TYPES_CPU_HEADER ++#define GRUB_TYPES_CPU_HEADER 1 ++ ++/* The size of void *. */ ++#define GRUB_TARGET_SIZEOF_VOID_P 8 ++ ++/* The size of long. */ ++#define GRUB_TARGET_SIZEOF_LONG 8 ++ ++/* ia64 is little-endian (usually). */ ++#undef GRUB_TARGET_WORDS_BIGENDIAN ++ ++ ++#endif /* ! GRUB_TYPES_CPU_HEADER */ +diff --git a/include/grub/util/install.h b/include/grub/util/install.h +index 7df3191f4..13ad805e9 100644 +--- a/include/grub/util/install.h ++++ b/include/grub/util/install.h +@@ -109,6 +109,7 @@ enum grub_install_plat + GRUB_INSTALL_PLATFORM_ARM_COREBOOT, + GRUB_INSTALL_PLATFORM_RISCV32_EFI, + GRUB_INSTALL_PLATFORM_RISCV64_EFI, ++ GRUB_INSTALL_PLATFORM_SW64_EFI, + GRUB_INSTALL_PLATFORM_MAX + }; + +diff --git a/include/grub/util/misc.h b/include/grub/util/misc.h +index e9e0a6724..e68ee361e 100644 +--- a/include/grub/util/misc.h ++++ b/include/grub/util/misc.h +@@ -49,4 +49,8 @@ void grub_util_host_init (int *argc, char ***argv); + + int grub_qsort_strcmp (const void *, const void *); + ++#ifdef __sw_64__ ++void __attribute__ ((weak)) sunway_debug_delegate(char *buffer); ++#endif ++ + #endif /* ! GRUB_UTIL_MISC_HEADER */ +diff --git a/util/grub-install-common.c b/util/grub-install-common.c +index 4e212e690..e09abd1a7 100644 +--- a/util/grub-install-common.c ++++ b/util/grub-install-common.c +@@ -902,6 +902,7 @@ static struct + [GRUB_INSTALL_PLATFORM_ARM_COREBOOT] = { "arm", "coreboot" }, + [GRUB_INSTALL_PLATFORM_RISCV32_EFI] = { "riscv32", "efi" }, + [GRUB_INSTALL_PLATFORM_RISCV64_EFI] = { "riscv64", "efi" }, ++ [GRUB_INSTALL_PLATFORM_SW64_EFI] = { "sw64", "efi" }, + }; + + char * +diff --git a/util/grub-install.c b/util/grub-install.c +index 0fbe7f78c..f4159b981 100644 +--- a/util/grub-install.c ++++ b/util/grub-install.c +@@ -332,6 +332,8 @@ get_default_platform (void) + #else + return NULL; + #endif ++#elif defined (__sw_64__) ++ return "sw64-efi"; + #else + return NULL; + #endif +@@ -507,6 +509,7 @@ have_bootdev (enum grub_install_plat pl) + case GRUB_INSTALL_PLATFORM_I386_XEN: + case GRUB_INSTALL_PLATFORM_X86_64_XEN: + case GRUB_INSTALL_PLATFORM_I386_XEN_PVH: ++ case GRUB_INSTALL_PLATFORM_SW64_EFI: + return 0; + + /* pacify warning. */ +@@ -912,6 +915,7 @@ main (int argc, char *argv[]) + case GRUB_INSTALL_PLATFORM_ARM64_EFI: + case GRUB_INSTALL_PLATFORM_RISCV32_EFI: + case GRUB_INSTALL_PLATFORM_RISCV64_EFI: ++ case GRUB_INSTALL_PLATFORM_SW64_EFI: + case GRUB_INSTALL_PLATFORM_IA64_EFI: + case GRUB_INSTALL_PLATFORM_I386_IEEE1275: + case GRUB_INSTALL_PLATFORM_SPARC64_IEEE1275: +@@ -959,6 +963,7 @@ main (int argc, char *argv[]) + case GRUB_INSTALL_PLATFORM_ARM64_EFI: + case GRUB_INSTALL_PLATFORM_RISCV32_EFI: + case GRUB_INSTALL_PLATFORM_RISCV64_EFI: ++ case GRUB_INSTALL_PLATFORM_SW64_EFI: + case GRUB_INSTALL_PLATFORM_IA64_EFI: + case GRUB_INSTALL_PLATFORM_I386_IEEE1275: + case GRUB_INSTALL_PLATFORM_ARM_UBOOT: + +@@ -906,6 +909,7 @@ main (int argc, char *argv[]) + case GRUB_INSTALL_PLATFORM_I386_EFI: + case GRUB_INSTALL_PLATFORM_IA64_EFI: + case GRUB_INSTALL_PLATFORM_X86_64_EFI: ++ case GRUB_INSTALL_PLATFORM_SW64_EFI: + is_efi = 1; + grub_util_error (_("this utility cannot be used for EFI platforms" + " because it does not support UEFI Secure Boot")); +@@ -1133,6 +1139,9 @@ main (int argc, char *argv[]) + case GRUB_INSTALL_PLATFORM_RISCV64_EFI: + efi_file = "BOOTRISCV64.EFI"; + break; ++ case GRUB_INSTALL_PLATFORM_SW64_EFI: ++ efi_file = "BOOTSW64.EFI"; ++ break; + default: + grub_util_error ("%s", _("You've found a bug")); + break; +@@ -1166,6 +1175,9 @@ main (int argc, char *argv[]) + case GRUB_INSTALL_PLATFORM_RISCV64_EFI: + efi_file = "grubriscv64.efi"; + break; ++ case GRUB_INSTALL_PLATFORM_SW64_EFI: ++ efi_file = "grubsw64.efi"; ++ break; + default: + efi_file = "grub.efi"; + break; +@@ -1470,6 +1482,7 @@ main (int argc, char *argv[]) + case GRUB_INSTALL_PLATFORM_ARM64_EFI: + case GRUB_INSTALL_PLATFORM_RISCV32_EFI: + case GRUB_INSTALL_PLATFORM_RISCV64_EFI: ++ case GRUB_INSTALL_PLATFORM_SW64_EFI: + case GRUB_INSTALL_PLATFORM_IA64_EFI: + g = grub_util_guess_efi_drive (*curdev); + break; +@@ -1565,6 +1578,7 @@ main (int argc, char *argv[]) + case GRUB_INSTALL_PLATFORM_ARM64_EFI: + case GRUB_INSTALL_PLATFORM_RISCV32_EFI: + case GRUB_INSTALL_PLATFORM_RISCV64_EFI: ++ case GRUB_INSTALL_PLATFORM_SW64_EFI: + case GRUB_INSTALL_PLATFORM_IA64_EFI: + core_name = "core.efi"; + snprintf (mkimage_target, sizeof (mkimage_target), +@@ -1670,6 +1684,7 @@ main (int argc, char *argv[]) + case GRUB_INSTALL_PLATFORM_ARM64_EFI: + case GRUB_INSTALL_PLATFORM_RISCV32_EFI: + case GRUB_INSTALL_PLATFORM_RISCV64_EFI: ++ case GRUB_INSTALL_PLATFORM_SW64_EFI: + case GRUB_INSTALL_PLATFORM_IA64_EFI: + case GRUB_INSTALL_PLATFORM_MIPSEL_QEMU_MIPS: + case GRUB_INSTALL_PLATFORM_MIPS_QEMU_MIPS: +@@ -1924,6 +1939,7 @@ main (int argc, char *argv[]) + case GRUB_INSTALL_PLATFORM_ARM64_EFI: + case GRUB_INSTALL_PLATFORM_RISCV32_EFI: + case GRUB_INSTALL_PLATFORM_RISCV64_EFI: ++ case GRUB_INSTALL_PLATFORM_SW64_EFI: + case GRUB_INSTALL_PLATFORM_IA64_EFI: + { + char *dst = grub_util_path_concat (2, efidir, efi_file); +diff --git a/util/grub-mkimagexx.c b/util/grub-mkimagexx.c +index d78fa3e53..aa57aa638 100644 +--- a/util/grub-mkimagexx.c ++++ b/util/grub-mkimagexx.c +@@ -781,8 +781,18 @@ SUFFIX (relocate_addrs) (Elf_Ehdr *e, struct section_metadata *smd, + Elf_Half i; + Elf_Shdr *s; + #ifdef MKIMAGE_ELF64 ++ grub_uint64_t got_offset = 0; ++ grub_uint64_t *gpptr; ++ ++ if (image_target->elf_target == EM_SW_64) ++ { ++ got_offset = got_off; ++ gpptr = (void *) (pe_target + got_offset + 0x8000); ++ } ++ else ++ gpptr = (void *) (pe_target + got_off); ++ + struct grub_ia64_trampoline *tr = (void *) (pe_target + tramp_off); +- grub_uint64_t *gpptr = (void *) (pe_target + got_off); + unsigned unmatched_adr_got_page = 0; + #define MASK19 ((1 << 19) - 1) + #else +@@ -1123,6 +1133,118 @@ SUFFIX (relocate_addrs) (Elf_Ehdr *e, struct section_metadata *smd, + } + break; + } ++ case EM_SW_64: ++ { ++ sym_addr += addend; ++ switch (ELF_R_TYPE (info)) ++ { ++ case R_SW64_NONE: ++ break; ++ case R_SW64_REFLONG: ++ *(grub_uint32_t *)target = grub_host_to_target32 (sym_addr); ++ break; ++ case R_SW64_REFQUAD: ++ { ++ *(grub_uint32_t *)target = grub_host_to_target32(sym_addr); ++ *((grub_uint32_t *)target + 1) = grub_host_to_target32(sym_addr >> 32); ++ break; ++ } ++ case R_SW64_GPREL32: ++ { ++ *(grub_uint32_t *) target = (grub_host_to_target64 (sym_addr) - ++ ((char *) gpptr - (char *)pe_target + image_target->vaddr_offset )) & 0xffffffff; ++ break; ++ } ++ case R_SW64_LITERAL: ++ { ++ grub_uint64_t li_hi; ++ grub_uint64_t li_lo; ++ ++ li_hi = (grub_uint64_t)pe_target + got_offset + (((grub_uint64_t)ELF_R_TYPE(r->r_info)) >> 8 ); ++ li_lo = li_hi - ((grub_uint64_t) gpptr); ++ *(grub_uint16_t *) target = (li_lo & 0xffff); ++ *(grub_uint64_t *) (li_hi) = grub_host_to_target64(grub_host_to_target64 (sym_addr)); ++ got_offset += 8; ++ break; ++ } ++ case R_SW64_LITERAL_GOT: ++ break; ++ case R_SW64_LITUSE: ++ break; ++ case R_SW64_GPDISP: ++ { ++ grub_uint64_t hi; ++ grub_uint64_t lo; ++ grub_int64_t gpoffset = (((char *) gpptr - (char *) pe_target + image_target->vaddr_offset)) ++ - ((offset + target_section_addr + image_target->vaddr_offset)); ++ if (gpoffset & 0x8000) { ++ hi = ((gpoffset + 0x8000) >> 16) & 0xffff; ++ lo = gpoffset & 0xffff; ++ } else { ++ hi = (gpoffset >> 16) & 0xffff; ++ lo = gpoffset & 0xffff; ++ } ++ *(grub_uint32_t *) target = grub_host_to_target32 ((grub_target_to_host32 (*target) & 0xffff0000) | (hi & 0xffff)); ++ *(grub_uint32_t *) ((unsigned long)target + addend) = ++ grub_host_to_target32 ((grub_target_to_host32 (*(grub_uint32_t *) ++ ((unsigned long)target + addend)) & 0xffff0000) | (lo & 0xffff)); ++ break; ++ } ++ case R_SW64_BRADDR: ++ { ++ grub_uint64_t braddr = grub_host_to_target64 (grub_target_to_host64 (*target) + sym_addr) - ((grub_uint64_t)target + 4); ++ braddr = braddr >> 2; ++ *(grub_uint32_t *) target = (*(grub_uint32_t *)target & (~0x1fffff)) | (braddr & 0x1fffff); ++ break; ++ } ++ case R_SW64_HINT: ++ break; ++ case R_SW64_SREL32: ++ { ++ grub_uint64_t srel32 = grub_host_to_target64 (grub_target_to_host64 (*target) + sym_addr); ++ srel32 -= (grub_uint64_t)target; ++ *(grub_uint32_t *) target = srel32; ++ break; ++ } ++ case R_SW64_SREL64: ++ { ++ grub_uint64_t srel64 = grub_host_to_target64 (grub_target_to_host64 (*target) + sym_addr); ++ srel64 -= (grub_uint64_t)target; ++ *(grub_uint64_t *) target = srel64; ++ break; ++ } ++ case R_SW64_GPRELHIGH: ++ { ++ grub_uint64_t gprel_hi = ((grub_host_to_target64 (sym_addr) - (((char *) gpptr - (char *)pe_target + image_target->vaddr_offset) + 0x0))); ++ ++ if (gprel_hi & 0x8000) ++ gprel_hi = ((gprel_hi + 0x8000) >> 16) & 0xffff; ++ else ++ gprel_hi = (gprel_hi >> 16) & 0xffff; ++ ++ *(grub_uint32_t *) target = grub_host_to_target32 ((grub_target_to_host32 (*target) & 0xffff0000) | (gprel_hi & 0xffff)); ++ break; ++ } ++ case R_SW64_GPRELLOW: ++ { ++ grub_uint64_t gprel_lo = (grub_host_to_target64 (sym_addr) - ((char *) gpptr - (char *)pe_target + image_target->vaddr_offset)); ++ *(grub_uint32_t *) target = grub_host_to_target32 ((grub_target_to_host32 (*target) & 0xffff0000) | (gprel_lo & 0xffff)); ++ break; ++ } ++ case R_SW64_GPREL16: ++ { ++ grub_uint64_t gprel16 = grub_host_to_target64 (grub_target_to_host64 (*target) + sym_addr); ++ gprel16 = (grub_uint64_t)(gprel16 - (grub_uint64_t)gpptr); ++ *(grub_uint16_t *) target = gprel16; ++ break; ++ } ++ default: ++ grub_util_error (_("relocation 0x%lx is not implemented yet"), ++ ELF_R_TYPE (info)); ++ break; ++ } ++ break; ++ } + #endif + #if defined(MKIMAGE_ELF32) + case EM_ARM: +@@ -1594,6 +1716,19 @@ translate_relocation_pe (struct translate_context *ctx, + image_target); + } + break; ++ case EM_SW_64: ++ if (ELF_R_TYPE (info) == R_SW64_REFQUAD) ++ { ++ grub_util_info ("adding a relocation entry for 0x%llx", ++ (unsigned long long) addr); ++ ctx->current_address ++ = add_fixup_entry (&ctx->lst, ++ GRUB_PE32_REL_BASED_DIR64, ++ addr, ++ 0, ctx->current_address, ++ image_target); ++ } ++ break; + case EM_IA_64: + switch (ELF_R_TYPE (info)) + { +@@ -2015,7 +2150,8 @@ make_reloc_section (Elf_Ehdr *e, struct grub_mkimage_layout *layout, + + image_target->vaddr_offset, + 2 * layout->ia64jmpnum, + image_target); +- if (image_target->elf_target == EM_IA_64 || image_target->elf_target == EM_AARCH64) ++ if (image_target->elf_target == EM_IA_64 || image_target->elf_target == EM_AARCH64 || ++ image_target->elf_target == EM_SW_64) + create_u64_fixups (&ctx, + layout->got_off + + image_target->vaddr_offset, +@@ -2384,6 +2520,17 @@ SUFFIX (grub_mkimage_load_image) (const char *kernel_path, + + grub_arm64_dl_get_tramp_got_size (e, &tramp, &layout->got_size); + ++ layout->got_off = layout->kernel_size; ++ layout->kernel_size += ALIGN_UP (layout->got_size, 16); ++ } ++ else if (image_target->elf_target == EM_SW_64) ++ { ++ grub_size_t tramp; ++ ++ layout->kernel_size = ALIGN_UP (layout->kernel_size, 16); ++ ++ grub_sw64_dl_get_tramp_got_size (e, &tramp, &layout->got_size); ++ + layout->got_off = layout->kernel_size; + layout->kernel_size += ALIGN_UP (layout->got_size, 16); + } +diff --git a/util/grub-module-verifier.c b/util/grub-module-verifier.c +index 163529ca9..f48bfbd56 100644 +--- a/util/grub-module-verifier.c ++++ b/util/grub-module-verifier.c +@@ -176,6 +176,24 @@ struct grub_module_verifier_arch archs[] = { + -1 + } + }, ++ { "sw64", 8, 0, EM_SW_64, GRUB_MODULE_VERIFY_SUPPORTS_REL | GRUB_MODULE_VERIFY_SUPPORTS_RELA, (int[]){ ++ R_SW64_NONE, ++ R_SW64_REFQUAD, ++ R_SW64_GPREL32, ++ R_SW64_LITERAL, ++ R_SW64_LITERAL_GOT, ++ R_SW64_LITUSE, ++ R_SW64_GPDISP, ++ R_SW64_BRSGP, ++ R_SW64_BRADDR, ++ R_SW64_HINT, ++ R_SW64_SREL32, ++ R_SW64_SREL64, ++ R_SW64_GPRELHIGH, ++ R_SW64_GPRELLOW, ++ R_SW64_GPREL16, ++ -1 ++ } }, + }; + + struct platform_whitelist { +diff --git a/util/misc.c b/util/misc.c +index d545212d9..6b1e7d360 100644 +--- a/util/misc.c ++++ b/util/misc.c +@@ -223,3 +223,9 @@ grub_qsort_strcmp (const void *p1, const void *p2) + return strcmp(*(char *const *)p1, *(char *const *)p2); + } + ++#ifdef __sw_64__ ++void __attribute__ ((weak)) ++sunway_debug_delegate(char *buffer __attribute__ ((unused))) ++{ ++} ++#endif +diff --git a/util/mkimage.c b/util/mkimage.c +index a26cf76f7..895a0a57e 100644 +--- a/util/mkimage.c ++++ b/util/mkimage.c +@@ -425,6 +425,22 @@ static const struct grub_install_image_target_desc image_targets[] = + .pe_target = GRUB_PE32_MACHINE_IA64, + .elf_target = EM_IA_64, + }, ++ { ++ .dirname = "sw64-efi", ++ .names = {"sw64-efi", NULL}, ++ .voidp_sizeof = 8, ++ .bigendian = 0, ++ .id = IMAGE_EFI, ++ .flags = PLATFORM_FLAGS_NONE, ++ .total_module_size = TARGET_NO_FIELD, ++ .decompressor_compressed_size = TARGET_NO_FIELD, ++ .decompressor_uncompressed_size = TARGET_NO_FIELD, ++ .decompressor_uncompressed_addr = TARGET_NO_FIELD, ++ .section_align = GRUB_PE32_SECTION_ALIGNMENT, ++ .vaddr_offset = EFI64_HEADER_SIZE, ++ .pe_target = GRUB_PE32_MACHINE_SW_64, ++ .elf_target = EM_SW_64, ++ }, + { + .dirname = "mips-arc", + .names = {"mips-arc", NULL}, +-- +2.33.0 + diff --git a/grub2.spec b/grub2.spec index cedbd44..569f54b 100644 --- a/grub2.spec +++ b/grub2.spec @@ -1,3 +1,4 @@ +%define efi_vendor %{expand:%{_efi_srpm_macros_setup}}%{expand:%{_efi_vendor}} %undefine _hardened_build %global tarversion 2.06 @@ -14,7 +15,7 @@ Name: grub2 Epoch: 1 Version: 2.06 -Release: 33 +Release: 34 Summary: Bootloader with support for Linux, Multiboot and more License: GPLv3+ URL: http://www.gnu.org/software/grub/ @@ -33,6 +34,10 @@ Source12: bootstrap.conf Source13: sbat.csv.in Source14: config_for_secure +Source3000: 9000-Add-sw_64-support.patch +Source3001: 0021-grub-enable-kernel.kss.img-build-for-sw64_efi.patch +Source3002: grubsw_64.efi + %include %{SOURCE1} %include %{SOURCE2} @@ -313,6 +318,57 @@ if [ -f /etc/default/grub ]; then fi fi +# kylinsec +if [ $(arch) == aarch64 ];then + lspci -v | grep "Kernel driver in use:" | grep mwv206 + if [ $? == 0 ];then + sed -i 's/terminal_output/#terminal_output/g' /etc/grub.d/00_header + fi +fi +# end kylinsec + +# kylinsec +%posttrans common +set -eu + +EFI_HOME=%{efi_esp_dir} +GRUB_HOME=/boot/%{name} +ESP_PATH=/boot/efi + +if ! mountpoint -q ${ESP_PATH}; then + exit 0 # no ESP mounted, nothing to do +fi + +if test ! -f ${EFI_HOME}/grub.cfg; then + # there's no config in ESP, create one + grub2-mkconfig -o ${EFI_HOME}/grub.cfg +fi + +if grep -q "configfile" ${EFI_HOME}/grub.cfg; then + exit 0 # already unified, nothing to do +fi + +# create a stub grub2 config in EFI +BOOT_UUID=$(%{name}-probe --target=fs_uuid ${GRUB_HOME}) +GRUB_DIR=$(%{name}-mkrelpath ${GRUB_HOME}) + +cat << EOF > ${EFI_HOME}/grub.cfg.stb +search --no-floppy --fs-uuid --set=dev ${BOOT_UUID} +set prefix=(\$dev)${GRUB_DIR} +export \$prefix +configfile \$prefix/grub.cfg +EOF + +if test -f ${EFI_HOME}/grubenv; then + cp -a ${EFI_HOME}/grubenv ${EFI_HOME}/grubenv.rpmsave + mv --force ${EFI_HOME}/grubenv ${GRUB_HOME}/grubenv +fi + +cp -a ${EFI_HOME}/grub.cfg ${EFI_HOME}/grub.cfg.rpmsave +cp -a ${EFI_HOME}/grub.cfg ${GRUB_HOME}/ +mv ${EFI_HOME}/grub.cfg.stb ${EFI_HOME}/grub.cfg +# end kylinsec + %files common -f grub.lang %defattr(-,root,root) %license COPYING @@ -440,6 +496,47 @@ fi %{_datadir}/man/man* %changelog +* Thu Apr 03 2023 majinhao - 1:2.06-27.kb17 +- KYOS-F: remove the grub parameter "rb.lvm.lv=ko/backup" for sw + +* Wed Apr 02 2023 majinhao - 1:2.06-27.kb16 +- KYOS-F: add the grub parameter crashkernel=512M for sw + +* Tue Apr 01 2023 majinhao - 1:2.06-27.kb15 +- KYOS-F: optimize backup and restore configuration files (#9159) + +* Fri Jul 28 2023 majinhao - 1:2.06-27.kb14 +- KYOS-F: modify duplicate grub2 boot entries (#9802) + +* Fri Jul 28 2023 guoqinglan - 1:2.06-27.kb13 +- KYOS-F: remove cmdline args audit=1 for sw_64 (#10373) +- KYOS-F: remove cmdline args console=tty0 console=ttyS0,115200n8 for sw_64 (#9811) + +* Mon Jul 17 2023 panchenbo - 1:2.06-27.kb12 +- KYOS-F: kss fallback to soft backend when hardware is not av + +* Wed Jul 05 2023 panchenbo - 1:2.06-27.kb11 +- KYOS-F: del some unused files for kss + set enforcing 0 for sw + +* Wed Jul 05 2023 mazhiguo - 1:2.06-27.kb10 +- KYOS-F: fixed kylin-backup-grub.sh for sw + +* Sat Jul 01 2023 mazhiguo - 1:2.06-27.kb9 +- KYOS-F: fixed 10_linux script for sw(#8642) + +* Tue Jun 27 2023 panchenbo - 1:2.06-27.kb8 +- KYOS-F: fix sw_64 grub.efi boot fail + +* Wed Jun 21 2023 mazhiguo - 1:2.06-27.kb7 +- KYOS-F: fixed kylin-backup-grub.sh + +* Mon Jun 5 2023 Wang Zhijiang - 1:2.06-27.kb6 +- KYOS-F: integrity trusted feature + +* Wed May 31 2023 mazhiguo - 1:2.06-27.kb5 +- KYOS-F: fixed boot para for backup(#4864) + * Mon Jul 24 2023 zhangqiumiao - 1:2.06-33 - Type:bugfix - CVE:NA @@ -656,7 +753,7 @@ fi * Wed Jan 12 2022 lvxiaoqian - 2.06-6 - update grub.macros for riscv - + * Thu Apr 14 2022 zhangqiumiao - 2.06-5 - Type:bugfix - CVE:NA @@ -853,8 +950,8 @@ strip kernel.exec and lnboot.image - add CPPFLAGS * Sat Aug 1 2020 hanzhijun - 2.04-1 -- update to 2.0.4 - +- update to 2.0.4 + * Fri Jul 17 2020 chenyaqiang - 2.02-75 - remove repeated buildrequest packge “rpm-devel” in grub2.spec diff --git a/grubsw_64.efi b/grubsw_64.efi new file mode 100755 index 0000000000000000000000000000000000000000..719f53ef508c6f8527234dd3569ea7fb484b8aee GIT binary patch literal 712624 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

qbF`7MJe;H*AYXk3@wYj9n5 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

&h_;b$((F@YaNK@ z{`;B-%{^4bERGsj`u<-bSx%6{UYcqy;ATs2I7~t>TUXWp`r3;=0vUm*8Di-hhI z_^FzU$aG>auZv?drE`e~O$IOR6kG_7H&HMVE`(h&Qww@8!d(PT##zz);Z!;fn zkju*-Pxo3e^;y4)QGLzMXKpKNo8P~)zg;H*-%NdcB07&~qZ})<}EN49F5OfNKt9jSUYaYj)c=3eV3Wnp{)g%~#nd|Im zQ;z7MzftZh9-hgnY~JfRz9Go)@sU#A=4h?>6ZRxISWXD&PyEmegSdCEviI#+)IOWu z*j`=q7XRzFXs$M*yHE3lZNGv3`i25=Law3L!Z!U@JeyB1|M$=Nt?$|Kc9Jizxa^6X zAxWR?$@AiO-$qev*C!Pp*mr%_&?Y-CPqF2DbhXq{mBIhY!6UqTvCsNv&>xuhVeW2{(pj&EJX7iy5 zRu?*!{!1`xd5?W?5ne*Y1Y12k zmlK)g6|?RF7-8uj=saOJ&kG?Bl;1YQeU)Kzol3QpZgMwyI&;xE#z$&B$63~>@%j4F z?!_*;5<2{neDtD|T3f3I7Hp{+ir#d;+fsF97mz$i8yvN@2GNJZ6K#9&)}c zZ1(4cIR}SqeNW?kk@9)0m+bhIARkL(C;BgEJ`M1o_)mKt6I{FdixuISi=LN)uzzd;dyJLLp#cdgPA@8DepZ};m z`zmX(D(QwA+DgBbh$|;fZiG0+f~CymcxYagB9BY^%N&YCjx2kC9-l{bd_Mo43X6oIo#D_j!8{~b?AG$97!|=Lz zeq>n1z{tP~7vXb;lh{@};Spf%D<9&dw+?Zf?N4)`w!z&J|B5@YywI)ogl9GWJB?Mi z$~S&5Z#>=9<;NGVy@>7i7~@`>)cn4FNcL1!N@H-H3Fu1o(E8;j(S|XkH2(=BtGem$ zQ8(%q$Jh(wYgjLDU{i#nEpd%C;_PD|{jK*B-!v}S+xbYO6=>{F8w)(E6`fjx>ZiWS3}o5u2_#JLU%r%4y}FsmC&<~YyIB1%3rq# zLgPbz* z(lYO-4^W5-5zo4#`X>D&Aira@w|eq#>SMaoEUk*n-l&? zEC=4obKmjq3jfM;+_c%t)NhWn8@O8x++kgC-!(X)&os+VR~6Z3-lbK2&ip#^-1^wS zvh7tD(Q)%*HQ{wy>2`4ISLApB%Mn z%u3p@RtoN+U6OW5+9he1q+ODBb+oIeUHu7p(QUl9+bMi9nN=O%3%6IS2@j|k6nUon zV<+)^L)~U_*!*B|$oavNtBF^U9Cn?n7dy`FiwCtXnLMCi@#I0o6JHa#ui~1>n)2Ji zgP?O_#~}Ba@-^Yr74yT1ZF$c5M(@dSegvE!Eg8^ych$M;6O&iDiK;6iKPdko^W2VU z&~VrRw=#EvQ@JIaXwDz%RNfMHwoi6zDs$Zr%5k%;7eBU#Ytp4&Oeh;vkYOK&TeggW-d9s+b?CHB=aOrh zzvS0^AalXtHHVb12R}6a*ay+68_Rn;3lF{Jdg*d^JvfxFDCgasQhWfBto^9MoeK`v z^Amkdx#FLLc zr1z4yOmUw9kK}URimZ4yv%g}b3t zH`=WEQ2)iyyPxw>#ogiJ7!J2|NliMgwWhIay)7Qw8)qDhYn!+3)%h}Lt|II8oG1k+3wdXE?M7F>7P%& zS5bDKFNX(wCR^iubC0&veslQdaaR1dbOSHP*A05ggoB*<1?yaEUh7}7_$S1{6}e-8 zTePI8wcq6Pqt0aIS6}mJ@#G%-nYPUk_akuDqpj&&lr3Do)L`_bX+c3}Fs( zovVy5E5;hCaA#Wi&AY_d2gD)q?(g*U+05_iQ0GQ}oV?G+9Ek1*?)AsJ8d{Wo>if%| z;hr9Q)5=#u*Co+s+uhCwaeFLm3ppPhDGnd5=v_9u@`cdY)T^Pf$vy>3D;q-BrJfFT zZfXkMnS!pVdHi4d%Y6R!bN7(siw)L(xVPrz^jV z^z-?^ni+O0?uXBw2(2~otIauy^y<)?Mn63+yoEd}>Fw_NX#AguxpiItZ6&SAG05Q{ zHlqRjr~a8Z17z(WH&MZF_Woj%w_W4TzVDldo;yEuXOcQe$%m&yYf~DF>ZR$oA=H_C z0eM^;ejXdojS(wn^w86D)7$4Uh9-E)b=t@^dcN5o2fNYqDNZ|U%AE|{P4j_!7VBhj zc#Ao=h`L_$ywJ0phfHt#C;E^)7{WR~{lJXLl2c(~VI5~l?J#I^2H(T1{~N;}nt2@p zoTWvJ$NxBdgI62QiS2N%pH%MTPB?|T_V}BC`)0BPxrY3Uj{;tTvCIrNcsbE@{2OkW zCm(JtV|xTy66iYm%Q))zPF%&i1|Q-$D~Ss=<7vU(l>Fn3T69U?LIL*7aJ6?O@~?!0 zvTpg897-g+1%Auw4I1PKiU}(lROxGptx#uS+uHuG+L$q=Q*pq zp-yg0`2wV~=Aa9Nu)lKLide`kN1p6KcO1f5Q_f0gbx)DAXT=0}z2`Zdskk$C6Y&6> zCb}^6XYyFPT?E+VfeiAY1Bbxv-j@dUry@Wg1zy4exDfGSbj#?zW9j+>#8EH zd-#@LEAMZYGniRPaS^YNf-hK?fc&+2i=HCtI#1onf&t=})dM|X#hqfmWZ@MNkeQN?9 z{5tRC@z&ksQ+RU$f0OqW=1_C2__mScWMEHttWS7RrS_GH>^s_9<|12^uOS@XQuRux zv3cNZ{?GT{h0;5q!3OOw>Qnp6@$6sPYi{VAj(#`2?R)HHQaj#=z` zBUz7EvsY_hp2_}OOnvRWli269|BlM)Q~Tgk^m{`%motSu6?x<&mJFEa{t_DOsMY)q zoUkSSx|`lAzL$P4e*b>Bnf>^!9h&>R@H+1|ZaO^&7-95AwJ&!k)BfSw@C3@y8FCnt zKOXjXczibF(S9ypndqT60yS>G-PT&@WyURfMFV^(&w)-q!zZEjcmsOEe`VfESGYIP z*Y)5!16;Pm|ATMLa}#<@d%p8lo8b2YM)rE*T=OyM1G!G7L;d!pTy)ePuisbkH=l26 zD>ws}IhFb@dL2IU)>hze=uP`>fA}|QwVr~tr+Q}~*R%QLc=+Ud@WMP~AO6?Lw}zt4 zlHv10UiuZjNgnIHDC8S5sWZv`9segM@j@V%rm;>#?B&v-wZ%yHTiA?LNlvJ*~U zpRT&w*a`0#xk6qK)2^ZJ4c;F8+`{#3K-YO^G5oPO)XIDE1?BNj!S1T^$d&kiLhwci z`yss}Ob*xj3IWsyf%Xh~aL;dn$F+9vRsb zCGR)i4Lr?%liAx&tAiivL)zQmhgQV#Fn2(#0lS4d+RIY|;M06JpEZ!bNc%!Qd0I}I zz?omziw~Sl{OwRr{9JxzWNZ0j@L$-;TQqFBWAw`WR;Nus5MH*!2O*~=^2 zjt^)eFe_6{hG*}@27M1+^YeP?z1a%GcisGU7WoKAt$HC@us&T`VD$OQT8(Xtn@)>v zbHeYSzh2@+&~bmvocVUq@33b+OH9NrQr&^A&sPmw-xB|!o34sSUMMFfcZ=3-z;BZK zMFnriBkpGRPb3e!o z-Y)(+1O5`sJa{Yr`EBH6ceY&YZfE~GZh3G1pFe3!JnwGoV>drGu`C^*7|Dx8&S>H9 z^Y|u?rc*CscNnL6Z**~ZvG;TMOY0MUGH>^4d|IF7UF$ZWoz~Q;nc?JM9J8t@*=xO5 z*~|SVw68Ms``r2B`kijp?;A;fJ?;4abp2NTFV-(-s_nAxIWJ6V&d-34MBjmt-Mq{D zx$%eeVXjVsF9*VxS4KWB&u6`g|A;T#GHFsvJTLM~Py4!P3>gmAJ3BcA^cG6eZ>2|ZEU6zo?Tr?{c$s)br9?!!Fmg^)`lUEwq>m=t*PMqX7hbw0$-MqRXT?v zR_}z!PvN;9F~^}EGd zx1x#G*BR^|{`!g-J$h#6;4Q9`w}d!{#RFTn;iKPLRa785@Fe^@ubTT2=OM@QS+{e- zFO=UO{&jhN7Ou9F_AdcH}NY!@#bT z-SczW{jGVq)Xq!kJHfp0mX(>8laHF0H;@qx!~o_vr-1LDn3qFlUb^`881wV~{}1O! zI@)~h+e+8Y*8lXqo_wc)-e~l*Bfjn^9Z&kBY|Fga{6n_tTTYn&qf_KWZZP`7DMuC} zBNlhT)jLnf_Ih-=ss{G+s9WPb9Xc&_6Zy8K2k5-!ICPCG55HyX;V1Bs$sV3SxpcUR z{JVaEckzw|&c&A@v#QZKhZ>!IozcI(jod9q9>_n1?5Ztk@!!!~jO^qbzxjr&HR8*I zqw8ST8Mz?74dlWN;qlxze2W|mjE&fc%Nc7P-$ajH{C^^PyMGsCN9})pKRre38=qEH ze)t9N7p%)=w3!G#g1HO*eHeOr9=5A|U2)_0ia$0x{II9oa^zNO4&k4>o%$i?YWC;~ zPyNc4G5sB$j-9f{oL`@A{3LVRWN*aKGs^M*PIR|<{md92Hs>Od*^Ng39*FJ`!9N$C ztuxqtUV-cjPxi%(CiztKE=o@LbT4&iVKd)qbI+*Ztm?sZ8~>QUTKU8xvlqp~;e=@) zavGa+!;9hvDVH48*aT}oYhFG!`PJlOo6@0khEq)(BVi~T&W6v(=VyN(-f#-*S>w?g zqLSmj4m*2A4m8OBUSOxaYtHBKFPQsf#Rnd$(s^SpKHVJWij=MV@2EaRI)Tlkvf>fOX#-+8S*ZE^_}Kj^*b{Bf90rEUtg)S2Aw&y;S16kgw7(g zx5#Iiy|2(d`KR{G34vd~7chm>yYOdE|KjiJ{C&Uqt<8siLcO5;*Yt3;oR8;cowJRyXWZ58+Bebg|`_bUl)Z(#yB5O^CktcSl#cQ&j>Gy>1;EX zn6)9ChxMjjjJ2G@ol*2Wa~F|#urz(wk9J4Jl>bzBi2VDTA60zJ+pn_4UE(N)ac?uQ z-}-X?9tDPMI^7{wAEM7kKlSOTH`wHt=00(g`V$@t-qanBjRqIxHqn@fU0}axjCsIU zduX!~njIB?oPC~M)8jl_uyxKQ90{5{K`=E(z^%u(mYSYLzx{9ED|b#a@IC2Q)-?B7(%G?t+2w_lze@Q# zwp{?+VOpKt+&IO zD)LVZkDUk&$!W8~B`zc6^ez`|HIIw-6%(UzZJhBpe~PdEKX`NAA?886#`{vtmw5Dx zJjYr!F^D>cR=Mi+;F%@Cqg`e;;%J6jqTq;{<@e&StaXO^V|zv^<9(4 zhWw|!{c^>skEc!n<0)ot`Q0R3gScYh0B_e8TKrm;`T0FRws$>MuKKya5Z->f?)t*7 z<&S>+m}1x^hgR2KTPHlZH*+L(MOnM@6$i2G{$23*Dh_j>H~$JhmR;~~59A-PR7bEB z(;l?dd2`Vf#If2oapKL@?k3yr8rrE&%aRN0d$t`#yYp{AqGtnTK|G%5NWCNRRmy+o%lTZCaK-XBShzI?*0t1mZ&UTEUiCqFtu6QbzK&F{ zdVkY2-~{CfTOPITr_sJ9tNnai?%4JVR4oSZ6H}|NzX$nrzb#0y9zl=O7bP73lIY_LRpO?=6J*w-@nE1&9mS`W)UHxbt zbg$`D#+2_A*1PV4~#-Hzath<&C8n5zc zvQBC>4(<2Chu@s*_~X&tH02ZITq$+znELJ*K-qBGe+r!__xY{oPV~U??yMq=+|*Pvkw5X zOZIroNx)Nv|A8fb5`ERLXv{h?F{Fx3^Y2=n+Nn2~f_+NsU-${Px4}_&6y5@tUt0Y3 z|Bvw7UonhtFIfEY!LN;b%|3oL$PkZyz8uehH-vAn_Z#^S?Ee>h-?RAs1>7FA_+F5O z@0u)pr``Skj&I9vkKV5|m!eC+%luo_+|Ai}p{-c&&HS51@UPZ6$xeerZ zjqN{}U(KE7QTKPWhJyJOK0YoVS7=^Ocl~|jW9W5-rPBalNxqfCd+6%heLqPc`_NaJ zt9-jY_{(}fmcHk&53MV$#X@MIbvKrAYk&KMcSsv+FN9B`;1f+{>%3g1?hv=qtA-sb-IkL}m z_cEZJ)(?8P8OJF4m7jGKI2~E;jW^n*EOO{eAsHbK9^`~>@_UOKIUxA<$hbfGY|XaiKKKE#s7qynch-25zm*U2~XiII!b5M zT{4}SE4OK}bGpfyuxMzp*>hR{;To`q#KCAWd+Qs+NSA&ox$%Ai}Bp&NUBI(ONKc+P~OCSPB8ANSp;e^7U5Oq=G$zt;XBx=e`r#2!7; zJ;%O`HvA9Hl7E^z$-iLC!b39A*D-fjlyZ+x_;Q~5@_!=(6<;si2fwM+H{YxHXG@=* zzx3aDZ9+q2^x|}V1*2RZa%)4@p_}{zZfc!lx*DW>o zZ5?OtBM;m4S3}=v=1(@Gcr}Y*c%L*HZ!F;m9f zU-MmK66_poTIHD0x_B496wab!H(z$|2ibl~&-w@MIfI-UVg5xf@pKLa{G{K$1U&R6 zN_T(qN0Q5LOAB$*$Ev6NzyFhYZu_fUv{yXHaBzRgth338BpDBcJ)I!k_!H zfj2T)N~~NkPa6LVz(MaioH~4cTi`zoxev3Cyp0*+(=!d(J^TOk`OSywZU6V$ z{)4gUZ_vMFz1~EUtS4VbbCAbOaIu*>dcs`;+?Vhly3WPz+3^sPPYKHAb-tASo`#J-DtQ)su3RMYVXVG?5$_QmIilb5c#EX4 zb7Ons{WI!5yw=ZGJBNK+_SYnyorS&kEu zeb>cxAF7z{?CzR-wNWk^`PfB+htY?BZE}3{)ral&LiVR2ii9&&Uzj&L?_}@ zQ?>k?#`pKR(DU@lH|jjuQzW##CH?7 zeiv{WR+T5EBgV-yDm_s;;&o-0k#Aw<3dO7^;2DkOm-c*z-^n$=@clNsD;~9SVJY8K zrv2 z#iKFIVT}auPYnVNzw3j3#QVbUe{4U8xB27Kw-R`^+I`lZ3x(^efhBk<`@>y6Jw%J0 zw2?36Q`Vj4Ky?DRw^+FAEL`zTAF~!p>NyKRu9nsA;!I1p2J1!bRd1K_aRUEMY*L%GJG_R@F5=)1z_ySDuT z%A3JQ{$2H(VC{aYb65D=yld-@?Rdqxv#qAGxNVfXmi$q-;O7}ltobdeyBx>q$UJbk z&>hglJg199(BGZ`ZY5jy4xon5X_nApFTbJRs5rE|1NTF3T^wtd-9zH z__a9K8NOZYmUz;;@bT3PkFu_I*Adq|HaUQ{Gs7k344piq&Gc{bgAKOzkon2|>CK1k z>l~N9&dM6~;pe3qoe-W$%6xwLxI$wSuA8j9NYVCK>+LVS{PmNhd_m{n^dw-bo#fAI zyN2YG=ml>Wc$WXJp}y#Ggf@~{`O2G!Ex0%w^4dB%o1|=%>%l+8$wqigawOrpoM}dl z{QaKgvjM=_4~&3bT3@O=&F$PY)#7&WIr8R$k7)jQhZYgzCX78-OTq1z=C&@ z@Qztmcd|Z(*QLa0D(>kOcxDd$jIr>)5ByhvRZYwd=hcr0Kh4up@;3Hd*As02!aJ9~ zdamm_ON+hF`s-Tw$JsN2b^Qa2XEWt0yUOy2@XOvuWV31>e`DX5SVeu!hF@@94}WFJ_Y{3G#A!i$_c=|FyEi5J``+?Td8}@ylS-{C&N1}z=4YmD@&+2C<{J}-qF5i!M zT=Ov>T8_5)Mg~w{xtvFsH4sgdLHlZWOyiq{{vXhBy@kK`8DcP~d+wLauY3-|=W08@ zPf=fE?rq1+U8dSX)5o((&GBG-0m0hSU(q6a{xo;TqRTRi&s5-xXVpjH->9K!Sa%Q5pEHsBBkBn>9 z_;p5lrp2p<{b?02V|>eG#&vMt95@B__me|Z`I97%r-9$c`F{U3%-cL?ZF0VIC$<51 zet7R?mceNmXIHXWXX6i^fE*s$^mF10g}eIxmc_r6y1&g#-x9#ZPB8lUYZiVkdhwE^Le5%dk(fl-bcH|$UT<-_QS zTz(L^`s?Zaie*+_DZg8;z7t2FJbt1>cK&+JPs@KF?LQ3WNAo5Blg3xoV}5uel{*zW zR~gRyM89-?&bITjfIj^B8UBU&8E)ohIP+7+{FK@GDUNZ@+pPKd2Qxpz&HOBPiA+Oe(k8___6)fuYJ)alrcRj^P*K(Y1PhH%O6{n^jn$suAp-|z4H$B);GSCVJn z)?Rz`FGWMqET6hy}hcq2$?PF=tmHK(c z;sYAXE~1^*L%tx{+gkil+5(w(>a&{t;#$lKT}rYcG%U%Ys|n z{-++c2-dj{pQiTb;PnpY;}HWfxJ>okd_`M&BhC4%F0}nW^+edevrFX8uY)qj-`w1y z$O_F*eh2JU+pnpJPQefGtiz{pseH^sEG}o8{zKcg@T#>qHGlY!IY&gX;phzUu%-9& zXfHgu__jmn4%C5$Vk!1lcc|Y5J95V_XDtudee~)-X@0vBgZ(Lz37Uueh)(Z4Mn2-R z?E0*yT?6+=Lq2u)vF7$TV_tErwLL$ZYLA<>cpy@1?)^MBC?1IN?BF@(!gpKUxZa;x z_%65b{nYAdx%iJ#Cj5tR&VjyeIKHZV403#ep*5|Ac$M=C z@44OcPF_Fvo}Jce_K&m%u@w2l(dovRe8t*7f%#58ZssUCpuOYvk><$!HdHdl8vciG zApL>7CFl1jj#lTcD71FPl2A^(_rn4IHg=${GU61YMqg4c%C`~^+jqEjQcwAp$=Sla ziTxXpXPtskyhC{AoSd!XZ{#LxI3W!m%Wfw&T6;<5@7rURpM>YD{Rs!pe8y4zkZw=j zv+#vh=Qqe*?;6^O#>7)rL2tqV_ShrZd$Gv4cwQvnu1I+>-qO9+Te3Zj-MQkJe7TF; zV}}2XvOG{S%ePUs6)91~2U6YN&o-98{TE-_WMB)bnTwd1>e>gtJ~Tt>Y==kRp54uZFo zcJGJvL|<-u?YDil{m#wdJa?R8zipvRxYt?>_t@r<8w2_rd~Tcepx#MNLC1yA;Sg)T zgl;nAsNSaU5#}v=DuZqo^FFcQRNm2C{Ay1@>lp{T_CpQhAGZ5lv=2h9bDR;ego47ORqTgSA^VINM_)8lT@LlSw zJPMz5cn3E4_-jXB`SZY;X$0jYH|sw`X+90K?XdIFzLrcJ!F&Q^rytNKoUa6)xl#U- zfPJ52&)4(+2S?_fGmZV~dA~g#cxzgl+h?Se%T+!#em8cKX{-bH4v#B`Osc&)E&dj+ z(^l3hq~F%|De3%*DD48~($KBBL}^zNjn*lL3GW@(m3aFTOCnA9pXPR{T=J#4{o=IF zAOXBYxi$Ga`=ot$D78`h>aXYDX&AINf+@vYAsQoTc+FJuyu{4?bn?xk*X6P1v9>Pk zLs9$?_pt7Z+b>EJ^JMgeQs5FUG*{&!Qh$O?{qZgPAAHk()Zf^XR_J`Hx;vpk`E$eX z1Nh?Iw64MaT&-V6HuT@BzSc-MZl<4*M~82Pi)Tx(md#S@Ct3~TD{eSG17Ei1ZB?7B zIc-9pD)E8(R*^*^TMZaC>#st4cOCF zr-O3gnZJ+V8{_}TP3Y9{sH&{&?5Qc?`b%!z=jq?w$H(L2S=IhvhW+-q?jEtXHmqXq z%0)MfWERTPE?D$m_`=G9|M@)cD)lPRI zuCa3T>OY0;X46LUVIOiKlo4xJh@OB89ZGS)C(B0RT~xcdW7 z-M#te+#3;p3$TX>Hu|%CdQGN22PVOjdW`ra;L&<(T&;`F9~#@irt!6I+8eVNw*j8E zfd9868*YNHv7VXvMy@=cX~M7SbkSMf(<|hY{^V8T@Xb{nxy`-@Fb&)Zf2EAAyLCh9 zLv^`VS=YiI(K;?;kEq{^f)3@jGkR{Z_dGm1yt{Q5<5Y4FYCPu+<;&DLwfY4mAWexYfZA=mAvy4tBRTaCwb9VoqRnX`MePMd@cP5uAx@W%%>m4qjlbQcczs5 zarmL@eBiqk*k%%=?b@Ta_DT=v`&vjZ)wZ2@uKZ3n6olV-ueo(NW$NQn`q2Ay8gH8& z@4X+ui=jtnOF%d6k9||UZ(6(gPE+sX_&1eLTosO!rCj!qkXB#&}3 z!TC%-j0ZMIu71n@t#z$8F_)sB0~`L^3*lNsJMDMTq4Wj^zy2;`&#BK=VE!uoXgr-s zMdwQ`eOKG|Ixkh;-oElMdbq+g9G9Si=v&iA6d{|j56>N!1JuG9arpb^{II`e)DzBQ7T6DJQhx{s(k%}4Cxklp;v2a$?#@PibnWy}`!qKPt-vc={xIZt$-D#$;uWQ2F3E$#8!-n}j<%=x0?%ci1$a;Ey2=i@k*#1NzlI z*ShHr-l2P3*{S1kM^oSF%o<<5iT?)g;kqjqYq;+JZToq3-PWVhf3zMi@w?U{#LGP! z7q{FE?gnJ8;>_SPe2eag_2V&|Lx{(PN6rODvgt4%gCoJN{)#M~7BL3+M31S0cZP2_ z>8<&nT6m^WE*uCKYIpn(;e0RUyXaZ-$lAJ5zDWj29u3H$5Vx9-M>*?{-E)AxBzwYn z#4-iU!{zw|o(z64&Mzm!{p)Xr<3I7p)}wy{?!o-d=|08yUBdJ9Ti6@s_D;0zkfrN1 zkGp8Ea@lG1_qmo{qv#+}{Qn;I%GuQE>x=d*i8KbhLx8z9F!^cni)NAMtU0MTwrD@z z<0qA=&ktkAkbb8A)Q9ZRT7Q-4n|PUz{;W8KGWOO(MlSu1wc5Sz^OnCmzA$*6JJ)L8 zhqx{9g6E{qM$sqqp0@lO?rn$?V03RoU{~pX8)B%@W5fEgN9SQfpO5|JJ>Gi=`)M+H zq4VwccloZjJ9sCjry-)4S=qJjVZ21Jlkc28TYdbS{Opw8sJ~-5f1C9OW@jG~9V3H8 zCmW@6hz`VSN{LsI-$DBV|LkAA2kZD3_w&*kkM^C!8Q^DFxMDm!VXSw%vG<-4ZKxaK z9Y`E{H>96CI|lgH5cmYTMw@7+`cO-qyJs-OpBg{IuddzF|AxYWbph=JqxkGA*oUOs zYY!Z_JM33?4z#}KQSUtLH6!@{0{AiW=bO&Un!Dz!dOCY3KE58E%uC>Za+R}zpdgMx zGj63fF5_`OFkG9%_^c-OB<)#9G%b8g;%~(Qj%Lo4{MS2&+yCyJBhuS}IURV9tX zcaKJIGfwa)_CED@iur$sHz*DyHgf()&SjT=FT}&nHAYW@H;rj~3H&GqT6qAjvvM|K z`4O?ft+M5>r#|nTq5p;VJ8Ix-*T#%@jmUXde-_ji{}$3qCJafGnM|Jw=VTV zyi|8RIDUmT#Ml^p^p;mbcrK@|)|0V-X+T~G9|cDKRk!B(b9-vNv6JE^p2y*TKrh#M zLAn@tMQ_)e?^Tv>po4>tIV;=w9`4Jk z&X6w;@Z)C6#EV5=+J}|AmFMKW=s~oAzoj*#1KBhWn{{qBa`)zyek4jRf`+MiMdiU4 zS^ICZUqk)q-NdIXzb$19=~tY$vfqZz#c#W88TQJ|;qQj;-@)foe^0+328X^MCC_*) zrMG}ZSJ;cYlbqE=-+Aaxg7Vsd0_%^8b5H?Uq` zLbfFFFOIS>eaFHyoBni`4CAXxd&~TxCJ)w&ciHvN8Se{>mxM0g)Em#h@NMfuNRk_W z1oarxl$H4x#lLRLj(tbp!8 z-oG*O^3?R^WQD^)QtwKzew=5>aZCJisBvDckb*3({iy~);baIZ;>>%G{vfAZw^hHu|(;hRr;jj`F*(f+IFo9?Aa zW;y<-{o#0|cy|MPP`*9g1<-m;xBU&Lt$2#y*FECU{yz~JeSYud+;RO>|Jo199{g6A zH(L5}7yHBW9^6>(4KZ~7Ew}#EDd+55?~QF+jITiSF~ycuqL+43&iw*&pIT@766Smw z^>sgEKn4u(Ao!2D_wDe>ct-xfw~btS-S$0=epROR{2L4Nc)r!xZx`8bqg9WwR8RL4 zF0|i8E5eI|BbR1MO+O(V$b{pnH;wmU#a~1EIbiNl==+(rzo%9!zCDzuTljsjK9RdV z;%SoA;$Pxjl3f?VW03VG4r#Rb82DB!&UY*wqIb5Q=T$vGj@-m-`p@&?@$$$u#xGS4 zkK?`9+A{C4%(%11OcGBz!y8wtxD(nuE;t)4oMqfU98P=jGxaGRp}0HU6<58L){mgF zgWuF$(J}HlKX$6Mvhw1j^`iguTRHR`;_Fc2`LBljLVAbBkq)AD`JjH=8C&~I^e~^8 z5w#Ib82YEooj*kXPG6%hqqD1SDYj7IQ}?I%-Q)z}Ji?qyjQr91Yt5sB=uP{<^Yw1b z{te)+)AP?a^!`N)zwr0+H^O~!5M5KUTX24gSbxpwl>T4pJ9xGBI#%Kxuq&#@X#3`I+ z_Q?V_2kP(+-v;-NPVO2E#)t5|>!J7iQylyg4eV8|f~5v|*s?2@6#Zd`PmZc;z|Yng zD6Y`_UDv?9l*T~!6w6lxp-b&@ks`bi|UZ)>(b=cc*OJf=4#-6z3(~)5E@D_=lTofDTkPXzfK`qZnKD zmD6vj-yC?v=lv`9Xx{Co>0O(1=^Oo^b?|-DE$zau?rqkj#Rnt@wa!}ma^Ms%Q0%Vw zb&DToj5(Xd3&giWJ@ya4+n9kLZ;#Vfc4p0&bKSO(FC0ibWaaiG#+nX4*F6o*nfpzF z@UNIc?XS^QdIzf|P>yu@XGWPdnE!vY2I~K6yAF~eJHH;vrVjy^@<|N!Z;i`GEM6ks zbDIBn{Cevz)Vq&rFMKJc{kyakUUW7xwCb0GhemXvQ|k#%E|~pKTb&Pbd8)&&)d@GC z!yd8G3bPe%+xpODR5MNJq z*7Fu+bK44MuC3#T0kDeBL|=n(B76v*(C;t$>Pujsde+@jeT8$6%5SuM|GlqmJ&I4G z%jYd|;$@c94?Rr0+WF5qd%3gcYi@(*<<`ix6MVuOXY%dJ2O_?v7%uENreE;5-Hkul zj(;cPGamOsL`Me_f8&phSA$En5uH!tzhH{scNspYzp|YE#@YTxhy9^HR;6^uC?6iH zzW)t=UFr=D{;luf9S)wC+2g8%gR)@3gzK4`o5YuQNQi)e9!nxuk@qaS9^2X z#aV^}iF=Pojs;q|KLEqh+BTD!qg`g}E=qXBv&nE5`0}48A2jQM|DXeyer< zw=akN=qy`GKf@T4`5Qmr?ch(mPdvx@;~{l&Q13QxF6E&HqDQ9-{GYQ|Bg}oNiA9@7 zyMP$ge8!L-E&kogycc`iqw<#qDes=_Z!I6-TbjSql&9NQiht-XP=0nfZ&)lN7Pg2! z-axK0Pb0ImSH=JS*}^Sfw&pRDw)lZI3m(raY{OQveG0h>B_mb7(biY|;b`iTGr^pf z6_@%a&e6=@^uNy5JJu$3t6FZtBC?_vA(A*qD{Z|j zb?_~kF;s7b{oc;^`ke1e?f1L%9okbr_t_!jz4{F8K+Tz*~ z=iNhzdoA99C3_zI{TRAwrjGXI+4!$Gj~o|%ljOM9eAy?~9{V=@t?I}+YnOjD!&>1d zQ@ekp56S1D$aOzboBV@`$++0u`IW41X6;oE`P=WGI+ydsan5RPJwN?mNQYX_W%TXV zd!n7Y=xGt(@5jE^p0gj}Eyj*tXXgbjvy-T&@s+1csI!uv#9?>y@0e5!hX zPd({*W#nC7W$!H=UmU{IK!5M0Lz(&;_>k)3@BW4OpULa!FN&*w+4q%O{6gD*12p{< z?P?=4j9t(77ZHD;v%b&0;q%SD<{aDAz`TmROZb1=ktP15ICu6p7qWjt-0MB|#v{4! zv1|X{≀*7ZdT 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 literal 0 HcmV?d00001 -- Gitee From cbf1d0251f2f07407c1af81f74e8b62d8c529d34 Mon Sep 17 00:00:00 2001 From: lanruo Date: Thu, 17 Aug 2023 16:49:48 +0800 Subject: [PATCH 2/2] remove the grub parameter rb.lvm.lv=ko/backup for sw --- grub2.spec | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/grub2.spec b/grub2.spec index 569f54b..4da789b 100644 --- a/grub2.spec +++ b/grub2.spec @@ -496,13 +496,13 @@ mv ${EFI_HOME}/grub.cfg.stb ${EFI_HOME}/grub.cfg %{_datadir}/man/man* %changelog -* Thu Apr 03 2023 majinhao - 1:2.06-27.kb17 +* Mon Apr 03 2023 majinhao - 1:2.06-27.kb17 - KYOS-F: remove the grub parameter "rb.lvm.lv=ko/backup" for sw -* Wed Apr 02 2023 majinhao - 1:2.06-27.kb16 +* Sun Apr 02 2023 majinhao - 1:2.06-27.kb16 - KYOS-F: add the grub parameter crashkernel=512M for sw -* Tue Apr 01 2023 majinhao - 1:2.06-27.kb15 +* Sat Apr 01 2023 majinhao - 1:2.06-27.kb15 - KYOS-F: optimize backup and restore configuration files (#9159) * Fri Jul 28 2023 majinhao - 1:2.06-27.kb14 -- Gitee