1.0.33 release

F5 ---> Keyboard Layouts

BUSYBOX/build.txt

@@ -0,0 +1,36 @@
+======== How to build ash/hexdump/xzcat for aarch64 ======== 
+#How to get ash.config/hexdump.cofig/xzcat.config
+#ARCH=arm64 CROSS_COMPILE=aarch64-linux- make allnoconfig
+#ARCH=arm64 CROSS_COMPILE=aarch64-linux- make menuconfig 
+#----> enable static build
+#----> enable xzcat
+#get aarch64_xzcat.config
+
+tar xf busybox-1.32.0.tar.bz2
+cd busybox-1.32.0
+copy aarch64_xzcat.config as .config
+ARCH=arm64 CROSS_COMPILE=aarch64-linux- make 
+rename ./busybox to xzcat
+
+
+
+======== How to build ash/hexdump/xzcat for x86_64 ==========
+#How to get ash.config/hexdump.cofig/xzcat.config
+#make allnoconfig
+#make menuconfig 
+#----> enable static build
+#----> enable xzcat
+#get x86_64_xzcat.config
+
+
+tar xf busybox-1.32.0.tar.bz2
+cd busybox-1.32.0
+copy x86_64_xzcat.config as .config
+modify Makefile
+CC		= gcc -specs "/usr/local/musl/lib/musl-gcc.specs"
+MODFLAGS	= -DMODULE -specs "/usr/local/musl/lib/musl-gcc.specs"
+make
+rename ./busybox to xzcat
+
+
+

BUSYBOX/chmod/build.sh

@@ -2,17 +2,24 @@
 
 DSTDIR=../../IMG/cpio/ventoy/busybox
 
-rm -f vtchmod32 vtchmod64
-rm -f $DSTDIR/vtchmod32 $DSTDIR/vtchmod64
+rm -f vtchmod32 vtchmod64 vtchmod64_musl vtchmodaa64
+rm -f $DSTDIR/vtchmod32 $DSTDIR/vtchmod64 $DSTDIR/vtchmodaa64
 
 /opt/diet32/bin/diet  gcc  -Os -m32  vtchmod.c -o  vtchmod32
 /opt/diet64/bin/diet  gcc  -Os       vtchmod.c -o  vtchmod64
+aarch64-linux-gcc -Os -static vtchmod.c -o  vtchmodaa64
+aarch64-linux-strip --strip-all vtchmodaa64
+
+gcc -specs "/usr/local/musl/lib/musl-gcc.specs" -Os -static vtchmod.c -o  vtchmod64_musl
+strip --strip-all vtchmod64_musl
 
 chmod 777 vtchmod32
 chmod 777 vtchmod64
+chmod 777 vtchmodaa64
+chmod 777 vtchmod64_musl
 
 cp -a vtchmod32 $DSTDIR/
 cp -a vtchmod64 $DSTDIR/
-
-
+cp -a vtchmodaa64 $DSTDIR/
+cp -a vtchmod64_musl $DSTDIR/
 

DMSETUP/build.txt

@@ -36,14 +36,25 @@ build for 32bit, static linked with dietlibc
 
 
 ======================== Build for 64bit dmsetup =========================
-https://www.uclibc.org/downloads/binaries/0.9.30.1/mini-native-x86_64.tar.bz2
 1. extract device mapper source code
-2. extract mini-native-x86_64.tar.bz2
-3. chroot to mini-native-x86_64
-3. ./configure --disable-nls  --disable-selinux --disable-shared  --enable-static_link
+2. ./configure --disable-nls  --disable-selinux --disable-shared  --enable-static_link CC='gcc -specs /usr/local/musl/lib/musl-gcc.specs'
+3. touch include/linux/limits.h include/linux/types.h   
+   echo '#include <sys/mount.h>' > include/linux/fs.h
 4. make
-5. strip dmsetup/dmsetup.static
+5. strip --strip-all dmsetup/dmsetup.static
 6. get dmsetup/dmsetup.static as the dmsetup64 binary file
 
 
+======================== Build for arm64 dmsetup =========================
+1. extract device mapper source code
+2. ./configure CC=aarch64-linux-gcc --target=arm --host=x86_64-linux-gnu --disable-nls  --disable-selinux --disable-shared  --enable-static_link
+3. modify include/configure.h file
+   --- delete the line with "#define malloc rpl_malloc"
+4. make
+5. aarch64-linux-strip dmsetup/dmsetup.static
+6. get dmsetup/dmsetup.static as the dmsetupaa64 binary file
+
+
+
+
 

DOC/BuildVentoyFromSource.txt

@@ -3,7 +3,7 @@
 1. Compile Enviroment
 ==========================================
     My build envrioment is CentOS 7.8 x86_64. So here I first explain how to create the build environment from scratch.
-    Because Ventoy is based on many open source projects, so the envrioment is important. I suggest you test it on a virtual machine first.
+    Because Ventoy is based on many open source projects, so the environment is important. I suggest you test it on a virtual machine first.
 
 1.1 Install CentOS 7.8
     I use CentOS-7-x86_64-Everything-2003.iso and select Minimal install
@@ -27,11 +27,26 @@
 2.2 Download third-part source code
     
     https://www.fefe.de/dietlibc/dietlibc-0.34.tar.xz                    ===>  /home/Ventoy-master/DOC/dietlibc-0.34.tar.xz
+    https://musl.libc.org/releases/musl-1.2.1.tar.gz                     ===>  /home/Ventoy-master/DOC/musl-1.2.1.tar.gz
     https://ftp.gnu.org/gnu/grub/grub-2.04.tar.xz                        ===>  /home/Ventoy-master/GRUB2/grub-2.04.tar.xz
     https://codeload.github.com/tianocore/edk2/zip/edk2-stable201911     ===>  /home/Ventoy-master/EDK2/edk2-edk2-stable201911.zip
     https://codeload.github.com/relan/exfat/zip/v1.3.0                   ===>  /home/Ventoy-master/ExFAT/exfat-1.3.0.zip
     https://codeload.github.com/libfuse/libfuse/zip/fuse-2.9.9           ===>  /home/Ventoy-master/ExFAT/libfuse-fuse-2.9.9.zip
+    https://releases.linaro.org/components/toolchain/binaries/7.4-2019.02/aarch64-linux-gnu/gcc-linaro-7.4.1-2019.02-x86_64_aarch64-linux-gnu.tar.xz           ===>  /opt/gcc-linaro-7.4.1-2019.02-x86_64_aarch64-linux-gnu.tar.xz
+    https://toolchains.bootlin.com/downloads/releases/toolchains/aarch64/tarballs/aarch64--uclibc--stable-2020.08-1.tar.bz2 ===> /opt/aarch64--uclibc--stable-2020.08-1.tar.bz2
 
+2.3 Prepare third-part tools
+    cd /home/Ventoy-master/DOC/
+    tar xf musl-1.2.1.tar.gz
+    cd musl-1.2.1
+    ./configure && make install
+
+    tar xf /opt/gcc-linaro-7.4.1-2019.02-x86_64_aarch64-linux-gnu.tar.xz  -C /opt
+    tar xf /opt/aarch64--uclibc--stable-2020.08-1.tar.bz2  -C /opt
+
+2.4 Set PATH envrioment
+    export PATH=$PATH:/opt/gcc-linaro-7.4.1-2019.02-x86_64_aarch64-linux-gnu/bin:/opt/aarch64--uclibc--stable-2020.08-1/bin
+    better to add this line to /root/.bashrc and relogin as root
 
 
 ==========================================
@@ -144,7 +159,7 @@
 4.18 IMG/cpio/ventoy/busybox/64h
   https://www.uclibc.org/downloads/binaries/0.9.30.1/mini-native-x86_64.tar.bz2
   https://busybox.net/downloads/busybox-1.32.0.tar.bz2
-  use BUSYBOX/64h.config and uclibc to build busybox-1.32
+  use BUSYBOX/x86_64_ash.config and uclibc to build busybox-1.32
 
 4.19 == Build lunzip32/lunzip64 ==
   http://mirror.yongbok.net/nongnu/lzip/lunzip/lunzip-1.11.tar.gz
@@ -153,6 +168,11 @@
   make
   strip --strip-all lunzip
   
+  #aarch64
+  ./configure --disable-nls CC='aarch64-buildroot-linux-uclibc-gcc -static'
+  make
+  aarch64-buildroot-linux-uclibc-strip --strip-all lunzip
+
 
 
 ==========================================
@@ -181,11 +201,11 @@
   https://busybox.net/downloads/binaries/1.27.1-i686   busybox_XZ
   SHA-256: f6cdb6293680424c29b89bde0685ca27f455166c9b302cd6082ef90681456291  
 
-5.6 INSTALL/tool/xzcat
+5.6 INSTALL/tool/i386/xzcat
   https://busybox.net/downloads/binaries/1.30.0-i686/   busybox_XZCAT
   SHA-256: 7399db642c2beaf52a16ab5264ffc55cfd1ff5699a524f63e5d48edf84e20f44  
   
-5.7 INSTALL/tool/hexdump
+5.7 INSTALL/tool/i386/hexdump
   https://busybox.net/downloads/binaries/1.30.0-i686/   busybox_HEXDUMP
   SHA-256: cde08b6a2cf5ad914f05203e18e3f7c2ed6060a63604e3d75536f19b55e8e0af  
 

EDK2/build.sh

@@ -0,0 +1,59 @@
+#!/bin/sh
+
+if [ -z "$1" ]; then
+    EDKARCH=X64
+    postfix=x64
+elif [ "$1" = "ia32" ]; then
+    EDKARCH=IA32
+    postfix=ia32
+    shift
+elif [ "$1" = "aa64" ]; then
+    EDKARCH=AARCH64
+    postfix=aa64
+    shift
+fi
+
+cd edk2-edk2-stable201911
+
+rm -rf ./Conf/.cache
+rm -f ./Conf/.AutoGenIdFile.txt
+
+VTEFI_PATH=Build/MdeModule/RELEASE_GCC48/$EDKARCH/MdeModulePkg/Application/Ventoy/Ventoy/OUTPUT/Ventoy.efi
+DST_PATH=../../INSTALL/ventoy/ventoy_${postfix}.efi
+
+VTEFI_PATH2=Build/MdeModule/RELEASE_GCC48/$EDKARCH/MdeModulePkg/Application/VtoyUtil/VtoyUtil/OUTPUT/VtoyUtil.efi
+DST_PATH2=../../INSTALL/ventoy/vtoyutil_${postfix}.efi
+
+VTEFI_PATH3=Build/MdeModule/RELEASE_GCC48/$EDKARCH/MdeModulePkg/Application/VDiskChain/VDiskChain/OUTPUT/VDiskChain.efi
+DST_PATH3=../../VDiskChain/Tool/vdiskchain_${postfix}.efi
+
+
+rm -f $VTEFI_PATH
+rm -f $DST_PATH
+rm -f $VTEFI_PATH2
+rm -f $DST_PATH2
+rm -f $VTEFI_PATH3
+rm -f $DST_PATH3
+
+source ./edksetup.sh
+
+if [ "$EDKARCH" = "AARCH64" ]; then    
+    PATH=$PATH:/opt/gcc-linaro-7.4.1-2019.02-x86_64_aarch64-linux-gnu/bin \
+    GCC48_AARCH64_PREFIX=aarch64-linux-gnu- \
+    build -p MdeModulePkg/MdeModulePkg.dsc -a $EDKARCH -b RELEASE -t GCC48
+else
+    build -p MdeModulePkg/MdeModulePkg.dsc -a $EDKARCH -b RELEASE -t GCC48
+fi
+
+if [ -e $VTEFI_PATH ] && [ -e $VTEFI_PATH2 ] && [ -e $VTEFI_PATH3 ]; then
+    echo -e '\n\n====================== SUCCESS ========================\n\n'    
+    cp -a $VTEFI_PATH $DST_PATH
+    cp -a $VTEFI_PATH2 $DST_PATH2
+    cp -a $VTEFI_PATH3 $DST_PATH3
+    cd ..
+else
+    echo -e '\n\n====================== FAILED ========================\n\n'
+    cd ..
+    exit 1
+fi
+

EDK2/buildedk.sh

@@ -11,17 +11,24 @@ cd edk2-edk2-stable201911
 VTEFI_PATH=Build/MdeModule/RELEASE_GCC48/X64/MdeModulePkg/Application/Ventoy/Ventoy/OUTPUT/Ventoy.efi
 DST_PATH=../../INSTALL/ventoy/ventoy_x64.efi
 
+VTEFI_PATH2=Build/MdeModule/RELEASE_GCC48/IA32/MdeModulePkg/Application/Ventoy/Ventoy/OUTPUT/Ventoy.efi
+DST_PATH2=../../INSTALL/ventoy/ventoy_ia32.efi
+
 rm -f $VTEFI_PATH
 rm -f $DST_PATH
+rm -f $VTEFI_PATH2
+rm -f $DST_PATH2
 
 make -j 4 -C BaseTools/
 
 source ./edksetup.sh
 build -p MdeModulePkg/MdeModulePkg.dsc -a  X64 -b RELEASE -t GCC48
+build -p MdeModulePkg/MdeModulePkg.dsc -a IA32 -b RELEASE -t GCC48
 
-if [ -e $VTEFI_PATH ]; then
+if [ -e $VTEFI_PATH ] && [ -e $VTEFI_PATH2 ]; then
     echo -e '\n\n====================== SUCCESS ========================\n\n'    
     cp -a $VTEFI_PATH  $DST_PATH
+    cp -a $VTEFI_PATH2 $DST_PATH2
     cd ..
 else
     echo -e '\n\n====================== FAILED ========================\n\n'

EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/VDiskChain/VDiskChain.c

@@ -0,0 +1,410 @@
+/******************************************************************************
+ * VDiskChain.c
+ *
+ * Copyright (c) 2021, longpanda <admin@ventoy.net>
+ *
+ * This program 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.
+ * 
+ * This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <Uefi.h>
+#include <Library/DebugLib.h>
+#include <Library/PrintLib.h>
+#include <Library/UefiLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DevicePathLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/UefiRuntimeServicesTableLib.h>
+#include <Library/UefiApplicationEntryPoint.h>
+#include <Library/UefiDecompressLib.h>
+#include <Protocol/LoadedImage.h>
+#include <Guid/FileInfo.h>
+#include <Guid/FileSystemInfo.h>
+#include <Protocol/BlockIo.h>
+#include <Protocol/RamDisk.h>
+#include <Protocol/SimpleFileSystem.h>
+#include <VDiskChain.h>
+
+BOOLEAN gVDiskDebugPrint = FALSE;
+vdisk_block_data gVDiskBlockData;
+
+/* Boot filename */
+CONST CHAR16 *gEfiBootFileName[] = 
+{
+    L"@",
+    EFI_REMOVABLE_MEDIA_FILE_NAME,
+#if   defined (MDE_CPU_IA32)
+    L"\\EFI\\BOOT\\GRUBIA32.EFI",
+    L"\\EFI\\BOOT\\BOOTia32.EFI",
+    L"\\EFI\\BOOT\\bootia32.efi",
+    L"\\efi\\boot\\bootia32.efi",
+#elif defined (MDE_CPU_X64)
+    L"\\EFI\\BOOT\\GRUBX64.EFI",
+    L"\\EFI\\BOOT\\BOOTx64.EFI",
+    L"\\EFI\\BOOT\\bootx64.efi",
+    L"\\efi\\boot\\bootx64.efi",
+#elif defined (MDE_CPU_ARM)
+    L"\\EFI\\BOOT\\GRUBARM.EFI",
+    L"\\EFI\\BOOT\\BOOTarm.EFI",
+    L"\\EFI\\BOOT\\bootarm.efi",
+    L"\\efi\\boot\\bootarm.efi",
+#elif defined (MDE_CPU_AARCH64)
+    L"\\EFI\\BOOT\\GRUBAA64.EFI",
+    L"\\EFI\\BOOT\\BOOTaa64.EFI",
+    L"\\EFI\\BOOT\\bootaa64.efi",
+    L"\\efi\\boot\\bootaa64.efi",
+#endif
+    
+};
+
+UINT8 *g_disk_buf_addr = NULL;
+UINT64 g_disk_buf_size = 0;
+        
+VOID EFIAPI VDiskDebug(IN CONST CHAR8  *Format, ...)
+{
+    VA_LIST  Marker;
+    CHAR16   Buffer[512];
+
+    VA_START (Marker, Format);
+    UnicodeVSPrintAsciiFormat(Buffer, sizeof(Buffer), Format, Marker);
+    VA_END (Marker);
+    
+    gST->ConOut->OutputString(gST->ConOut, Buffer);
+}
+
+VOID EFIAPI vdisk_clear_input(VOID)
+{
+    EFI_INPUT_KEY Key;
+    
+    gST->ConIn->Reset(gST->ConIn, FALSE);
+    while (EFI_SUCCESS == gST->ConIn->ReadKeyStroke(gST->ConIn, &Key))
+    {
+        ;
+    }
+    gST->ConIn->Reset(gST->ConIn, FALSE);
+}
+
+STATIC EFI_STATUS EFIAPI vdisk_load_image
+(
+    IN EFI_HANDLE ImageHandle,
+    IN EFI_DEVICE_PATH_PROTOCOL *pDevicePath,
+    IN CONST CHAR16 *FileName,
+    IN UINTN FileNameLen,
+    OUT EFI_HANDLE *Image
+)
+{
+    EFI_STATUS Status = EFI_SUCCESS;
+    CHAR16 TmpBuf[256] = {0};
+    FILEPATH_DEVICE_PATH *pFilePath = NULL;
+    EFI_DEVICE_PATH_PROTOCOL *pImgPath = NULL;
+
+    pFilePath = (FILEPATH_DEVICE_PATH *)TmpBuf;
+    pFilePath->Header.Type = MEDIA_DEVICE_PATH;
+    pFilePath->Header.SubType = MEDIA_FILEPATH_DP;
+    pFilePath->Header.Length[0] = FileNameLen + sizeof(EFI_DEVICE_PATH_PROTOCOL);
+    pFilePath->Header.Length[1] = 0;
+    CopyMem(pFilePath->PathName, FileName, FileNameLen);
+    
+    pImgPath = AppendDevicePathNode(pDevicePath, (EFI_DEVICE_PATH_PROTOCOL *)pFilePath);
+    if (!pImgPath)
+    {
+        return EFI_NOT_FOUND;
+    }
+    
+    Status = gBS->LoadImage(FALSE, ImageHandle, pImgPath, NULL, 0, Image);
+    
+    debug("Load Image File %r DP: <%s>", Status, ConvertDevicePathToText(pImgPath, FALSE, FALSE));
+
+    FreePool(pImgPath);
+    
+    return Status;
+}
+
+STATIC EFI_STATUS EFIAPI vdisk_decompress_vdisk(IN EFI_LOADED_IMAGE_PROTOCOL *pImageInfo)
+{
+    UINT32 Size;
+    UINT32 DestinationSize;
+    UINT32 ScratchSize;
+    UINT8 *buf;
+    VOID  *ScratchBuf;
+    EFI_STATUS Status = EFI_SUCCESS;
+
+    (VOID)pImageInfo;
+
+    vdisk_get_vdisk_raw(&buf, &Size);
+    UefiDecompressGetInfo(buf + VDISK_MAGIC_LEN, Size - VDISK_MAGIC_LEN, &DestinationSize, &ScratchSize);
+    debug("vdisk: size:%u realsize:%u", Size, DestinationSize);
+
+    g_disk_buf_size = DestinationSize;
+    g_disk_buf_addr = AllocatePool(DestinationSize);
+    ScratchBuf = AllocatePool(ScratchSize);
+    
+    Status = UefiDecompress(buf + VDISK_MAGIC_LEN, g_disk_buf_addr, ScratchBuf);
+    FreePool(ScratchBuf);
+
+    debug("Status:%r %p %u", Status, g_disk_buf_addr, (UINT32)g_disk_buf_size);
+    
+    return EFI_SUCCESS;
+}
+
+STATIC EFI_STATUS vdisk_patch_vdisk_path(CHAR16 *pos)
+{
+    UINTN i;
+    UINTN j;
+    CHAR16 *end;
+    CHAR8 *buf = (char *)g_disk_buf_addr;
+    
+    if (*pos == L'\"')
+    {
+        pos++;
+    }
+
+    end = StrStr(pos, L".vtoy");
+    end += 5;//string length
+    
+    for (i = 0; i < g_disk_buf_size; i++)
+    {
+        if (*(UINT32 *)(buf + i) == 0x59595959)
+        {
+            for (j = 0; j < 300; j++)
+            {
+                if (buf[i + j] != 'Y')
+                {
+                    break;
+                }
+            }
+
+            if (j >= 300)
+            {
+                break; 
+            }
+        }
+    }
+
+    if (i >= g_disk_buf_size)
+    {
+        debug("No need to fill vdisk path");
+        return 0;
+    }
+
+    debug("Fill vdisk path at %d", i);        
+
+    while (pos != end)
+    {
+        buf[i++] = (CHAR8)(*pos++);
+    }
+
+    buf[i++] = '\"';
+    
+    while (buf[i] == 'Y' || buf[i] == '\"')
+    {
+        buf[i] = ' ';
+        i++;
+    }   
+
+    return 0;    
+}
+
+STATIC EFI_STATUS EFIAPI vdisk_parse_cmdline(IN EFI_HANDLE ImageHandle)
+{   
+    CHAR16 *Pos = NULL;
+    CHAR16 *pCmdLine = NULL;
+    EFI_STATUS Status = EFI_SUCCESS;
+    EFI_LOADED_IMAGE_PROTOCOL *pImageInfo = NULL;
+
+    Status = gBS->HandleProtocol(ImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **)&pImageInfo);
+    if (EFI_ERROR(Status))
+    {
+        VDiskDebug("Failed to handle load image protocol %r\n", Status);
+        return Status;
+    }
+
+    pCmdLine = (CHAR16 *)AllocatePool(pImageInfo->LoadOptionsSize + 4);
+    SetMem(pCmdLine, pImageInfo->LoadOptionsSize + 4, 0);
+    CopyMem(pCmdLine, pImageInfo->LoadOptions, pImageInfo->LoadOptionsSize);
+
+    if (StrStr(pCmdLine, L"debug"))
+    {
+        gVDiskDebugPrint = TRUE;
+    }
+    
+    debug("cmdline:<%s>", pCmdLine);
+    vdisk_debug_pause();
+
+    Pos = StrStr(pCmdLine, L"vdisk=");
+    if (NULL == Pos || NULL == StrStr(pCmdLine, L".vtoy"))
+    {
+        VDiskDebug("vdisk parameter not found!\n");
+        return EFI_NOT_FOUND;
+    }
+
+    vdisk_decompress_vdisk(pImageInfo);
+
+    vdisk_patch_vdisk_path(Pos + 6);
+
+    FreePool(pCmdLine);
+    return EFI_SUCCESS;
+}
+
+EFI_STATUS EFIAPI vdisk_boot(IN EFI_HANDLE ImageHandle)
+{
+    UINTN t = 0;
+    UINTN i = 0;
+    UINTN j = 0;
+    UINTN Find = 0;
+    UINTN Count = 0;
+    EFI_HANDLE Image = NULL;
+    EFI_HANDLE *Handles = NULL;
+    EFI_STATUS Status = EFI_SUCCESS;
+    EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *pFile = NULL;
+    EFI_DEVICE_PATH_PROTOCOL *pDevPath = NULL;
+
+    for (t = 0; t < 3; t++)
+    {
+        Count = 0;
+        Handles = NULL;
+
+        Status = gBS->LocateHandleBuffer(ByProtocol, &gEfiSimpleFileSystemProtocolGuid, 
+                                     NULL, &Count, &Handles);
+        if (EFI_ERROR(Status))
+        {
+            return Status;
+        }
+
+        debug("vdisk_boot fs count:%u", Count);
+
+        for (i = 0; i < Count; i++)
+        {
+            Status = gBS->HandleProtocol(Handles[i], &gEfiSimpleFileSystemProtocolGuid, (VOID **)&pFile);
+            if (EFI_ERROR(Status))
+            {
+                continue;
+            }
+
+            debug("FS:%u Protocol:%p  OpenVolume:%p", i, pFile, pFile->OpenVolume);
+
+            Status = gBS->OpenProtocol(Handles[i], &gEfiDevicePathProtocolGuid, 
+                                       (VOID **)&pDevPath,
+                                       ImageHandle,
+                                       Handles[i],
+                                       EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+            if (EFI_ERROR(Status))
+            {
+                debug("Failed to open device path protocol %r", Status);
+                continue;
+            }
+
+            debug("Handle:%p FS DP: <%s>", Handles[i], ConvertDevicePathToText(pDevPath, FALSE, FALSE));
+            if (CompareMem(gVDiskBlockData.Path, pDevPath, gVDiskBlockData.DevicePathCompareLen))
+            {
+                debug("Not ventoy disk file system");
+                continue;
+            }
+
+            for (j = 1; j < ARRAY_SIZE(gEfiBootFileName); j++)
+            {
+                Status = vdisk_load_image(ImageHandle, pDevPath, gEfiBootFileName[j], 
+                                           StrSize(gEfiBootFileName[j]), &Image);
+                if (EFI_SUCCESS == Status)
+                {
+                    break;
+                }
+                debug("Failed to load image %r <%s>", Status, gEfiBootFileName[j]);
+            }
+
+            if (j >= ARRAY_SIZE(gEfiBootFileName))
+            {
+                continue;
+            }
+
+            Find++;
+            debug("Find boot file, now try to boot .....");
+            vdisk_debug_pause();
+
+            if (gVDiskDebugPrint)
+            {
+                gST->ConIn->Reset(gST->ConIn, FALSE);
+            }
+
+            /* can't add debug print here */
+            //ventoy_wrapper_system();
+            Status = gBS->StartImage(Image, NULL, NULL);
+            if (EFI_ERROR(Status))
+            {
+                debug("Failed to start image %r", Status);
+                sleep(3);
+                gBS->UnloadImage(Image);
+                break;
+            }
+        }
+
+        FreePool(Handles);
+
+        if (Find == 0)
+        {
+            debug("Fs not found, now wait and retry...");
+            sleep(2);
+        }
+    }
+
+    if (Find == 0)
+    {
+        return EFI_NOT_FOUND;
+    }
+
+    return EFI_SUCCESS;
+}
+
+EFI_STATUS EFIAPI VDiskChainEfiMain
+(
+    IN EFI_HANDLE         ImageHandle,
+    IN EFI_SYSTEM_TABLE  *SystemTable
+)
+{
+    EFI_STATUS Status = EFI_SUCCESS;
+
+    gST->ConOut->ClearScreen(gST->ConOut);
+    vdisk_clear_input();
+
+    Status = vdisk_parse_cmdline(ImageHandle);
+    if (EFI_ERROR(Status))
+    {
+        return Status;
+    }
+
+    vdisk_install_blockio(ImageHandle, g_disk_buf_size);
+    vdisk_debug_pause();
+
+    Status = vdisk_boot(ImageHandle);
+    
+    gBS->DisconnectController(gVDiskBlockData.Handle, NULL, NULL);
+    gBS->UninstallMultipleProtocolInterfaces(gVDiskBlockData.Handle,
+            &gEfiBlockIoProtocolGuid, &gVDiskBlockData.BlockIo,
+            &gEfiDevicePathProtocolGuid, gVDiskBlockData.Path,
+            NULL);
+
+    if (EFI_NOT_FOUND == Status)
+    {
+        gST->ConOut->OutputString(gST->ConOut, L"No bootfile found for UEFI!\r\n");
+        gST->ConOut->OutputString(gST->ConOut, L"Maybe the image does not support " VENTOY_UEFI_DESC  L"!\r\n");
+        sleep(30);
+    }
+    
+    vdisk_clear_input();
+    gST->ConOut->ClearScreen(gST->ConOut);
+
+    return EFI_SUCCESS;
+}
+

EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/VDiskChain/VDiskChain.h

@@ -0,0 +1,97 @@
+/******************************************************************************
+ * VDiskChain.h
+ *
+ * Copyright (c) 2021, longpanda <admin@ventoy.net>
+ *
+ * This program 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.
+ * 
+ * This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+ 
+#ifndef __VENTOY_H__
+#define __VENTOY_H__
+
+#define VDISK_MAGIC_LEN  32
+
+#define VDISK_BLOCK_DEVICE_PATH_GUID					\
+	{ 0x6ed2134e, 0xc2ea, 0x4943, { 0x99, 0x54, 0xa7, 0x76, 0xe5, 0x9c, 0x12, 0xc3 }}
+
+#define VDISK_BLOCK_DEVICE_PATH_NAME  L"vdisk"
+
+#if   defined (MDE_CPU_IA32)
+  #define VENTOY_UEFI_DESC   L"IA32 UEFI"
+#elif defined (MDE_CPU_X64)
+  #define VENTOY_UEFI_DESC   L"X64 UEFI"
+#elif defined (MDE_CPU_EBC)
+#elif defined (MDE_CPU_ARM)
+  #define VENTOY_UEFI_DESC   L"ARM UEFI"
+#elif defined (MDE_CPU_AARCH64)
+  #define VENTOY_UEFI_DESC   L"ARM64 UEFI"
+#else
+  #error Unknown Processor Type
+#endif
+
+typedef struct vdisk_block_data 
+{
+	EFI_HANDLE Handle;
+	EFI_BLOCK_IO_MEDIA Media;       /* Media descriptor */
+	EFI_BLOCK_IO_PROTOCOL BlockIo;	/* Block I/O protocol */
+
+    UINTN DevicePathCompareLen;
+	EFI_DEVICE_PATH_PROTOCOL *Path;	/* Device path protocol */
+
+    EFI_HANDLE RawBlockIoHandle;
+    EFI_BLOCK_IO_PROTOCOL *pRawBlockIo;
+    EFI_DEVICE_PATH_PROTOCOL *pDiskDevPath;
+
+    /* ventoy disk part2 ESP */
+    EFI_HANDLE DiskFsHandle;
+    EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *pDiskFs;
+    EFI_DEVICE_PATH_PROTOCOL *pDiskFsDevPath;
+
+    EFI_HANDLE IsoDriverImage;
+}vdisk_block_data;
+
+
+#define debug(expr, ...) if (gVDiskDebugPrint) VDiskDebug("[VDISK] "expr"\r\n", ##__VA_ARGS__)
+#define trace(expr, ...) VDiskDebug("[VDISK] "expr"\r\n", ##__VA_ARGS__)
+#define sleep(sec) gBS->Stall(1000000 * (sec))
+
+#define vdisk_debug_pause() \
+if (gVDiskDebugPrint) \
+{ \
+    UINTN __Index = 0; \
+    gST->ConOut->OutputString(gST->ConOut, L"[VDISK] ###### Press Enter to continue... ######\r\n");\
+    gST->ConIn->Reset(gST->ConIn, FALSE); \
+    gBS->WaitForEvent(1, &gST->ConIn->WaitForKey, &__Index);\
+}
+
+extern BOOLEAN gVDiskDebugPrint;
+VOID EFIAPI VDiskDebug(IN CONST CHAR8  *Format, ...);
+EFI_STATUS EFIAPI vdisk_block_io_read 
+(
+    IN EFI_BLOCK_IO_PROTOCOL          *This,
+    IN UINT32                          MediaId,
+    IN EFI_LBA                         Lba,
+    IN UINTN                           BufferSize,
+    OUT VOID                          *Buffer
+);
+
+extern UINT8 *g_disk_buf_addr;
+extern UINT64 g_disk_buf_size;
+extern vdisk_block_data gVDiskBlockData;
+EFI_STATUS EFIAPI vdisk_install_blockio(IN EFI_HANDLE ImageHandle, IN UINT64 ImgSize);
+int vdisk_get_vdisk_raw(UINT8 **buf, UINT32 *size);
+
+#endif
+

EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/VDiskChain/VDiskChain.inf

@@ -0,0 +1,82 @@
+#************************************************************************************
+# Copyright (c) 2020, longpanda <admin@ventoy.net>
+# 
+# This program 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.
+# 
+# This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
+# 
+#************************************************************************************
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = VDiskChain
+  FILE_GUID                      = 5bce96e3-ba11-4440-833b-299cf5849193
+  MODULE_TYPE                    = UEFI_APPLICATION
+  VERSION_STRING                 = 1.0
+  ENTRY_POINT                    = VDiskChainEfiMain
+
+
+[Sources]
+  VDiskChain.h
+  VDiskChain.c
+  VDiskRawData.c
+  VDiskChainProtocol.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+  MdeModulePkg/MdeModulePkg.dec
+  ShellPkg/ShellPkg.dec
+
+[LibraryClasses]
+  UefiApplicationEntryPoint
+  UefiLib
+  DebugLib
+  UefiDecompressLib
+
+[Guids]
+  gShellVariableGuid
+  gEfiVirtualCdGuid
+  gEfiFileInfoGuid
+  
+[Protocols]
+  gEfiLoadedImageProtocolGuid
+  gEfiBlockIoProtocolGuid
+  gEfiDevicePathProtocolGuid
+  gEfiSimpleFileSystemProtocolGuid
+  gEfiRamDiskProtocolGuid
+  gEfiAbsolutePointerProtocolGuid
+  gEfiAcpiTableProtocolGuid
+  gEfiBlockIo2ProtocolGuid
+  gEfiBusSpecificDriverOverrideProtocolGuid
+  gEfiComponentNameProtocolGuid
+  gEfiComponentName2ProtocolGuid
+  gEfiDriverBindingProtocolGuid
+  gEfiDiskIoProtocolGuid
+  gEfiDiskIo2ProtocolGuid
+  gEfiGraphicsOutputProtocolGuid
+  gEfiHiiConfigAccessProtocolGuid
+  gEfiHiiFontProtocolGuid
+  gEfiLoadFileProtocolGuid
+  gEfiLoadFile2ProtocolGuid
+  gEfiLoadedImageProtocolGuid
+  gEfiLoadedImageDevicePathProtocolGuid
+  gEfiPciIoProtocolGuid
+  gEfiSerialIoProtocolGuid
+  gEfiSimpleTextInProtocolGuid
+  gEfiSimpleTextInputExProtocolGuid
+  gEfiSimpleTextOutProtocolGuid
+  
+  
+  
+  
+  
+  

EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/VDiskChain/VDiskChainProtocol.c

@@ -0,0 +1,264 @@
+/******************************************************************************
+ * VDiskChainProtocol.c
+ *
+ * Copyright (c) 2021, longpanda <admin@ventoy.net>
+ *
+ * This program 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.
+ * 
+ * This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <Uefi.h>
+#include <Library/DebugLib.h>
+#include <Library/PrintLib.h>
+#include <Library/UefiLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DevicePathLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/UefiRuntimeServicesTableLib.h>
+#include <Library/UefiApplicationEntryPoint.h>
+#include <Protocol/LoadedImage.h>
+#include <Guid/FileInfo.h>
+#include <Guid/FileSystemInfo.h>
+#include <Protocol/BlockIo.h>
+#include <Protocol/RamDisk.h>
+#include <Protocol/SimpleFileSystem.h>
+#include <VDiskChain.h>
+
+/* EFI block device vendor device path GUID */
+EFI_GUID gVDiskBlockDevicePathGuid = VDISK_BLOCK_DEVICE_PATH_GUID;
+
+EFI_STATUS EFIAPI vdisk_block_io_reset 
+(
+    IN EFI_BLOCK_IO_PROTOCOL          *This,
+    IN BOOLEAN                        ExtendedVerification
+) 
+{
+    (VOID)This;
+    (VOID)ExtendedVerification;
+	return EFI_SUCCESS;
+}
+
+EFI_STATUS EFIAPI vdisk_block_io_flush(IN EFI_BLOCK_IO_PROTOCOL *This)
+{
+	(VOID)This;
+	return EFI_SUCCESS;
+}
+
+EFI_STATUS EFIAPI vdisk_block_io_read
+(
+    IN EFI_BLOCK_IO_PROTOCOL          *This,
+    IN UINT32                          MediaId,
+    IN EFI_LBA                         Lba,
+    IN UINTN                           BufferSize,
+    OUT VOID                          *Buffer
+)
+{
+    (VOID)This;
+    (VOID)MediaId;
+
+    debug("vdisk_block_io_read %lu %lu\n", Lba, BufferSize / 512);
+    CopyMem(Buffer, g_disk_buf_addr + (Lba * 512), BufferSize);
+
+    return EFI_SUCCESS;
+}
+
+EFI_STATUS EFIAPI vdisk_block_io_write
+(
+    IN EFI_BLOCK_IO_PROTOCOL          *This,
+    IN UINT32                          MediaId,
+    IN EFI_LBA                         Lba,
+    IN UINTN                           BufferSize,
+    IN VOID                           *Buffer
+)
+{
+    (VOID)This;
+    (VOID)MediaId;
+    (VOID)Buffer;
+
+    debug("vdisk_block_io_read %lu %lu\n", Lba, BufferSize / 512);
+    return EFI_WRITE_PROTECTED;
+}
+
+EFI_STATUS EFIAPI vdisk_fill_device_path(VOID)
+{
+    UINTN NameLen = 0;
+    UINT8 TmpBuf[128] = {0};
+    VENDOR_DEVICE_PATH *venPath = NULL;
+
+    venPath = (VENDOR_DEVICE_PATH *)TmpBuf;
+    NameLen = StrSize(VDISK_BLOCK_DEVICE_PATH_NAME);
+    venPath->Header.Type = HARDWARE_DEVICE_PATH;
+    venPath->Header.SubType = HW_VENDOR_DP;
+    venPath->Header.Length[0] = sizeof(VENDOR_DEVICE_PATH) + NameLen;
+    venPath->Header.Length[1] = 0;
+    CopyMem(&venPath->Guid, &gVDiskBlockDevicePathGuid, sizeof(EFI_GUID));
+    CopyMem(venPath + 1, VDISK_BLOCK_DEVICE_PATH_NAME, NameLen);
+    
+    gVDiskBlockData.Path = AppendDevicePathNode(NULL, (EFI_DEVICE_PATH_PROTOCOL *)TmpBuf);
+    gVDiskBlockData.DevicePathCompareLen = sizeof(VENDOR_DEVICE_PATH) + NameLen;
+
+    debug("gVDiskBlockData.Path=<%s>\n", ConvertDevicePathToText(gVDiskBlockData.Path, FALSE, FALSE));
+
+    return EFI_SUCCESS;
+}
+
+EFI_STATUS EFIAPI vdisk_connect_driver(IN EFI_HANDLE ControllerHandle, IN CONST CHAR16 *DrvName)
+{
+    UINTN i = 0;
+    UINTN Count = 0;
+    CHAR16 *DriverName = NULL;
+    EFI_HANDLE *Handles = NULL;
+    EFI_HANDLE DrvHandles[2] = { NULL };
+    EFI_STATUS Status = EFI_SUCCESS;
+    EFI_COMPONENT_NAME_PROTOCOL *NameProtocol = NULL;
+    EFI_COMPONENT_NAME2_PROTOCOL *Name2Protocol = NULL;
+
+    debug("vdisk_connect_driver <%s>...", DrvName);
+
+    Status = gBS->LocateHandleBuffer(ByProtocol, &gEfiComponentName2ProtocolGuid, 
+                                     NULL, &Count, &Handles);
+    if (EFI_ERROR(Status))
+    {
+        return Status;
+    }
+
+    for (i = 0; i < Count; i++)
+    {
+        Status = gBS->HandleProtocol(Handles[i], &gEfiComponentName2ProtocolGuid, (VOID **)&Name2Protocol);
+        if (EFI_ERROR(Status))
+        {
+            continue;
+        }
+
+        Status = Name2Protocol->GetDriverName(Name2Protocol, "en", &DriverName);
+        if (EFI_ERROR(Status) || NULL == DriverName)
+        {
+            continue;
+        }
+
+        if (StrStr(DriverName, DrvName))
+        {
+            debug("Find driver name2:<%s>: <%s>", DriverName, DrvName);
+            DrvHandles[0] = Handles[i];
+            break;
+        }
+    }
+
+    if (i < Count)
+    {
+        Status = gBS->ConnectController(ControllerHandle, DrvHandles, NULL, TRUE);
+        debug("vdisk_connect_driver:<%s> <%r>", DrvName, Status);
+        goto end;
+    }
+
+    debug("%s NOT found, now try COMPONENT_NAME", DrvName);
+
+    Count = 0;
+    FreePool(Handles);
+    Handles = NULL;
+
+    Status = gBS->LocateHandleBuffer(ByProtocol, &gEfiComponentNameProtocolGuid, 
+                                     NULL, &Count, &Handles);
+    if (EFI_ERROR(Status))
+    {
+        return Status;
+    }
+
+    for (i = 0; i < Count; i++)
+    {
+        Status = gBS->HandleProtocol(Handles[i], &gEfiComponentNameProtocolGuid, (VOID **)&NameProtocol);
+        if (EFI_ERROR(Status))
+        {
+            continue;
+        }
+
+        Status = NameProtocol->GetDriverName(NameProtocol, "en", &DriverName);
+        if (EFI_ERROR(Status))
+        {
+            continue;
+        }
+
+        if (StrStr(DriverName, DrvName))
+        {
+            debug("Find driver name:<%s>: <%s>", DriverName, DrvName);
+            DrvHandles[0] = Handles[i];
+            break;
+        }
+    }
+
+    if (i < Count)
+    {
+        Status = gBS->ConnectController(ControllerHandle, DrvHandles, NULL, TRUE);
+        debug("vdisk_connect_driver:<%s> <%r>", DrvName, Status);
+        goto end;
+    }
+
+    Status = EFI_NOT_FOUND;
+    
+end:
+    FreePool(Handles);
+    
+    return Status;
+}
+
+EFI_STATUS EFIAPI vdisk_install_blockio(IN EFI_HANDLE ImageHandle, IN UINT64 ImgSize)
+{   
+    EFI_STATUS Status = EFI_SUCCESS;
+    EFI_BLOCK_IO_PROTOCOL *pBlockIo = &(gVDiskBlockData.BlockIo);
+    
+    vdisk_fill_device_path();
+
+    debug("install block io protocol %p", ImageHandle);
+    vdisk_debug_pause();
+
+    gVDiskBlockData.Media.BlockSize = 512;
+    gVDiskBlockData.Media.LastBlock = ImgSize / 512 - 1;
+    gVDiskBlockData.Media.ReadOnly = TRUE;
+    gVDiskBlockData.Media.MediaPresent = 1;
+    gVDiskBlockData.Media.LogicalBlocksPerPhysicalBlock = 1;
+
+	pBlockIo->Revision = EFI_BLOCK_IO_PROTOCOL_REVISION3;
+	pBlockIo->Media = &(gVDiskBlockData.Media);
+	pBlockIo->Reset = vdisk_block_io_reset;
+    pBlockIo->ReadBlocks = vdisk_block_io_read;
+	pBlockIo->WriteBlocks = vdisk_block_io_write;
+	pBlockIo->FlushBlocks = vdisk_block_io_flush;
+
+    Status = gBS->InstallMultipleProtocolInterfaces(&gVDiskBlockData.Handle,
+            &gEfiBlockIoProtocolGuid, &gVDiskBlockData.BlockIo,
+            &gEfiDevicePathProtocolGuid, gVDiskBlockData.Path,
+            NULL);
+    debug("Install protocol %r %p", Status, gVDiskBlockData.Handle);
+    if (EFI_ERROR(Status))
+    {
+        return Status;
+    }
+
+    Status = vdisk_connect_driver(gVDiskBlockData.Handle, L"Disk I/O Driver");
+    debug("Connect disk IO driver %r", Status);
+
+    Status = vdisk_connect_driver(gVDiskBlockData.Handle, L"Partition Driver");
+    debug("Connect partition driver %r", Status);
+    if (EFI_ERROR(Status))
+    {
+        Status = gBS->ConnectController(gVDiskBlockData.Handle, NULL, NULL, TRUE);
+        debug("Connect all controller %r", Status);
+    }
+
+    vdisk_debug_pause();
+
+    return EFI_SUCCESS;
+}
+

EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/VDiskChain/VDiskRawData.c

@@ -0,0 +1 @@
+123

EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/Ventoy/Ventoy.c

@@ -39,6 +39,7 @@
 BOOLEAN gDebugPrint = FALSE;
 BOOLEAN gDotEfiBoot = FALSE;
 BOOLEAN gLoadIsoEfi = FALSE;
+BOOLEAN gIsoUdf = FALSE;
 ventoy_ram_disk g_ramdisk_param;
 ventoy_chain_head *g_chain;
 ventoy_img_chunk *g_chunk;
@@ -56,6 +57,7 @@ ventoy_grub_param_file_replace *g_file_replace_list = NULL;
 ventoy_efi_file_replace g_efi_file_replace;
 
 CONST CHAR16 gIso9660EfiDriverPath[] = ISO9660_EFI_DRIVER_PATH;
+CONST CHAR16 gUdfEfiDriverPath[] = UDF_EFI_DRIVER_PATH;
 
 BOOLEAN g_fix_windows_1st_cdrom_issue = FALSE;
 
@@ -69,10 +71,28 @@ CONST CHAR16 *gEfiBootFileName[] =
 {
     L"@",
     EFI_REMOVABLE_MEDIA_FILE_NAME,
+#if   defined (MDE_CPU_IA32)
+    L"\\EFI\\BOOT\\GRUBIA32.EFI",
+    L"\\EFI\\BOOT\\BOOTia32.EFI",
+    L"\\EFI\\BOOT\\bootia32.efi",
+    L"\\efi\\boot\\bootia32.efi",
+#elif defined (MDE_CPU_X64)
     L"\\EFI\\BOOT\\GRUBX64.EFI",
     L"\\EFI\\BOOT\\BOOTx64.EFI",
     L"\\EFI\\BOOT\\bootx64.efi",
     L"\\efi\\boot\\bootx64.efi",
+#elif defined (MDE_CPU_ARM)
+    L"\\EFI\\BOOT\\GRUBARM.EFI",
+    L"\\EFI\\BOOT\\BOOTarm.EFI",
+    L"\\EFI\\BOOT\\bootarm.efi",
+    L"\\efi\\boot\\bootarm.efi",
+#elif defined (MDE_CPU_AARCH64)
+    L"\\EFI\\BOOT\\GRUBAA64.EFI",
+    L"\\EFI\\BOOT\\BOOTaa64.EFI",
+    L"\\EFI\\BOOT\\bootaa64.efi",
+    L"\\efi\\boot\\bootaa64.efi",
+#endif
+    
 };
 
 VOID EFIAPI VtoyDebug(IN CONST CHAR8  *Format, ...)
@@ -408,12 +428,12 @@ STATIC VOID ventoy_warn_invalid_device(VOID)
     gST->ConOut->OutputString(gST->ConOut, VTOY_WARNING L"\r\n");
     gST->ConOut->OutputString(gST->ConOut, VTOY_WARNING L"\r\n\r\n\r\n");
 
-    gST->ConOut->OutputString(gST->ConOut, L"This is NOT a standard Ventoy device and is NOT officially supported.\r\n\r\n");
+    gST->ConOut->OutputString(gST->ConOut, L"This is NOT a standard Ventoy device and is NOT supported.\r\n\r\n");
     gST->ConOut->OutputString(gST->ConOut, L"You should follow the official instructions in https://www.ventoy.net\r\n");
     
-    gST->ConOut->OutputString(gST->ConOut, L"\r\n\r\nWill continue to boot after 15 seconds ...... ");
+    gST->ConOut->OutputString(gST->ConOut, L"\r\n\r\nWill exit after 10 seconds ...... ");
 
-    sleep(15);
+    sleep(10);
 }
 #else
 STATIC VOID ventoy_warn_invalid_device(VOID)
@@ -609,11 +629,22 @@ STATIC EFI_STATUS EFIAPI ventoy_load_isoefi_driver(IN EFI_HANDLE ImageHandle)
     EFI_STATUS Status = EFI_SUCCESS;
     CHAR16 LogVar[4] = L"5";
 
+    if (gIsoUdf)
+    {
+        Status = ventoy_load_image(ImageHandle, gBlockData.pDiskFsDevPath, 
+                                   gUdfEfiDriverPath, 
+                                   sizeof(gUdfEfiDriverPath), 
+                                   &Image);
+        debug("load iso UDF efi driver status:%r", Status);
+    }
+    else
+    {
         Status = ventoy_load_image(ImageHandle, gBlockData.pDiskFsDevPath, 
                                    gIso9660EfiDriverPath, 
                                    sizeof(gIso9660EfiDriverPath), 
                                    &Image);
-    debug("load iso efi driver status:%r", Status);
+        debug("load iso 9660 efi driver status:%r", Status);        
+    }
 
     if (gDebugPrint)
     {
@@ -673,6 +704,11 @@ STATIC EFI_STATUS EFIAPI ventoy_parse_cmdline(IN EFI_HANDLE ImageHandle)
         gLoadIsoEfi = TRUE;
     }
     
+    if (StrStr(pCmdLine, L"iso_udf"))
+    {
+        gIsoUdf = TRUE;
+    }
+
     pPos = StrStr(pCmdLine, L"FirstTry=@");
     if (pPos)
     {
@@ -718,6 +754,7 @@ STATIC EFI_STATUS EFIAPI ventoy_parse_cmdline(IN EFI_HANDLE ImageHandle)
     if (pEnv[0] != '0' || pEnv[1] != 0)
     {
         ventoy_warn_invalid_device();
+        return EFI_INVALID_PARAMETER;
     }
     
     g_file_replace_list = &pGrubParam->file_replace;

EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/Ventoy/Ventoy.h

@@ -168,24 +168,31 @@ typedef struct ventoy_virt_chunk
 #define VTOY_BLOCK_DEVICE_PATH_GUID					\
 	{ 0x37b87ac6, 0xc180, 0x4583, { 0xa7, 0x05, 0x41, 0x4d, 0xa8, 0xf7, 0x7e, 0xd2 }}
 
-#define ISO9660_EFI_DRIVER_PATH  L"\\ventoy\\iso9660_x64.efi"
 
 #define VTOY_BLOCK_DEVICE_PATH_NAME  L"ventoy"
 
 #if   defined (MDE_CPU_IA32)
   #define VENTOY_UEFI_DESC   L"IA32 UEFI"
+  #define ISO9660_EFI_DRIVER_PATH  L"\\ventoy\\iso9660_ia32.efi"
+  #define UDF_EFI_DRIVER_PATH  L"\\ventoy\\udf_ia32.efi"
 #elif defined (MDE_CPU_X64)
   #define VENTOY_UEFI_DESC   L"X64 UEFI"
+  #define ISO9660_EFI_DRIVER_PATH  L"\\ventoy\\iso9660_x64.efi"
+  #define UDF_EFI_DRIVER_PATH  L"\\ventoy\\udf_x64.efi"
 #elif defined (MDE_CPU_EBC)
 #elif defined (MDE_CPU_ARM)
   #define VENTOY_UEFI_DESC   L"ARM UEFI"
+  #define ISO9660_EFI_DRIVER_PATH  L"\\ventoy\\iso9660_arm.efi"
+  #define UDF_EFI_DRIVER_PATH  L"\\ventoy\\udf_arm.efi"
 #elif defined (MDE_CPU_AARCH64)
   #define VENTOY_UEFI_DESC   L"ARM64 UEFI"
+  #define ISO9660_EFI_DRIVER_PATH  L"\\ventoy\\iso9660_aa64.efi"
+  #define UDF_EFI_DRIVER_PATH  L"\\ventoy\\udf_aa64.efi"
 #else
   #error Unknown Processor Type
 #endif
 
-#define VENTOY_DEVICE_WARN 0
+#define VENTOY_DEVICE_WARN 1
 #define VTOY_WARNING  L"!!!!!!!!!!!!! WARNING !!!!!!!!!!!!!"
 
 typedef struct ventoy_sector_flag

EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/Ventoy/VentoyProtocol.c

@@ -161,10 +161,19 @@ STATIC EFI_STATUS EFIAPI ventoy_read_iso_sector
             {
                 MapLba = (Sector - pchunk->img_start_sector) * 4 + pchunk->disk_start_sector;
             }
-            else
+            else if (g_chain->disk_sector_size == 1024)
             {
-                MapLba = (Sector - pchunk->img_start_sector) * 2048 / g_chain->disk_sector_size + pchunk->disk_start_sector;
+                MapLba = (Sector - pchunk->img_start_sector) * 2 + pchunk->disk_start_sector;
             }
+            else if (g_chain->disk_sector_size == 2048)
+            {
+                MapLba = (Sector - pchunk->img_start_sector) + pchunk->disk_start_sector;
+            }
+            else if (g_chain->disk_sector_size == 4096)
+            {
+                MapLba = ((Sector - pchunk->img_start_sector) >> 1) + pchunk->disk_start_sector;
+            }
+            
 
             secLeft = pchunk->img_end_sector + 1 - Sector;
             secRead = (Count < secLeft) ? Count : secLeft;
@@ -277,10 +286,19 @@ STATIC EFI_STATUS EFIAPI ventoy_write_iso_sector
             {
                 MapLba = (Sector - pchunk->img_start_sector) * 4 + pchunk->disk_start_sector;
             }
-            else
+            else if (g_chain->disk_sector_size == 1024)
             {
-                MapLba = (Sector - pchunk->img_start_sector) * 2048 / g_chain->disk_sector_size + pchunk->disk_start_sector;
+                MapLba = (Sector - pchunk->img_start_sector) * 2 + pchunk->disk_start_sector;
             }
+            else if (g_chain->disk_sector_size == 2048)
+            {
+                MapLba = (Sector - pchunk->img_start_sector) + pchunk->disk_start_sector;
+            }
+            else if (g_chain->disk_sector_size == 4096)
+            {
+                MapLba = ((Sector - pchunk->img_start_sector) >> 1) + pchunk->disk_start_sector;
+            }
+
 
             secLeft = pchunk->img_end_sector + 1 - Sector;
             secRead = (Count < secLeft) ? Count : secLeft;

EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/VtoyUtil/VtoyUtil.c

@@ -79,6 +79,14 @@ STATIC EFI_STATUS ParseCmdline(IN EFI_HANDLE ImageHandle)
     SetMem(pCmdLine, pImageInfo->LoadOptionsSize + 4, 0);
     CopyMem(pCmdLine, pImageInfo->LoadOptions, pImageInfo->LoadOptionsSize);
 
+    if (StrStr(pCmdLine, L"vtoyefitest"))
+    {
+        gST->ConOut->OutputString(gST->ConOut, L"\r\n##########################");
+        gST->ConOut->OutputString(gST->ConOut, L"\r\n#########  VTOY  #########");
+        gST->ConOut->OutputString(gST->ConOut, L"\r\n##########################");
+        return EFI_SUCCESS;
+    }
+    
     if (StrStr(pCmdLine, L"debug"))
     {
         gVtoyDebugPrint = TRUE;
@@ -102,6 +110,7 @@ STATIC EFI_STATUS ParseCmdline(IN EFI_HANDLE ImageHandle)
     gCurFeature = pPos + StrLen(L"feature=");
     
     gCmdLine = pCmdLine;
+    
     return EFI_SUCCESS;
 }
 
@@ -116,7 +125,7 @@ EFI_STATUS EFIAPI VtoyUtilEfiMain
     
     ParseCmdline(ImageHandle);
 
-    for (i = 0; i < ARRAY_SIZE(gFeatureList); i++)
+    for (i = 0; gCurFeature && i < ARRAY_SIZE(gFeatureList); i++)
     {
         Len = StrLen(gFeatureList[i].Cmd);
         if (StrnCmp(gFeatureList[i].Cmd, gCurFeature, Len) == 0)
@@ -127,8 +136,11 @@ EFI_STATUS EFIAPI VtoyUtilEfiMain
         }
     }
 
+    if (gCmdLine)
+    {
         FreePool(gCmdLine);
         gCmdLine = NULL;        
+    }
 
     return EFI_SUCCESS;
 }

EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/MdeModulePkg.dsc

@@ -205,6 +205,7 @@
 [Components]
   MdeModulePkg/Application/Ventoy/Ventoy.inf
   MdeModulePkg/Application/VtoyUtil/VtoyUtil.inf
+  MdeModulePkg/Application/VDiskChain/VDiskChain.inf
   MdeModulePkg/Application/HelloWorld/HelloWorld.inf
   MdeModulePkg/Application/DumpDynPcd/DumpDynPcd.inf
   MdeModulePkg/Application/MemoryProfileInfo/MemoryProfileInfo.inf

ExFAT/buidexfat_aarch64.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+CUR="$PWD"
+
+if ! [ -e LIBFUSE ]; then
+	./buidlibfuse.sh
+fi
+
+rm -f EXFAT/shared/*
+
+
+rm -rf exfat-1.3.0
+unzip exfat-1.3.0.zip
+sed "/printf.*VERSION/a\    if (access(\"/etc/initrd-release\", F_OK) >= 0) argv[0][0] = '@';"  -i exfat-1.3.0/fuse/main.c
+
+cd exfat-1.3.0
+autoreconf --install
+./configure --prefix="$CUR" CFLAGS='-O2 -D_FILE_OFFSET_BITS=64' FUSE_CFLAGS="-I$CUR/LIBFUSE/include/" FUSE_LIBS="$CUR/LIBFUSE/lib/libfuse.a -lpthread -ldl"
+make
+
+strip --strip-all fuse/mount.exfat-fuse
+strip --strip-all mkfs/mkexfatfs
+
+cp fuse/mount.exfat-fuse ../EXFAT/shared/mount.exfat-fuse
+cp mkfs/mkexfatfs ../EXFAT/shared/mkexfatfs
+
+cd ..
+rm -rf exfat-1.3.0
+
+
+
+

ExFAT/buidlibfuse_aarch64.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+CUR="$PWD"
+
+rm -rf libfuse
+rm -rf LIBFUSE
+
+if [ -e mirrors-libfuse-fuse-2.9.9.zip ]; then
+    unzip mirrors-libfuse-fuse-2.9.9.zip
+    cd libfuse
+else
+    unzip libfuse-fuse-2.9.9.zip
+    cd libfuse-fuse-2.9.9
+fi
+
+./makeconf.sh
+
+./configure --prefix="$CUR/LIBFUSE"
+
+sed '/#define *__u64/d' -i include/fuse_kernel.h
+sed '/#define *__s64/d' -i include/fuse_kernel.h
+
+sed  's/__u64/uint64_t/g'    -i include/fuse_kernel.h
+sed  's/__s64/int64_t/g'    -i include/fuse_kernel.h
+
+make -j 16
+make install
+cd ..
+rm -rf libfuse

FUSEISO/build.sh

@@ -11,10 +11,16 @@ else
     opt=-lrt
 fi
 
+#
+# use musl-c to build for x86_64
+#
+
 export C_INCLUDE_PATH=$LIBFUSE_DIR/include
 
 rm -f $name
-gcc -static -O2 -D_FILE_OFFSET_BITS=64  vtoy_fuse_iso.c -o $name $LIBFUSE_DIR/lib/libfuse.a  -lpthread -ldl $opt
+gcc -specs "/usr/local/musl/lib/musl-gcc.specs" -static -O2 -D_FILE_OFFSET_BITS=64  vtoy_fuse_iso.c $LIBFUSE_DIR/lib/libfuse.a  -o  $name
+
+strip --strip-all $name
 
 if [ -e $name ]; then
    echo -e "\n############### SUCCESS $name ##################\n"

FUSEISO/build_aarch64.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+CUR="$PWD"
+
+LIBFUSE_DIR=$CUR/LIBFUSE
+
+name=vtoy_fuse_iso_aa64
+
+export C_INCLUDE_PATH=$LIBFUSE_DIR/include
+
+rm -f $name
+aarch64-buildroot-linux-uclibc-gcc -static -O2 -D_FILE_OFFSET_BITS=64  vtoy_fuse_iso.c -o $name $LIBFUSE_DIR/lib/libfuse.a
+
+if [ -e $name ]; then
+   echo -e "\n############### SUCCESS $name ##################\n"
+else
+    echo -e "\n############### FAILED $name ##################\n"
+fi
+
+aarch64-buildroot-linux-uclibc-strip --strip-all $name
+

FUSEISO/build_libfuse.sh

@@ -7,6 +7,8 @@
 #
 #
 
+#  use mini-native-x86_64 UCLIBC to build for x86_64
+
 
 CUR="$PWD"
 LIBFUSE_DIR=$CUR/LIBFUSE
@@ -31,7 +33,7 @@ fi
 
 ./makeconf.sh
 
-./configure --prefix="$LIBFUSE_DIR"
+./configure --prefix="$LIBFUSE_DIR" CFLAGS='-specs /usr/local/musl/lib/musl-gcc.specs'
 make -j 16
 make install
 cd ..

FUSEISO/build_libfuse_aarch64.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+
+#
+#
+# Package Dependency:
+# gcc automake autoconf gettext gettext-devel libtool unzip
+#
+#
+
+
+CUR="$PWD"
+LIBFUSE_DIR=$CUR/LIBFUSE
+
+rm -rf libfuse
+rm -rf $LIBFUSE_DIR
+
+# please download https://codeload.github.com/libfuse/libfuse/zip/fuse-2.9.9
+if [ -e ../ExFAT/mirrors-libfuse-fuse-2.9.9.zip ]; then
+    rm -rf libfuse
+    unzip ../ExFAT/mirrors-libfuse-fuse-2.9.9.zip
+    cd libfuse
+elif [ -e ../ExFAT/libfuse-fuse-2.9.9.zip ]; then
+    rm -rf libfuse-fuse-2.9.9
+    unzip ../ExFAT/libfuse-fuse-2.9.9.zip
+    cd libfuse-fuse-2.9.9
+else
+    echo "Please download mirrors-libfuse-fuse-2.9.9.zip first"
+    exit 1
+fi
+
+
+./makeconf.sh
+
+sed '/#define *__u64/d' -i include/fuse_kernel.h
+sed '/#define *__s64/d' -i include/fuse_kernel.h
+
+sed  's/__u64/uint64_t/g'    -i include/fuse_kernel.h
+sed  's/__s64/int64_t/g'    -i include/fuse_kernel.h
+
+./configure --prefix="$LIBFUSE_DIR" --host=aarch64 CC=aarch64-buildroot-linux-uclibc-gcc
+
+
+make -j 16
+make install
+cd ..
+rm -rf libfuse

GRUB2/MOD_SRC/grub-2.04/grub-core/Makefile.core.def

@@ -1597,6 +1597,12 @@ module = {
   common = ventoy/lzx.c;
   common = ventoy/xpress.c;
   common = ventoy/huffman.c;
+  common = ventoy/miniz.c;
+};
+
+module = {
+    name = setkey;
+    common = term/setkey.c;
 };
 
 module = {

GRUB2/MOD_SRC/grub-2.04/grub-core/boot/i386/pc/boot.S

@@ -479,7 +479,7 @@ LOCAL(stop):
 	jmp	LOCAL(stop)
 
 ventoy_uuid:	.ascii  "XXXXXXXXXXXXXXXX"
-notification_string:	.asciz "GR"
+notification_string:	.asciz "VT"
 geometry_error_string:	.asciz "Ge"
 hd_probe_error_string:	.asciz "HD"
 read_error_string:	.asciz "Rd"

GRUB2/MOD_SRC/grub-2.04/grub-core/commands/search.c

@@ -0,0 +1,353 @@
+/* search.c - search devices based on a file or a filesystem label */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2005,2007,2008,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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/dl.h>
+#include <grub/device.h>
+#include <grub/file.h>
+#include <grub/env.h>
+#include <grub/command.h>
+#include <grub/search.h>
+#include <grub/i18n.h>
+#include <grub/disk.h>
+#include <grub/partition.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static int g_no_vtoyefi_part = 0;
+static char g_vtoyefi_dosname[64];
+static char g_vtoyefi_gptname[64];
+
+struct cache_entry
+{
+  struct cache_entry *next;
+  char *key;
+  char *value;
+};
+
+static struct cache_entry *cache;
+
+/* Context for FUNC_NAME.  */
+struct search_ctx
+{
+  const char *key;
+  const char *var;
+  int no_floppy;
+  char **hints;
+  unsigned nhints;
+  int count;
+  int is_cache;
+};
+
+/* Helper for FUNC_NAME.  */
+static int
+iterate_device (const char *name, void *data)
+{
+  struct search_ctx *ctx = data;
+  int found = 0;
+
+  /* Skip floppy drives when requested.  */
+  if (ctx->no_floppy &&
+      name[0] == 'f' && name[1] == 'd' && name[2] >= '0' && name[2] <= '9')
+    return 1;
+
+  if (g_no_vtoyefi_part && (grub_strcmp(name, g_vtoyefi_dosname) == 0 || grub_strcmp(name, g_vtoyefi_gptname) == 0)) {
+    return 0;
+  }
+
+#ifdef DO_SEARCH_FS_UUID
+#define compare_fn grub_strcasecmp
+#else
+#define compare_fn grub_strcmp
+#endif
+
+#ifdef DO_SEARCH_FILE
+    {
+      char *buf;
+      grub_file_t file;
+
+      buf = grub_xasprintf ("(%s)%s", name, ctx->key);
+      if (! buf)
+	return 1;
+
+      file = grub_file_open (buf, GRUB_FILE_TYPE_FS_SEARCH
+			     | GRUB_FILE_TYPE_NO_DECOMPRESS);
+      if (file)
+	{
+	  found = 1;
+	  grub_file_close (file);
+	}
+      grub_free (buf);
+    }
+#else
+    {
+      /* SEARCH_FS_UUID or SEARCH_LABEL */
+      grub_device_t dev;
+      grub_fs_t fs;
+      char *quid;
+
+      dev = grub_device_open (name);
+      if (dev)
+	{
+	  fs = grub_fs_probe (dev);
+
+#ifdef DO_SEARCH_FS_UUID
+#define read_fn fs_uuid
+#else
+#define read_fn fs_label
+#endif
+
+	  if (fs && fs->read_fn)
+	    {
+	      fs->read_fn (dev, &quid);
+
+	      if (grub_errno == GRUB_ERR_NONE && quid)
+		{
+		  if (compare_fn (quid, ctx->key) == 0)
+		    found = 1;
+
+		  grub_free (quid);
+		}
+	    }
+
+	  grub_device_close (dev);
+	}
+    }
+#endif
+
+  if (!ctx->is_cache && found && ctx->count == 0)
+    {
+      struct cache_entry *cache_ent;
+      cache_ent = grub_malloc (sizeof (*cache_ent));
+      if (cache_ent)
+	{
+	  cache_ent->key = grub_strdup (ctx->key);
+	  cache_ent->value = grub_strdup (name);
+	  if (cache_ent->value && cache_ent->key)
+	    {
+	      cache_ent->next = cache;
+	      cache = cache_ent;
+	    }
+	  else
+	    {
+	      grub_free (cache_ent->value);
+	      grub_free (cache_ent->key);
+	      grub_free (cache_ent);
+	      grub_errno = GRUB_ERR_NONE;
+	    }
+	}
+      else
+	grub_errno = GRUB_ERR_NONE;
+    }
+
+  if (found)
+    {
+      ctx->count++;
+      if (ctx->var)
+	grub_env_set (ctx->var, name);
+      else
+	grub_printf (" %s", name);
+    }
+
+  grub_errno = GRUB_ERR_NONE;
+  return (found && ctx->var);
+}
+
+/* Helper for FUNC_NAME.  */
+static int
+part_hook (grub_disk_t disk, const grub_partition_t partition, void *data)
+{
+  struct search_ctx *ctx = data;
+  char *partition_name, *devname;
+  int ret;
+
+  partition_name = grub_partition_get_name (partition);
+  if (! partition_name)
+    return 1;
+
+  devname = grub_xasprintf ("%s,%s", disk->name, partition_name);
+  grub_free (partition_name);
+  if (!devname)
+    return 1;
+  ret = iterate_device (devname, ctx);
+  grub_free (devname);    
+
+  return ret;
+}
+
+/* Helper for FUNC_NAME.  */
+static void
+try (struct search_ctx *ctx)    
+{
+  unsigned i;
+  struct cache_entry **prev;
+  struct cache_entry *cache_ent;
+
+  for (prev = &cache, cache_ent = *prev; cache_ent;
+       prev = &cache_ent->next, cache_ent = *prev)
+    if (compare_fn (cache_ent->key, ctx->key) == 0)
+      break;
+  if (cache_ent)
+    {
+      ctx->is_cache = 1;
+      if (iterate_device (cache_ent->value, ctx))
+	{
+	  ctx->is_cache = 0;
+	  return;
+	}
+      ctx->is_cache = 0;
+      /* Cache entry was outdated. Remove it.  */
+      if (!ctx->count)
+	{
+	  *prev = cache_ent->next;
+	  grub_free (cache_ent->key);
+	  grub_free (cache_ent->value);
+	  grub_free (cache_ent);
+	}
+    }
+
+  for (i = 0; i < ctx->nhints; i++)
+    {
+      char *end;
+      if (!ctx->hints[i][0])
+	continue;
+      end = ctx->hints[i] + grub_strlen (ctx->hints[i]) - 1;
+      if (*end == ',')
+	*end = 0;
+      if (iterate_device (ctx->hints[i], ctx))
+	{
+	  if (!*end)
+	    *end = ',';
+	  return;
+	}
+      if (!*end)
+	{
+	  grub_device_t dev;
+	  int ret;
+	  dev = grub_device_open (ctx->hints[i]);
+	  if (!dev)
+	    {
+	      if (!*end)
+		*end = ',';
+	      continue;
+	    }
+	  if (!dev->disk)
+	    {
+	      grub_device_close (dev);
+	      if (!*end)
+		*end = ',';
+	      continue;
+	    }
+	  ret = grub_partition_iterate (dev->disk, part_hook, ctx);
+	  if (!*end)
+	    *end = ',';
+	  grub_device_close (dev);
+	  if (ret)
+	    return;
+	}
+    }
+  grub_device_iterate (iterate_device, ctx);
+}
+
+void
+FUNC_NAME (const char *key, const char *var, int no_floppy,
+	   char **hints, unsigned nhints)
+{
+  struct search_ctx ctx = {
+    .key = key,
+    .var = var,
+    .no_floppy = no_floppy,
+    .hints = hints,
+    .nhints = nhints,
+    .count = 0,
+    .is_cache = 0
+  };
+  grub_fs_autoload_hook_t saved_autoload;
+
+  g_no_vtoyefi_part = 0;
+  if (grub_env_get("VTOY_SEARCH_NO_VTOYEFI"))
+  {
+      grub_snprintf(g_vtoyefi_dosname, sizeof(g_vtoyefi_dosname), "%s,msdos2", grub_env_get("vtoydev"));
+      grub_snprintf(g_vtoyefi_gptname, sizeof(g_vtoyefi_gptname), "%s,gpt2", grub_env_get("vtoydev"));
+      g_no_vtoyefi_part = 1;
+  }
+
+  /* First try without autoloading if we're setting variable. */
+  if (var)
+    {
+      saved_autoload = grub_fs_autoload_hook;
+      grub_fs_autoload_hook = 0;
+      try (&ctx);
+
+      /* Restore autoload hook.  */
+      grub_fs_autoload_hook = saved_autoload;
+
+      /* Retry with autoload if nothing found.  */
+      if (grub_errno == GRUB_ERR_NONE && ctx.count == 0)
+	try (&ctx);
+    }
+  else
+    try (&ctx);
+
+  if (grub_errno == GRUB_ERR_NONE && ctx.count == 0)
+    grub_error (GRUB_ERR_FILE_NOT_FOUND, "no such device: %s", key);
+}
+
+static grub_err_t
+grub_cmd_do_search (grub_command_t cmd __attribute__ ((unused)), int argc,
+		    char **args)
+{
+  if (argc == 0)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
+
+  FUNC_NAME (args[0], argc == 1 ? 0 : args[1], 0, (args + 2),
+	     argc > 2 ? argc - 2 : 0);
+
+  return grub_errno;
+}
+
+static grub_command_t cmd;
+
+#ifdef DO_SEARCH_FILE
+GRUB_MOD_INIT(search_fs_file)
+#elif defined (DO_SEARCH_FS_UUID)
+GRUB_MOD_INIT(search_fs_uuid)
+#else
+GRUB_MOD_INIT(search_label)
+#endif
+{
+  cmd =
+    grub_register_command (COMMAND_NAME, grub_cmd_do_search,
+			   N_("NAME [VARIABLE] [HINTS]"),
+			   HELP_MESSAGE);
+}
+
+#ifdef DO_SEARCH_FILE
+GRUB_MOD_FINI(search_fs_file)
+#elif defined (DO_SEARCH_FS_UUID)
+GRUB_MOD_FINI(search_fs_uuid)
+#else
+GRUB_MOD_FINI(search_label)
+#endif
+{
+  grub_unregister_command (cmd);
+}

GRUB2/MOD_SRC/grub-2.04/grub-core/fs/iso9660.c

@@ -735,6 +735,8 @@ grub_iso9660_iterate_dir (grub_fshelp_node_t dir,
 	  {
 	    if ((dirent.flags & FLAG_TYPE) == FLAG_TYPE_DIR)
 	      ctx.type = GRUB_FSHELP_DIR;
+        else if ((dirent.flags & FLAG_TYPE) == 3)
+          ctx.type = GRUB_FSHELP_DIR;
 	    else
 	      ctx.type = GRUB_FSHELP_REG;
 	  }

GRUB2/MOD_SRC/grub-2.04/grub-core/kern/term.c

@@ -0,0 +1,133 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2002,2003,2005,2007,2008,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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/term.h>
+#include <grub/err.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/env.h>
+#include <grub/time.h>
+
+struct grub_term_output *grub_term_outputs_disabled;
+struct grub_term_input *grub_term_inputs_disabled;
+struct grub_term_output *grub_term_outputs;
+struct grub_term_input *grub_term_inputs;
+
+/* Current color state.  */
+grub_uint8_t grub_term_normal_color = GRUB_TERM_DEFAULT_NORMAL_COLOR;
+grub_uint8_t grub_term_highlight_color = GRUB_TERM_DEFAULT_HIGHLIGHT_COLOR;
+
+void (*grub_term_poll_usb) (int wait_for_completion) = NULL;
+void (*grub_net_poll_cards_idle) (void) = NULL;
+
+/* Put a Unicode character.  */
+static void
+grub_putcode_dumb (grub_uint32_t code,
+		   struct grub_term_output *term)
+{
+  struct grub_unicode_glyph c =
+    {
+      .base = code,
+      .variant = 0,
+      .attributes = 0,
+      .ncomb = 0,
+      .estimated_width = 1
+    };
+
+  if (code == '\t' && term->getxy)
+    {
+      int n;
+
+      n = GRUB_TERM_TAB_WIDTH - ((term->getxy (term).x)
+				 % GRUB_TERM_TAB_WIDTH);
+      while (n--)
+	grub_putcode_dumb (' ', term);
+
+      return;
+    }
+
+  (term->putchar) (term, &c);
+  if (code == '\n')
+    grub_putcode_dumb ('\r', term);
+}
+
+static void
+grub_xputs_dumb (const char *str)
+{
+  for (; *str; str++)
+    {
+      grub_term_output_t term;
+      grub_uint32_t code = *str;
+      if (code > 0x7f)
+	code = '?';
+
+      FOR_ACTIVE_TERM_OUTPUTS(term)
+	grub_putcode_dumb (code, term);
+    }
+}
+
+void (*grub_xputs) (const char *str) = grub_xputs_dumb;
+
+int (*grub_key_remap)(int key) = NULL;
+int
+grub_getkey_noblock (void)
+{
+  grub_term_input_t term;
+
+  if (grub_term_poll_usb)
+    grub_term_poll_usb (0);
+
+  if (grub_net_poll_cards_idle)
+    grub_net_poll_cards_idle ();
+
+  FOR_ACTIVE_TERM_INPUTS(term)
+  {
+    int key = term->getkey (term);
+    if (grub_key_remap)
+        key = grub_key_remap(key);
+    if (key != GRUB_TERM_NO_KEY)
+      return key;
+  }
+
+  return GRUB_TERM_NO_KEY;
+}
+
+int
+grub_getkey (void)
+{
+  int ret;
+
+  grub_refresh ();
+
+  while (1)
+    {
+      ret = grub_getkey_noblock ();
+      if (ret != GRUB_TERM_NO_KEY)
+	return ret;
+      grub_cpu_idle ();
+    }
+}
+
+void
+grub_refresh (void)
+{
+  struct grub_term_output *term;
+
+  FOR_ACTIVE_TERM_OUTPUTS(term)
+    grub_term_refresh (term);
+}

GRUB2/MOD_SRC/grub-2.04/grub-core/term/setkey.c

@@ -0,0 +1,362 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2020  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/env.h>
+#include <grub/err.h>
+#include <grub/dl.h>
+#include <grub/extcmd.h>
+#include <grub/i18n.h>
+#include <grub/term.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+#define MAX_KEYMAP 255
+
+struct keymap
+{
+  int cnt;
+  int in[MAX_KEYMAP];
+  int out[MAX_KEYMAP];
+};
+
+static struct keymap setkey_keymap;
+
+struct keysym
+{
+  const char *name; /* the name in unshifted state */
+  int code;   /* scan code */
+};
+
+/* The table for key symbols. (from GRUB4DOS) */
+static struct keysym keysym_table[] =
+{
+  {"escape",        GRUB_TERM_ESC},    // ESC
+  {"exclam",        0x21},    //    '!'
+  {"at",            0x40},    //    '@'
+  {"numbersign",    0x23},    //    '#'
+  {"dollar",        0x24},    //    '$'
+  {"percent",       0x25},    //    '%'
+  {"caret",         0x5E},    //    '^'
+  {"ampersand",     0x26},    //    '&'
+  {"asterisk",      0x2A},    //    '*'
+  {"parenleft",     0x28},    //    '('
+  {"parenright",    0x29},    //    ')'
+  {"minus",         0x2D},    //    '-'
+  {"underscore",    0x5F},    //    '_'
+  {"equal",         0x3D},    //    '='
+  {"plus",          0x2B},    //    '+'
+  {"backspace",     GRUB_TERM_BACKSPACE},    // BS
+  {"ctrlbackspace", GRUB_TERM_CTRL | GRUB_TERM_BACKSPACE}, // (DEL)
+  {"tab",           GRUB_TERM_TAB},    // Tab
+  {"bracketleft",   0x5B},    // '['
+  {"braceleft",     0x7B},    //    '{'
+  {"bracketright",  0x5D},    // ']'
+  {"braceright",    0x7D},    //    '}'
+  {"enter",         0x0D},    // Enter
+  {"semicolon",     0x3B},    // ';'
+  {"colon",         0x3A},    //    ':'
+  {"quote",         0x27},    // '\''
+  {"doublequote",   0x22},    //    '"'
+  {"backquote",     0x60},    // '`'
+  {"tilde",         0x7E},    //    '~'
+  {"backslash",     0x5C},    // '\\'
+  {"bar",           0x7C},    //    '|'
+  {"comma",         0x2C},    // ','
+  {"less",          0x3C},    //    '<'
+  {"period",        0x2E},    // '.'
+  {"greater",       0x3E},    //    '>'
+  {"slash",         0x2F},    // '/'
+  {"question",      0x3F},    //    '?'
+  {"space",         0x20},    // Space
+  {"F1",            GRUB_TERM_KEY_F1},
+  {"F2",            GRUB_TERM_KEY_F2},
+  {"F3",            GRUB_TERM_KEY_F3},
+  {"F4",            GRUB_TERM_KEY_F4},
+  {"F5",            GRUB_TERM_KEY_F5},
+  {"F6",            GRUB_TERM_KEY_F6},
+  {"F7",            GRUB_TERM_KEY_F7},
+  {"F8",            GRUB_TERM_KEY_F8},
+  {"F9",            GRUB_TERM_KEY_F9},
+  {"F10",           GRUB_TERM_KEY_F10},
+  {"F11",           GRUB_TERM_KEY_F11},
+  {"F12",           GRUB_TERM_KEY_F12},
+  {"home",          GRUB_TERM_KEY_HOME},
+  {"uparrow",       GRUB_TERM_KEY_UP},
+  {"pageup",        GRUB_TERM_KEY_NPAGE},    // PgUp
+  {"leftarrow",     GRUB_TERM_KEY_LEFT},
+  {"center",        GRUB_TERM_KEY_CENTER},    // keypad center key
+  {"rightarrow",    GRUB_TERM_KEY_RIGHT},
+  {"end",           GRUB_TERM_KEY_END},
+  {"downarrow",     GRUB_TERM_KEY_DOWN},
+  {"pagedown",      GRUB_TERM_KEY_PPAGE},    // PgDn
+  {"insert",        GRUB_TERM_KEY_INSERT},    // Insert
+  {"delete",        GRUB_TERM_KEY_DC},    // Delete
+  {"shiftF1",       GRUB_TERM_SHIFT | GRUB_TERM_KEY_F1},
+  {"shiftF2",       GRUB_TERM_SHIFT | GRUB_TERM_KEY_F2},
+  {"shiftF3",       GRUB_TERM_SHIFT | GRUB_TERM_KEY_F3},
+  {"shiftF4",       GRUB_TERM_SHIFT | GRUB_TERM_KEY_F4},
+  {"shiftF5",       GRUB_TERM_SHIFT | GRUB_TERM_KEY_F5},
+  {"shiftF6",       GRUB_TERM_SHIFT | GRUB_TERM_KEY_F6},
+  {"shiftF7",       GRUB_TERM_SHIFT | GRUB_TERM_KEY_F7},
+  {"shiftF8",       GRUB_TERM_SHIFT | GRUB_TERM_KEY_F8},
+  {"shiftF9",       GRUB_TERM_SHIFT | GRUB_TERM_KEY_F9},
+  {"shiftF10",      GRUB_TERM_SHIFT | GRUB_TERM_KEY_F10},
+  {"shiftF11",      GRUB_TERM_SHIFT | GRUB_TERM_KEY_F11},
+  {"shiftF12",      GRUB_TERM_SHIFT | GRUB_TERM_KEY_F12},
+  {"ctrlF1",        GRUB_TERM_CTRL | GRUB_TERM_KEY_F1},
+  {"ctrlF2",        GRUB_TERM_CTRL | GRUB_TERM_KEY_F2},
+  {"ctrlF3",        GRUB_TERM_CTRL | GRUB_TERM_KEY_F3},
+  {"ctrlF4",        GRUB_TERM_CTRL | GRUB_TERM_KEY_F4},
+  {"ctrlF5",        GRUB_TERM_CTRL | GRUB_TERM_KEY_F5},
+  {"ctrlF6",        GRUB_TERM_CTRL | GRUB_TERM_KEY_F6},
+  {"ctrlF7",        GRUB_TERM_CTRL | GRUB_TERM_KEY_F7},
+  {"ctrlF8",        GRUB_TERM_CTRL | GRUB_TERM_KEY_F8},
+  {"ctrlF9",        GRUB_TERM_CTRL | GRUB_TERM_KEY_F9},
+  {"ctrlF10",       GRUB_TERM_CTRL | GRUB_TERM_KEY_F10},
+  {"ctrlF11",       GRUB_TERM_CTRL | GRUB_TERM_KEY_F11},
+  {"ctrlF12",       GRUB_TERM_CTRL | GRUB_TERM_KEY_F12},
+  // A=Alt or AltGr.    Provided by steve.
+  {"Aq",            GRUB_TERM_ALT | 0x71},
+  {"Aw",            GRUB_TERM_ALT | 0x77},
+  {"Ae",            GRUB_TERM_ALT | 0x65},
+  {"Ar",            GRUB_TERM_ALT | 0x72},
+  {"At",            GRUB_TERM_ALT | 0x74},
+  {"Ay",            GRUB_TERM_ALT | 0x79},
+  {"Au",            GRUB_TERM_ALT | 0x75},
+  {"Ai",            GRUB_TERM_ALT | 0x69},
+  {"Ao",            GRUB_TERM_ALT | 0x6F},
+  {"Ap",            GRUB_TERM_ALT | 0x70},
+  {"Aa",            GRUB_TERM_ALT | 0x61},
+  {"As",            GRUB_TERM_ALT | 0x73},
+  {"Ad",            GRUB_TERM_ALT | 0x64},
+  {"Af",            GRUB_TERM_ALT | 0x66},
+  {"Ag",            GRUB_TERM_ALT | 0x67},
+  {"Ah",            GRUB_TERM_ALT | 0x68},
+  {"Aj",            GRUB_TERM_ALT | 0x6A},
+  {"Ak",            GRUB_TERM_ALT | 0x6B},
+  {"Al",            GRUB_TERM_ALT | 0x6C},
+  {"Az",            GRUB_TERM_ALT | 0x7A},
+  {"Ax",            GRUB_TERM_ALT | 0x78},
+  {"Ac",            GRUB_TERM_ALT | 0x63},
+  {"Av",            GRUB_TERM_ALT | 0x76},
+  {"Ab",            GRUB_TERM_ALT | 0x62},
+  {"An",            GRUB_TERM_ALT | 0x6E},
+  {"Am",            GRUB_TERM_ALT | 0x6D},
+  {"A1",            GRUB_TERM_ALT | 0x31},
+  {"A2",            GRUB_TERM_ALT | 0x32},
+  {"A3",            GRUB_TERM_ALT | 0x33},
+  {"A4",            GRUB_TERM_ALT | 0x34},
+  {"A5",            GRUB_TERM_ALT | 0x35},
+  {"A6",            GRUB_TERM_ALT | 0x36},
+  {"A7",            GRUB_TERM_ALT | 0x37},
+  {"A8",            GRUB_TERM_ALT | 0x38},
+  {"A9",            GRUB_TERM_ALT | 0x39},
+  {"A0",            GRUB_TERM_ALT | 0x30},
+  //{"oem102",        0x5c},
+  //{"shiftoem102",   0x7c},
+  {"Aminus",        GRUB_TERM_ALT | 0x2D},
+  {"Aequal",        GRUB_TERM_ALT | 0x3D},
+  {"Abracketleft",  GRUB_TERM_ALT | 0x5B},
+  {"Abracketright", GRUB_TERM_ALT | 0x5D},
+  {"Asemicolon",    GRUB_TERM_ALT | 0x3B},
+  {"Aquote",        GRUB_TERM_ALT | 0x27},
+  {"Abackquote",    GRUB_TERM_ALT | 0x60},
+  {"Abackslash",    GRUB_TERM_ALT | 0x5C},
+  {"Acomma",        GRUB_TERM_ALT | 0x2C},
+  {"Aperiod",       GRUB_TERM_ALT | 0x2E},
+  {"Aslash",        GRUB_TERM_ALT | 0x2F},
+  {"Acolon",        GRUB_TERM_ALT | 0x3A},
+  {"Aplus",         GRUB_TERM_ALT | 0x2B},
+  {"Aless",         GRUB_TERM_ALT | 0x3C},
+  {"Aunderscore",   GRUB_TERM_ALT | 0x5F},
+  {"Agreater",      GRUB_TERM_ALT | 0x3E},
+  {"Aquestion",     GRUB_TERM_ALT | 0x3F},
+  {"Atilde",        GRUB_TERM_ALT | 0x7E},
+  {"Abraceleft",    GRUB_TERM_ALT | 0x7B},
+  {"Abar",          GRUB_TERM_ALT | 0x7C},
+  {"Abraceright",   GRUB_TERM_ALT | 0x7D},
+  {"Adoublequote",  GRUB_TERM_ALT | 0x22},
+};
+
+static int grub_keymap_getkey (int key)
+{
+  int i;
+  if (key == GRUB_TERM_NO_KEY)
+    return key;
+  if (setkey_keymap.cnt > MAX_KEYMAP)
+    setkey_keymap.cnt = MAX_KEYMAP;
+  for (i = 0; i < setkey_keymap.cnt; i++)
+  {
+    if (key == setkey_keymap.in[i])
+    {
+      key = setkey_keymap.out[i];
+      break;
+    }
+  }
+  return key;
+}
+
+static void
+grub_keymap_reset (void)
+{
+  grub_memset (&setkey_keymap, 0, sizeof (struct keymap));
+}
+
+static grub_err_t
+grub_keymap_add (int in, int out)
+{
+  if (in == GRUB_TERM_NO_KEY || out == GRUB_TERM_NO_KEY)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid key: %d -> %d", in, out);
+  if (setkey_keymap.cnt >= MAX_KEYMAP)
+    return grub_error (GRUB_ERR_OUT_OF_MEMORY,
+                       "keymap FULL %d", setkey_keymap.cnt);
+  setkey_keymap.in[setkey_keymap.cnt] = in;
+  setkey_keymap.out[setkey_keymap.cnt] = out;
+  setkey_keymap.cnt++;
+  return GRUB_ERR_NONE;
+}
+
+static void
+grub_keymap_enable (void)
+{
+  grub_key_remap = grub_keymap_getkey;
+}
+
+static void
+grub_keymap_disable (void)
+{
+  grub_key_remap = NULL;
+}
+
+static void
+grub_keymap_status (void)
+{
+  int i;
+  if (setkey_keymap.cnt > MAX_KEYMAP)
+    setkey_keymap.cnt = MAX_KEYMAP;
+  for (i = 0; i < setkey_keymap.cnt; i++)
+  {
+    grub_printf ("0x%x -> 0x%x\n", setkey_keymap.in[i], setkey_keymap.out[i]);
+  }
+}
+
+static const struct grub_arg_option options[] =
+{
+  {"reset", 'r', 0, N_("Reset keymap."), 0, 0},
+  {"enable", 'e', 0, N_("Enable keymap."), 0, 0},
+  {"disable", 'd', 0, N_("Disable keymap."), 0, 0},
+  {"status", 's', 0, N_("Display keymap."), 0, 0},
+  {0, 0, 0, 0, 0, 0}
+};
+
+enum options
+{
+  SETKEY_RESET,
+  SETKEY_ENABLE,
+  SETKEY_DISABLE,
+  SETKEY_STATUS,
+};
+
+static int
+ishex (const char *str)
+{
+  if (grub_strlen (str) < 3 || str[0] != '0')
+    return 0;
+  if (str[1] != 'x' && str[1] != 'X')
+    return 0;
+  return 1;
+}
+
+static int
+parse_key (const char *str)
+{
+  int i;
+  if (ishex (str))
+    return grub_strtol (str, NULL, 16);
+  if (grub_strlen (str) == 1)
+    return (int) str[0];
+  for (i = 0; i < (int) (sizeof (keysym_table) / sizeof (keysym_table[0])); i++)
+  {
+    if (grub_strcmp (str, keysym_table[i].name) == 0)
+      return keysym_table[i].code;
+  }
+  grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid key %s", str);
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_setkey (grub_extcmd_context_t ctxt, int argc, char **args)
+{
+  struct grub_arg_list *state = ctxt->state;
+  int in, out;
+  if (state[SETKEY_ENABLE].set)
+  {
+    grub_keymap_enable ();
+    goto out;
+  }
+  if (state[SETKEY_DISABLE].set)
+  {
+    grub_keymap_disable ();
+    goto out;
+  }
+  if (state[SETKEY_RESET].set)
+  {
+    grub_keymap_reset ();
+    goto out;
+  }
+  if (state[SETKEY_STATUS].set)
+  {
+    grub_keymap_status ();
+    goto out;
+  }
+  if (argc != 2)
+  {
+    grub_printf
+      ("Key names: 0-9, A-Z, a-z or escape, exclam, at, numbersign, dollar,"
+       "percent, caret, ampersand, asterisk, parenleft, parenright, minus,"
+       "underscore, equal, plus, backspace, tab, bracketleft, braceleft,"
+       "bracketright, braceright, enter, semicolon, colon, quote, doublequote,"
+       "backquote, tilde, backslash, bar, comma, less, period, greater,"
+       "slash, question, alt, space, delete, [ctrl|shift]F1-12."
+       "For Alt+ prefix with A, e.g. \'setkey at Aequal\'.");
+    goto out;
+  }
+  in = parse_key (args[1]);
+  out = parse_key (args[0]);
+  if (!in || !out)
+    goto out;
+  grub_keymap_add (in, out);
+out:
+  return grub_errno;
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT(setkey)
+{
+  cmd = grub_register_extcmd ("setkey", grub_cmd_setkey, 0, N_("NEW_KEY USA_KEY"),
+                              N_("Map default USA_KEY to NEW_KEY."), options);
+}
+
+GRUB_MOD_FINI(setkey)
+{
+  grub_unregister_extcmd (cmd);
+}

GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/miniz.h

@@ -0,0 +1,2 @@
+#define MINIZ_HEADER_FILE_ONLY
+#include "miniz.c"

GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy.c

@@ -41,10 +41,12 @@
 #include <grub/time.h>
 #include <grub/video.h>
 #include <grub/acpi.h>
-#include <grub/relocator.h>
 #include <grub/charset.h>
+#include <grub/crypto.h>
+#include <grub/lib/crc.h>
 #include <grub/ventoy.h>
 #include "ventoy_def.h"
+#include "miniz.h"
 
 GRUB_MOD_LICENSE ("GPLv3+");
 
@@ -60,6 +62,7 @@ int g_sort_case_sensitive = 0;
 int g_tree_view_menu_style = 0;
 static grub_file_t g_old_file;
 static int g_ventoy_last_entry_back;
+static grub_uint32_t g_ventoy_plat_data;
 
 char g_iso_path[256];
 char g_img_swap_tmp_buf[1024];
@@ -82,6 +85,8 @@ grub_uint32_t g_ventoy_cpio_size = 0;
 cpio_newc_header *g_ventoy_initrd_head = NULL;
 grub_uint8_t *g_ventoy_runtime_buf = NULL;
 
+int g_plugin_image_list = 0;
+
 ventoy_grub_param *g_grub_param = NULL;
 
 ventoy_guid  g_ventoy_guid = VENTOY_GUID;
@@ -94,7 +99,15 @@ char *g_wimiso_path = NULL;
 
 int g_vhdboot_enable = 0;
 
+grub_uint64_t g_conf_replace_offset = 0;
+grub_uint64_t g_svd_replace_offset = 0;
+conf_replace *g_conf_replace_node = NULL;
+grub_uint8_t *g_conf_replace_new_buf = NULL;
+int g_conf_replace_new_len = 0;
+int g_conf_replace_new_len_align = 0;
+
 ventoy_gpt_info *g_ventoy_part_info = NULL;
+grub_uint64_t g_ventoy_disk_size = 0;
 
 static char *g_tree_script_buf = NULL;
 static int g_tree_script_pos = 0;
@@ -438,8 +451,8 @@ static grub_err_t ventoy_cmd_break(grub_extcmd_context_t ctxt, int argc, char **
         grub_printf("    03/13: hook / (+cat log)\r\n");
         grub_printf("\r\n");
         grub_printf(" debug:\r\n");
-        grub_printf("    0: debug is on\r\n");
-        grub_printf("    1: debug is off\r\n");
+        grub_printf("    0: debug is off\r\n");
+        grub_printf("    1: debug is on\r\n");
         grub_printf("\r\n");
         VENTOY_CMD_RETURN(GRUB_ERR_NONE);
     }
@@ -965,7 +978,7 @@ static grub_err_t ventoy_cmd_check_compatible(grub_extcmd_context_t ctxt, int ar
 
     for (i = 0; i < (int)ARRAY_SIZE(files); i++)
     {
-        grub_snprintf(buf, sizeof(buf) - 1, "[ -e %s/%s ]", args[0], files[i]);
+        grub_snprintf(buf, sizeof(buf) - 1, "[ -e \"%s/%s\" ]", args[0], files[i]);
         if (0 == grub_script_execute_sourcecode(buf))
         {
             debug("file %s exist, ventoy_compatible YES\n", buf);
@@ -1018,6 +1031,11 @@ int ventoy_cmp_img(img_info *img1, img_info *img2)
     int c1 = 0;
     int c2 = 0;
 
+    if (g_plugin_image_list)
+    {
+        return (img1->plugin_list_index - img2->plugin_list_index);
+    }
+
     for (s1 = img1->name, s2 = img2->name; *s1 && *s2; s1++, s2++)
     {
         c1 = *s1;
@@ -1045,13 +1063,18 @@ int ventoy_cmp_img(img_info *img1, img_info *img2)
     return (c1 - c2);
 }
 
-static int ventoy_cmp_subdir(char *name1, char *name2)
+static int ventoy_cmp_subdir(img_iterator_node *node1, img_iterator_node *node2)
 {
     char *s1, *s2;
     int c1 = 0;
     int c2 = 0;
 
-    for (s1 = name1, s2 = name2; *s1 && *s2; s1++, s2++)
+    if (g_plugin_image_list)
+    {
+        return (node1->plugin_list_index - node2->plugin_list_index);
+    }
+
+    for (s1 = node1->dir, s2 = node2->dir; *s1 && *s2; s1++, s2++)
     {
         c1 = *s1;
         c2 = *s2;
@@ -1093,26 +1116,13 @@ void ventoy_swap_img(img_info *img1, img_info *img2)
 
 static int ventoy_img_name_valid(const char *filename, grub_size_t namelen)
 {
-    grub_size_t i;
+    (void)namelen;
     
     if (g_filt_dot_underscore_file && filename[0] == '.' && filename[1] == '_')
     {
         return 0;
     }
 
-    for (i = 0; i < namelen; i++)
-    {
-        if (filename[i] == ' ' || filename[i] == '\t')
-        {
-            return 0;
-        }
-
-        if ((grub_uint8_t)(filename[i]) >= 127)
-        {
-            return 0;
-        }
-    }
-
     return 1;
 }
 
@@ -1132,9 +1142,10 @@ static int ventoy_check_ignore_flag(const char *filename, const struct grub_dirh
 
 static int ventoy_colect_img_files(const char *filename, const struct grub_dirhook_info *info, void *data)
 {
-    int i = 0;
+    //int i = 0;
     int type = 0;
     int ignore = 0;
+    int index = 0;
     grub_size_t len;
     img_info *img;
     img_info *tail;
@@ -1162,9 +1173,21 @@ static int ventoy_colect_img_files(const char *filename, const struct grub_dirho
             return 0;
         }
 
+        if (g_plugin_image_list)
+        {
+            grub_snprintf(g_img_swap_tmp_buf, sizeof(g_img_swap_tmp_buf), "%s%s/", node->dir, filename);
+            index = ventoy_plugin_get_image_list_index(vtoy_class_directory, g_img_swap_tmp_buf);
+            if (index == 0)
+            {
+                debug("Directory %s not found in image_list plugin config...\n", g_img_swap_tmp_buf);
+                return 0; 
+            }
+        }
+
         new_node = grub_zalloc(sizeof(img_iterator_node));
         if (new_node)
         {
+            new_node->plugin_list_index = index;
             new_node->dirlen = grub_snprintf(new_node->dir, sizeof(new_node->dir), "%s%s/", node->dir, filename);
 
             g_enum_fs->fs_dir(g_enum_dev, new_node->dir, ventoy_check_ignore_flag, &ignore);
@@ -1248,21 +1271,24 @@ static int ventoy_colect_img_files(const char *filename, const struct grub_dirho
             return 0;
         }
 
+        if (g_plugin_image_list)
+        {
+            grub_snprintf(g_img_swap_tmp_buf, sizeof(g_img_swap_tmp_buf), "%s%s", node->dir, filename);
+            index = ventoy_plugin_get_image_list_index(vtoy_class_image_file, g_img_swap_tmp_buf);
+            if (index == 0)
+            {
+                debug("File %s not found in image_list plugin config...\n", g_img_swap_tmp_buf);
+                return 0; 
+            }
+        }
+        
         img = grub_zalloc(sizeof(img_info));
         if (img)
         {
             img->type = type;
+            img->plugin_list_index = index;
             grub_snprintf(img->name, sizeof(img->name), "%s", filename);
 
-            for (i = 0; i < (int)len; i++)
-            {
-                if (filename[i] == ' ' || filename[i] == '\t' || (0 == grub_isprint(filename[i])))
-                {
-                    img->name[i] = '*';
-                    img->unsupport = 1;
-                }
-            }
-            
             img->pathlen = grub_snprintf(img->path, sizeof(img->path), "%s%s", node->dir, img->name);
 
             img->size = info->size;
@@ -1330,6 +1356,32 @@ static int ventoy_colect_img_files(const char *filename, const struct grub_dirho
     return 0;
 }
 
+static int ventoy_arch_mode_init(void)
+{
+    #ifdef GRUB_MACHINE_EFI
+    if (grub_strcmp(GRUB_TARGET_CPU, "i386") == 0)
+    {
+        g_ventoy_plat_data = VTOY_PLAT_I386_UEFI;
+        grub_snprintf(g_arch_mode_suffix, sizeof(g_arch_mode_suffix), "%s", "ia32");
+    }
+    else if (grub_strcmp(GRUB_TARGET_CPU, "arm64") == 0)
+    {
+        g_ventoy_plat_data = VTOY_PLAT_ARM64_UEFI;
+        grub_snprintf(g_arch_mode_suffix, sizeof(g_arch_mode_suffix), "%s", "aa64");
+    }
+    else
+    {
+        g_ventoy_plat_data = VTOY_PLAT_X86_64_UEFI;
+        grub_snprintf(g_arch_mode_suffix, sizeof(g_arch_mode_suffix), "%s", "uefi");
+    }
+#else
+    g_ventoy_plat_data = VTOY_PLAT_X86_LEGACY;
+    grub_snprintf(g_arch_mode_suffix, sizeof(g_arch_mode_suffix), "%s", "legacy");
+#endif
+
+    return 0;
+}
+
 int ventoy_fill_data(grub_uint32_t buflen, char *buffer)
 {
     int len = GRUB_UINT_MAX;
@@ -1381,11 +1433,7 @@ int ventoy_fill_data(grub_uint32_t buflen, char *buffer)
 
     grub_memcpy(guidstr, &guid, sizeof(guid));
 
-    #if defined (GRUB_MACHINE_EFI)
-    puint2[0] = grub_swap_bytes32(0x55454649);
-    #else
-    puint2[0] = grub_swap_bytes32(0x42494f53);
-    #endif
+    puint2[0] = grub_swap_bytes32(g_ventoy_plat_data);    
 
     /* Easter egg :) It will be appreciated if you reserve it, but NOT mandatory. */
     #pragma GCC diagnostic push
@@ -1406,6 +1454,55 @@ int ventoy_fill_data(grub_uint32_t buflen, char *buffer)
     return len;
 }
 
+int ventoy_check_password(const vtoy_password *pwd, int retry)
+{
+    int offset;
+    char input[256];
+    grub_uint8_t md5[16];
+
+    while (retry--)
+    {
+        grub_memset(input, 0, sizeof(input));
+
+        grub_printf("Enter password: ");
+        grub_refresh();
+        
+        if (pwd->type == VTOY_PASSWORD_TXT)
+        {
+            grub_password_get(input, 128);
+            if (grub_strcmp(pwd->text, input) == 0)
+            {
+                return 0;
+            }
+        }
+        else if (pwd->type == VTOY_PASSWORD_MD5)
+        {
+            grub_password_get(input, 128);
+            grub_crypto_hash(GRUB_MD_MD5, md5, input, grub_strlen(input));
+            if (grub_memcmp(pwd->md5, md5, 16) == 0)
+            {
+                return 0;
+            }
+        }
+        else if (pwd->type == VTOY_PASSWORD_SALT_MD5)
+        {
+            offset = (int)grub_snprintf(input, 128, "%s", pwd->salt);
+            grub_password_get(input + offset, 128);
+            
+            grub_crypto_hash(GRUB_MD_MD5, md5, input, grub_strlen(input));
+            if (grub_memcmp(pwd->md5, md5, 16) == 0)
+            {
+                return 0;
+            }
+        }
+        
+        grub_printf("Invalid password!\n\n");
+        grub_refresh();
+    }
+
+    return 1;
+}
+
 static img_info * ventoy_get_min_iso(img_iterator_node *node)
 {
     img_info *minimg = NULL;
@@ -1435,7 +1532,7 @@ static img_iterator_node * ventoy_get_min_child(img_iterator_node *node)
 
     while (child && child->parent == node)
     {
-        if (child->select == 0 && (NULL == Minchild || ventoy_cmp_subdir(child->dir, Minchild->dir) < 0))
+        if (child->select == 0 && (NULL == Minchild || ventoy_cmp_subdir(child, Minchild) < 0))
         {
             Minchild = child;
         }
@@ -1596,15 +1693,14 @@ int ventoy_check_device_result(int ret)
     grub_env_set("VTOY_CHKDEV_RESULT_STRING", buf);
     grub_env_export("VTOY_CHKDEV_RESULT_STRING");
 
-    if (ret & 0x1000)
+    if (ret)
     {
         grub_printf(VTOY_WARNING"\n");
         grub_printf(VTOY_WARNING"\n");
         grub_printf(VTOY_WARNING"\n\n\n");
         
-        grub_printf("Unsatisfied conditions detected for Ventoy.\n\n");
-        grub_printf("This is NOT a standard Ventoy device and is NOT officially supported.\n\n");
-        grub_printf("Recommend to follow the instructions in https://www.ventoy.net to use Ventoy.\n");
+        grub_printf("This is NOT a standard Ventoy device and is NOT supported.\n\n");
+        grub_printf("You should follow the instructions in https://www.ventoy.net to use Ventoy.\n");
         
         grub_printf("\n\nWill exit after 10 seconds ...... ");
         grub_refresh();
@@ -1616,6 +1712,7 @@ int ventoy_check_device_result(int ret)
 
 int ventoy_check_device(grub_device_t dev)
 {
+    int workaround = 0;
     grub_file_t file;
     grub_uint64_t offset;
     char devname[64];
@@ -1631,13 +1728,31 @@ int ventoy_check_device(grub_device_t dev)
 
     if (0 == ventoy_check_file_exist("(%s,2)/ventoy/ventoy.cpio", dev->disk->name) ||
         0 == ventoy_check_file_exist("(%s,2)/grub/localboot.cfg", dev->disk->name) ||
-        0 == ventoy_check_file_exist("(%s,2)/tool/mount.exfat-fuse_64", dev->disk->name))
+        0 == ventoy_check_file_exist("(%s,2)/tool/mount.exfat-fuse_aarch64", dev->disk->name))
+    {
+        #ifndef GRUB_MACHINE_EFI
+        if (0 == ventoy_check_file_exist("(ventoydisk)/ventoy/ventoy.cpio", dev->disk->name) ||
+            0 == ventoy_check_file_exist("(ventoydisk)/grub/localboot.cfg", dev->disk->name) ||
+            0 == ventoy_check_file_exist("(ventoydisk)/tool/mount.exfat-fuse_aarch64", dev->disk->name))
         {
             return ventoy_check_device_result(2 | 0x1000);
         }
+        else
+        {
+            workaround = 1;
+        }
+        #endif
+    }
 
     /* We must have partition 2 */
+    if (workaround)
+    {
+        file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", "(ventoydisk)/ventoy/ventoy.cpio");
+    }
+    else
+    {
         file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "(%s,2)/ventoy/ventoy.cpio", dev->disk->name);        
+    }
     if (!file)
     {
         return ventoy_check_device_result(3 | 0x1000);
@@ -1655,37 +1770,68 @@ int ventoy_check_device(grub_device_t dev)
         return ventoy_check_device_result(5);
     }
 
+    if (workaround)
+    {
+        if (grub_strncmp(g_ventoy_part_info->Head.Signature, "EFI PART", 8) == 0)
+        {
+            ventoy_gpt_part_tbl *PartTbl = g_ventoy_part_info->PartTbl;
+            if (PartTbl[1].StartLBA != PartTbl[0].LastLBA + 1 ||
+                (PartTbl[1].LastLBA + 1 - PartTbl[1].StartLBA) != 65536)
+            {
+                grub_file_close(file);
+                return ventoy_check_device_result(6);
+            }
+        }
+        else
+        {
+            ventoy_part_table *PartTbl = g_ventoy_part_info->MBR.PartTbl;
+            if (PartTbl[1].StartSectorId != PartTbl[0].StartSectorId + PartTbl[0].SectorCount ||
+                PartTbl[1].SectorCount != 65536)
+            {
+                grub_file_close(file);
+                return ventoy_check_device_result(6);
+            }
+        }
+    }
+    else
+    {
         offset = partition->start + partition->len;
         partition = file->device->disk->partition;
         if ((partition->number != 1) || (partition->len != 65536) || (offset != partition->start))
         {
             grub_file_close(file);
-        return ventoy_check_device_result(6);
+            return ventoy_check_device_result(7);
         }
+    }
+
     grub_file_close(file);
 
+    if (workaround == 0)
+    {
         grub_snprintf(devname, sizeof(devname), "%s,2", dev->disk->name);
         dev2 = grub_device_open(devname);
         if (!dev2)
         {
-        return ventoy_check_device_result(7);
+            return ventoy_check_device_result(8);
         }
 
         fs = grub_fs_probe(dev2);
         if (!fs)
         {
             grub_device_close(dev2);
-        return ventoy_check_device_result(8);
+            return ventoy_check_device_result(9);
         }
 
         fs->fs_label(dev2, &label);
         if ((!label) || grub_strncmp("VTOYEFI", label, 7))
         {
             grub_device_close(dev2);
-        return ventoy_check_device_result(9);
+            return ventoy_check_device_result(10);
         }
 
         grub_device_close(dev2);    
+    }
+    
     return ventoy_check_device_result(0);
 }
 
@@ -1695,6 +1841,7 @@ static int ventoy_set_default_menu(void)
     char *pos = NULL;
     char *end = NULL;
     char *def = NULL;
+    const char *strdata = NULL;
     img_info *cur = NULL;
     img_info *default_node = NULL;
     const char *default_image = NULL;
@@ -1732,7 +1879,20 @@ static int ventoy_set_default_menu(void)
 
             vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos, "set default=%c", '\'');
 
+            strdata = ventoy_get_env("VTOY_DEFAULT_SEARCH_ROOT");
+            if (strdata && strdata[0] == '/')
+            {
+                pos = def + grub_strlen(strdata);
+                if (*pos == '/')
+                {
+                    pos++;
+                }
+            }
+            else
+            {
                 pos = def + 1;
+            }
+
             while ((end = grub_strchr(pos, '/')) != NULL)
             {
                 *end = 0;                
@@ -2023,6 +2183,8 @@ static grub_err_t ventoy_cmd_chosen_img_path(grub_extcmd_context_t ctxt, int arg
         grub_env_set(args[1], value);        
     }
 
+    g_svd_replace_offset = 0;
+
     VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 }
 
@@ -2311,6 +2473,9 @@ static grub_err_t ventoy_cmd_img_sector(grub_extcmd_context_t ctxt, int argc, ch
         return grub_error(GRUB_ERR_BAD_ARGUMENT, "Can't open file %s\n", args[0]); 
     }
 
+    g_conf_replace_node = NULL;
+    g_conf_replace_offset = 0;
+    
     if (g_img_chunk_list.chunk)
     {
         grub_free(g_img_chunk_list.chunk);
@@ -2349,6 +2514,75 @@ static grub_err_t ventoy_cmd_img_sector(grub_extcmd_context_t ctxt, int argc, ch
     VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 }
 
+static grub_err_t ventoy_select_conf_replace(grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    grub_uint64_t offset = 0;
+    grub_uint32_t align = 0;
+    grub_file_t file = NULL;
+    conf_replace *node = NULL;
+        
+    (void)ctxt;
+    (void)argc;
+    (void)args;
+
+    debug("select conf replace argc:%d\n", argc);
+
+    if (argc < 2)
+    {
+        return 0;
+    }
+
+    node = ventoy_plugin_find_conf_replace(args[1]);
+    if (!node)
+    {
+        debug("Conf replace not found for %s\n", args[1]);
+        goto end;
+    }
+
+    debug("Find conf replace for %s\n", args[1]);
+
+    file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "(loop)%s", node->orgconf);
+    if (!file)
+    {
+        debug("<(loop)%s> NOT exist\n", node->orgconf);
+        goto end;
+    }
+
+    offset = grub_iso9660_get_last_file_dirent_pos(file);
+    grub_file_close(file);    
+
+    file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s%s", args[0], node->newconf);
+    if (!file)
+    {
+        debug("New config file <%s%s> NOT exist\n", args[0], node->newconf);
+        goto end;
+    }
+
+    align = ((int)file->size + 2047) / 2048 * 2048;
+
+    if (align > vtoy_max_replace_file_size)
+    {
+        debug("New config file <%s%s> too big\n", args[0], node->newconf);
+        goto end;
+    }
+
+    grub_file_read(file, g_conf_replace_new_buf, file->size);
+    g_conf_replace_new_len = (int)file->size;
+    g_conf_replace_new_len_align = align;
+
+    g_conf_replace_node = node;
+    g_conf_replace_offset = offset + 2;
+
+    debug("conf_replace OK: newlen: %d\n", g_conf_replace_new_len);
+
+end:
+    if (file)
+    {
+        grub_file_close(file);        
+    }
+    VENTOY_CMD_RETURN(GRUB_ERR_NONE);
+}
+
 static grub_err_t ventoy_cmd_sel_auto_install(grub_extcmd_context_t ctxt, int argc, char **args)
 {
     int i = 0;
@@ -2501,67 +2735,6 @@ static grub_err_t ventoy_cmd_dump_img_sector(grub_extcmd_context_t ctxt, int arg
     VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 }
 
-#ifdef GRUB_MACHINE_EFI
-static grub_err_t ventoy_cmd_relocator_chaindata(grub_extcmd_context_t ctxt, int argc, char **args)
-{
-    (void)ctxt;
-    (void)argc;
-    (void)args;
-    return 0;
-}
-#else
-static grub_err_t ventoy_cmd_relocator_chaindata(grub_extcmd_context_t ctxt, int argc, char **args)
-{
-    int rc = 0;
-    ulong chain_len = 0;
-    char *chain_data = NULL;
-    char *relocator_addr = NULL;
-    grub_relocator_chunk_t ch;
-    struct grub_relocator *relocator = NULL;
-    char envbuf[64] = { 0 };
-
-    (void)ctxt;
-    (void)argc;
-    (void)args;
-    
-    if (argc != 2)
-    {
-        return 1;
-    }
-
-    chain_data = (char *)grub_strtoul(args[0], NULL, 16);
-    chain_len = grub_strtoul(args[1], NULL, 10);
-
-    relocator = grub_relocator_new ();
-    if (!relocator)
-    {
-        debug("grub_relocator_new failed %p %lu\n", chain_data, chain_len);
-        return 1;
-    }
-
-    rc = grub_relocator_alloc_chunk_addr (relocator, &ch,
-					   0x100000, // GRUB_LINUX_BZIMAGE_ADDR,
-					   chain_len);
-    if (rc)
-    {
-        debug("grub_relocator_alloc_chunk_addr failed %d %p %lu\n", rc, chain_data, chain_len);
-        grub_relocator_unload (relocator);
-        return 1;
-    }
-
-    relocator_addr = get_virtual_current_address(ch);
-
-    grub_memcpy(relocator_addr, chain_data, chain_len);
-    
-    grub_relocator_unload (relocator);
-
-    grub_snprintf(envbuf, sizeof(envbuf), "0x%lx", (unsigned long)relocator_addr);
-    grub_env_set("vtoy_chain_relocator_addr", envbuf);
-
-    VENTOY_CMD_RETURN(GRUB_ERR_NONE);
-}
-#endif
-
 static grub_err_t ventoy_cmd_test_block_list(grub_extcmd_context_t ctxt, int argc, char **args)
 {
     grub_uint32_t i;
@@ -2678,7 +2851,7 @@ static grub_err_t ventoy_cmd_dump_img_list(grub_extcmd_context_t ctxt, int argc,
 
     while (cur)
     {
-        grub_printf("path:<%s> id=%d\n", cur->path, cur->id);
+        grub_printf("path:<%s> id=%d list_index=%d\n", cur->path, cur->id, cur->plugin_list_index);
         grub_printf("name:<%s>\n\n", cur->name);
         cur = cur->next;
     }
@@ -3280,6 +3453,22 @@ static grub_err_t ventoy_cmd_pop_last_entry(grub_extcmd_context_t ctxt, int argc
     return 0;
 }
 
+grub_uint64_t ventoy_get_part1_size(ventoy_gpt_info *gpt)
+{
+    grub_uint64_t sectors;
+    
+    if (grub_strncmp(gpt->Head.Signature, "EFI PART", 8) == 0)
+    {
+        sectors = gpt->PartTbl[0].LastLBA + 1 - gpt->PartTbl[0].StartLBA;
+    }
+    else
+    {
+        sectors = gpt->MBR.PartTbl[0].SectorCount;
+    }
+
+    return sectors * 512;
+}
+
 static int ventoy_lib_module_callback(const char *filename, const struct grub_dirhook_info *info, void *data)
 {
     const char *pos = filename + 1;
@@ -3382,6 +3571,8 @@ static grub_err_t ventoy_cmd_load_part_table(grub_extcmd_context_t ctxt, int arg
         return 1;
     }
 
+    g_ventoy_disk_size = disk->total_sectors * (1U << disk->log_sector_size);
+
     grub_disk_read(disk, 0, 0, sizeof(ventoy_gpt_info), g_ventoy_part_info);
     grub_disk_close(disk);
 
@@ -3393,7 +3584,7 @@ static grub_err_t ventoy_cmd_load_part_table(grub_extcmd_context_t ctxt, int arg
         ret = ventoy_check_device(dev);
         grub_device_close(dev);
 
-        if (ret & 0x1000)
+        if (ret)
         {
             grub_exit();            
         }
@@ -3724,14 +3915,14 @@ int ventoy_is_file_exist(const char *fmt, ...)
     char *pos = NULL;
     char buf[256] = {0};
 
-    grub_snprintf(buf, sizeof(buf), "%s", "[ -f ");
-    pos = buf + 5;
+    grub_snprintf(buf, sizeof(buf), "%s", "[ -f \"");
+    pos = buf + 6;
 
     va_start (ap, fmt);
     len = grub_vsnprintf(pos, 255, fmt, ap);
     va_end (ap);
 
-    grub_strncpy(pos + len, " ]", 2);
+    grub_strncpy(pos + len, "\" ]", 3);
 
     debug("script exec %s\n", buf);
 
@@ -3750,14 +3941,14 @@ int ventoy_is_dir_exist(const char *fmt, ...)
     char *pos = NULL;
     char buf[256] = {0};
 
-    grub_snprintf(buf, sizeof(buf), "%s", "[ -d ");
-    pos = buf + 5;
+    grub_snprintf(buf, sizeof(buf), "%s", "[ -d \"");
+    pos = buf + 6;
 
     va_start (ap, fmt);
     len = grub_vsnprintf(pos, 255, fmt, ap);
     va_end (ap);
 
-    grub_strncpy(pos + len, " ]", 2);
+    grub_strncpy(pos + len, "\" ]", 3);
 
     debug("script exec %s\n", buf);
 
@@ -3769,6 +3960,47 @@ int ventoy_is_dir_exist(const char *fmt, ...)
     return 0;
 }
 
+int ventoy_gzip_compress(void *mem_in, int mem_in_len, void *mem_out, int mem_out_len)
+{
+	mz_stream s;
+    grub_uint8_t *outbuf;
+    grub_uint8_t gzHdr[10] = 
+    {
+		0x1F, 0x8B,	/* magic */
+		8,		    /* z method */
+		0,		    /* flags */
+		0,0,0,0,	/* mtime */
+		4,		    /* xfl */
+		3,		    /* OS */
+	};
+
+	grub_memset(&s, 0, sizeof(mz_stream));
+
+    mz_deflateInit2(&s, 1, MZ_DEFLATED, -MZ_DEFAULT_WINDOW_BITS, 6, MZ_DEFAULT_STRATEGY);
+    
+    outbuf = (grub_uint8_t *)mem_out;
+
+    mem_out_len -= sizeof(gzHdr) + 8;
+    grub_memcpy(outbuf, gzHdr, sizeof(gzHdr));
+    outbuf += sizeof(gzHdr);
+
+    s.avail_in = mem_in_len;
+    s.next_in = mem_in;
+
+    s.avail_out = mem_out_len;
+    s.next_out = outbuf;
+
+    mz_deflate(&s, MZ_FINISH);
+
+    mz_deflateEnd(&s);
+
+    outbuf += s.total_out;
+    *(grub_uint32_t *)outbuf = grub_getcrc32c(0, outbuf, s.total_out);
+    *(grub_uint32_t *)(outbuf + 4) = (grub_uint32_t)(s.total_out);
+
+    return s.total_out + sizeof(gzHdr) + 8;    
+}
+
 static int ventoy_env_init(void)
 {
     char buf[64];
@@ -3778,6 +4010,7 @@ static int ventoy_env_init(void)
     g_part_list_buf = grub_malloc(VTOY_PART_BUF_LEN);
     g_tree_script_buf = grub_malloc(VTOY_MAX_SCRIPT_BUF);
     g_list_script_buf = grub_malloc(VTOY_MAX_SCRIPT_BUF);
+    g_conf_replace_new_buf = grub_malloc(vtoy_max_replace_file_size); 
 
     ventoy_filt_register(0, ventoy_wrapper_open);
 
@@ -3819,6 +4052,7 @@ static cmd_para ventoy_cmds[] =
     { "vt_raw_chain_data", ventoy_cmd_raw_chain_data, 0, NULL, "", "", NULL },
     { "vt_get_vtoy_type", ventoy_cmd_get_vtoy_type, 0, NULL, "", "", NULL },
 
+    { "vt_skip_svd", ventoy_cmd_skip_svd, 0, NULL, "", "", NULL },
     { "vt_cpio_busybox64", ventoy_cmd_cpio_busybox_64, 0, NULL, "", "", NULL },
     { "vt_load_cpio", ventoy_cmd_load_cpio, 0, NULL, "", "", NULL },
     { "vt_trailer_cpio", ventoy_cmd_trailer_cpio, 0, NULL, "", "", NULL },
@@ -3846,6 +4080,7 @@ static cmd_para ventoy_cmds[] =
     { "vt_dump_persistence", ventoy_cmd_dump_persistence, 0, NULL, "", "", NULL },
     { "vt_select_auto_install", ventoy_cmd_sel_auto_install, 0, NULL, "", "", NULL },
     { "vt_select_persistence", ventoy_cmd_sel_persistence, 0, NULL, "", "", NULL },
+    { "vt_select_conf_replace", ventoy_select_conf_replace, 0, NULL, "", "", NULL },
 
     { "vt_iso9660_nojoliet", ventoy_cmd_iso9660_nojoliet, 0, NULL, "", "", NULL },
     { "vt_is_udf", ventoy_cmd_is_udf, 0, NULL, "", "", NULL },
@@ -3871,16 +4106,17 @@ static cmd_para ventoy_cmds[] =
     { "vt_windows_locate_wim_patch", ventoy_cmd_locate_wim_patch, 0, NULL, "", "", NULL },
     { "vt_windows_count_wim_patch", ventoy_cmd_wim_patch_count, 0, NULL, "", "", NULL },
     { "vt_dump_wim_patch", ventoy_cmd_dump_wim_patch, 0, NULL, "", "", NULL },
+    { "vt_wim_check_bootable", ventoy_cmd_wim_check_bootable, 0, NULL, "", "", NULL },
     { "vt_wim_chain_data", ventoy_cmd_wim_chain_data, 0, NULL, "", "", NULL },
 
     { "vt_add_replace_file", ventoy_cmd_add_replace_file, 0, NULL, "", "", NULL },
-    { "vt_relocator_chaindata", ventoy_cmd_relocator_chaindata, 0, NULL, "", "", NULL },
     { "vt_test_block_list", ventoy_cmd_test_block_list, 0, NULL, "", "", NULL },
     { "vt_file_exist_nocase", ventoy_cmd_file_exist_nocase, 0, NULL, "", "", NULL },
 
     
     { "vt_load_plugin", ventoy_cmd_load_plugin, 0, NULL, "", "", NULL },
     { "vt_check_plugin_json", ventoy_cmd_plugin_check_json, 0, NULL, "", "", NULL },
+    { "vt_check_password", ventoy_cmd_check_password, 0, NULL, "", "", NULL },
     
     { "vt_1st_line", ventoy_cmd_read_1st_line, 0, NULL, "", "", NULL },
     { "vt_file_strstr", ventoy_cmd_file_strstr, 0, NULL, "", "", NULL },
@@ -3894,6 +4130,8 @@ static cmd_para ventoy_cmds[] =
     { "vt_unix_reset", ventoy_cmd_unix_reset, 0, NULL, "", "", NULL },
     { "vt_unix_replace_conf", ventoy_cmd_unix_replace_conf, 0, NULL, "", "", NULL },
     { "vt_unix_replace_ko", ventoy_cmd_unix_replace_ko, 0, NULL, "", "", NULL },
+    { "vt_unix_fill_image_desc", ventoy_cmd_unix_fill_image_desc, 0, NULL, "", "", NULL },
+    { "vt_unix_gzip_new_ko", ventoy_cmd_unix_gzip_newko, 0, NULL, "", "", NULL },
     { "vt_unix_chain_data", ventoy_cmd_unix_chain_data, 0, NULL, "", "", NULL },
 
     { "vt_img_hook_root", ventoy_cmd_img_hook_root, 0, NULL, "", "", NULL },
@@ -3911,6 +4149,8 @@ GRUB_MOD_INIT(ventoy)
 
     ventoy_env_init();
 
+    ventoy_arch_mode_init();
+    
     for (i = 0; i < ARRAY_SIZE(ventoy_cmds); i++)
     {
         cur = ventoy_cmds + i;

GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_def.h

@@ -52,6 +52,20 @@
 
 #define VTOY_WARNING  "!!!!!!!!!!!!! WARNING !!!!!!!!!!!!!"
 
+#define VTOY_PLAT_I386_UEFI     0x49413332
+#define VTOY_PLAT_ARM64_UEFI    0x41413634
+#define VTOY_PLAT_X86_64_UEFI   0x55454649
+#define VTOY_PLAT_X86_LEGACY    0x42494f53
+
+#define VTOY_PWD_CORRUPTED(err) \
+{\
+    grub_printf("\n\n Password corrupted, will reboot after 5 seconds.\n\n"); \
+    grub_refresh(); \
+    grub_sleep(5); \
+    grub_exit(); \
+    return (err);\
+}
+
 typedef struct ventoy_initrd_ctx
 {
     const char *path_prefix;
@@ -172,6 +186,7 @@ typedef struct img_info
     
     int id;
     int type;
+    int plugin_list_index;
     grub_uint64_t size;
     int select;
     int unsupport;
@@ -192,6 +207,8 @@ typedef struct img_iterator_node
     int done;
     int select;
 
+    int plugin_list_index;
+
     struct img_iterator_node *parent;
     struct img_iterator_node *firstchild;
     
@@ -236,6 +253,7 @@ extern ventoy_guid  g_ventoy_guid;
 extern ventoy_img_chunk_list g_img_chunk_list;
 extern ventoy_img_chunk_list g_wimiso_chunk_list;
 extern char *g_wimiso_path;
+extern char g_arch_mode_suffix[64];
 
 extern int g_ventoy_debug;
 void ventoy_debug(const char *fmt, ...);
@@ -487,6 +505,7 @@ grub_err_t ventoy_cmd_linux_locate_initrd(grub_extcmd_context_t ctxt, int argc,
 grub_err_t ventoy_cmd_initrd_count(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_valid_initrd_count(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_load_cpio(grub_extcmd_context_t ctxt, int argc, char **args);
+grub_err_t ventoy_cmd_skip_svd(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_cpio_busybox_64(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_trailer_cpio(grub_extcmd_context_t ctxt, int argc, char **args);
 int ventoy_cpio_newc_fill_head(void *buf, int filesize, const void *filedata, const char *name);
@@ -499,6 +518,7 @@ grub_err_t ventoy_cmd_load_plugin(grub_extcmd_context_t ctxt, int argc, char **a
 grub_err_t ventoy_cmd_wimdows_reset(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_windows_chain_data(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_wim_chain_data(grub_extcmd_context_t ctxt, int argc, char **args);
+grub_err_t ventoy_cmd_wim_check_bootable(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_dump_wim_patch(grub_extcmd_context_t ctxt, int argc, char **args);
 
 VTOY_JSON *vtoy_json_find_item
@@ -722,6 +742,24 @@ typedef struct install_template
     struct install_template *next;
 }install_template;
 
+typedef struct dudfile
+{
+    int size;
+    char *buf;
+}dudfile;
+
+typedef struct dud
+{
+    int pathlen;
+    char isopath[256];
+
+    int dudnum;
+    file_fullpath *dudpath;
+    dudfile *files;
+
+    struct dud *next;
+}dud;
+
 typedef struct persistence_config
 {
     int pathlen;
@@ -761,6 +799,17 @@ typedef struct menu_class
     struct menu_class *next;
 }menu_class;
 
+#define vtoy_max_replace_file_size  (2 * 1024 * 1024)
+typedef struct conf_replace
+{
+    int pathlen;
+    char isopath[256];
+    char orgconf[256];
+    char newconf[256];
+
+    struct conf_replace *next;
+}conf_replace;
+
 typedef struct injection_config
 {
     int pathlen;
@@ -778,6 +827,37 @@ typedef struct auto_memdisk
     struct auto_memdisk *next;
 }auto_memdisk;
 
+typedef struct image_list
+{
+    int pathlen;
+    char isopath[256];
+
+    struct image_list *next;
+}image_list;
+
+#define VTOY_PASSWORD_NONE       0
+#define VTOY_PASSWORD_TXT        1
+#define VTOY_PASSWORD_MD5        2
+#define VTOY_PASSWORD_SALT_MD5   3
+
+typedef struct vtoy_password
+{
+    int type;
+    char text[128];
+    char salt[64];
+    grub_uint8_t md5[16];
+}vtoy_password;
+
+typedef struct menu_password
+{
+    int pathlen;
+    char isopath[256];
+
+    vtoy_password password;
+
+    struct menu_password *next;
+}menu_password;
+
 extern int g_ventoy_menu_esc;
 extern int g_ventoy_suppress_esc;
 extern int g_ventoy_last_entry;
@@ -787,7 +867,15 @@ extern int g_ventoy_iso_uefi_drv;
 extern int g_ventoy_case_insensitive;
 extern grub_uint8_t g_ventoy_chain_type;
 extern int g_vhdboot_enable;
+extern int g_plugin_image_list;
 extern ventoy_gpt_info *g_ventoy_part_info;
+extern grub_uint64_t g_conf_replace_offset;
+extern grub_uint64_t g_svd_replace_offset;
+extern conf_replace *g_conf_replace_node;
+extern grub_uint8_t *g_conf_replace_new_buf;
+extern int g_conf_replace_new_len;
+extern int g_conf_replace_new_len_align;
+extern grub_uint64_t g_ventoy_disk_size;
 
 #define ventoy_unix_fill_virt(new_data, new_len) \
 { \
@@ -819,10 +907,15 @@ const char * ventoy_plugin_get_injection(const char *isopath);
 const char * ventoy_plugin_get_menu_alias(int type, const char *isopath);
 const char * ventoy_plugin_get_menu_class(int type, const char *name);
 int ventoy_plugin_check_memdisk(const char *isopath);
+int ventoy_plugin_get_image_list_index(int type, const char *name);
+conf_replace * ventoy_plugin_find_conf_replace(const char *iso);
+dud * ventoy_plugin_find_dud(const char *iso);
+int ventoy_plugin_load_dud(dud *node, const char *isopart);
 int ventoy_get_block_list(grub_file_t file, ventoy_img_chunk_list *chunklist, grub_disk_addr_t start);
 int ventoy_check_block_list(grub_file_t file, ventoy_img_chunk_list *chunklist, grub_disk_addr_t start);
 void ventoy_plugin_dump_persistence(void);
 grub_err_t ventoy_cmd_plugin_check_json(grub_extcmd_context_t ctxt, int argc, char **args);
+grub_err_t ventoy_cmd_check_password(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_linux_get_main_initrd_index(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_collect_wim_patch(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_wim_patch_count(grub_extcmd_context_t ctxt, int argc, char **args);
@@ -832,6 +925,8 @@ int ventoy_get_disk_guid(const char *filename, grub_uint8_t *guid, grub_uint8_t
 grub_err_t ventoy_cmd_unix_reset(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_unix_replace_conf(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_unix_replace_ko(grub_extcmd_context_t ctxt, int argc, char **args);
+grub_err_t ventoy_cmd_unix_fill_image_desc(grub_extcmd_context_t ctxt, int argc, char **args);
+grub_err_t ventoy_cmd_unix_gzip_newko(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_unix_freebsd_ver(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_parse_freenas_ver(grub_extcmd_context_t ctxt, int argc, char **args);
 int ventoy_check_device_result(int ret);
@@ -841,6 +936,9 @@ grub_err_t ventoy_cmd_load_vhdboot(grub_extcmd_context_t ctxt, int argc, char **
 grub_err_t ventoy_cmd_patch_vhdboot(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_raw_chain_data(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_get_vtoy_type(grub_extcmd_context_t ctxt, int argc, char **args);
+int ventoy_check_password(const vtoy_password *pwd, int retry);
+int ventoy_gzip_compress(void *mem_in, int mem_in_len, void *mem_out, int mem_out_len);
+grub_uint64_t ventoy_get_part1_size(ventoy_gpt_info *gpt);
 
 #endif /* __VENTOY_DEF_H__ */
 

GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_linux.c

@@ -333,6 +333,7 @@ end:
 static grub_err_t ventoy_grub_cfg_initrd_collect(const char *fileName)
 {
     int i = 0;
+    int dollar = 0;
     grub_file_t file = NULL;
     char *buf = NULL;
     char *start = NULL;
@@ -389,12 +390,17 @@ static grub_err_t ventoy_grub_cfg_initrd_collect(const char *fileName)
                 break;
             }
 
+            dollar = 0;
             for (i = 0; i < 255 && (0 == ventoy_is_word_end(*start)); i++)
             {
                 img->name[i] = *start++;
+                if (img->name[i] == '$')
+                {
+                    dollar = 1;
+                }
             }
 
-            if (ventoy_find_initrd_by_name(g_initrd_img_list, img->name))
+            if (dollar == 1 || ventoy_find_initrd_by_name(g_initrd_img_list, img->name))
             {
                 grub_free(img);
             }
@@ -625,9 +631,30 @@ int ventoy_cpio_newc_fill_head(void *buf, int filesize, const void *filedata, co
     return headlen;
 }
 
+static grub_uint32_t ventoy_linux_get_virt_chunk_count(void)
+{
+    grub_uint32_t count = g_valid_initrd_count;
+    
+    if (g_conf_replace_offset > 0)
+    {
+        count++;
+    }
+    
+    return count;
+}
+
 static grub_uint32_t ventoy_linux_get_virt_chunk_size(void)
 {
-    return (sizeof(ventoy_virt_chunk) + g_ventoy_cpio_size) * g_valid_initrd_count;
+    grub_uint32_t size;
+    
+    size = (sizeof(ventoy_virt_chunk) + g_ventoy_cpio_size) * g_valid_initrd_count;
+    
+    if (g_conf_replace_offset > 0)
+    {
+        size += sizeof(ventoy_virt_chunk) + g_conf_replace_new_len_align;
+    }
+
+    return size;
 }
 
 static void ventoy_linux_fill_virt_data(    grub_uint64_t isosize, ventoy_chain_head *chain)
@@ -646,7 +673,7 @@ static void ventoy_linux_fill_virt_data(    grub_uint64_t isosize, ventoy_chain_
     sector = (isosize + 2047) / 2048;
     cpio_secs = g_ventoy_cpio_size / 2048;
 
-    offset = g_valid_initrd_count * sizeof(ventoy_virt_chunk);
+    offset = ventoy_linux_get_virt_chunk_count() * sizeof(ventoy_virt_chunk);
     cur = (ventoy_virt_chunk *)override;
 
     for (node = g_initrd_img_list; node; node = node->next)
@@ -682,12 +709,61 @@ static void ventoy_linux_fill_virt_data(    grub_uint64_t isosize, ventoy_chain_
         cur++;
     }
 
+    if (g_conf_replace_offset > 0)
+    {
+        cpio_secs = g_conf_replace_new_len_align / 2048;
+    
+        cur->mem_sector_start   = sector;
+        cur->mem_sector_end     = cur->mem_sector_start + cpio_secs;
+        cur->mem_sector_offset  = offset;
+        cur->remap_sector_start = 0;
+        cur->remap_sector_end   = 0;
+        cur->org_sector_start   = 0;
+
+        grub_memcpy(override + offset, g_conf_replace_new_buf, g_conf_replace_new_len);
+
+        chain->virt_img_size_in_bytes += g_conf_replace_new_len_align;
+
+        offset += g_conf_replace_new_len_align;
+        sector += cpio_secs;
+        cur++;
+    }
+
     return;
 }
 
+static grub_uint32_t ventoy_linux_get_override_chunk_count(void)
+{
+    grub_uint32_t count = g_valid_initrd_count;
+    
+    if (g_conf_replace_offset > 0)
+    {
+        count++;
+    }
+
+    if (g_svd_replace_offset > 0)
+    {
+        count++;
+    }
+    
+    return count;
+}
+
 static grub_uint32_t ventoy_linux_get_override_chunk_size(void)
 {
-    return sizeof(ventoy_override_chunk) * g_valid_initrd_count;
+    int count = g_valid_initrd_count;
+    
+    if (g_conf_replace_offset > 0)
+    {
+        count++;
+    }
+
+    if (g_svd_replace_offset > 0)
+    {
+        count++;
+    }
+
+    return sizeof(ventoy_override_chunk) * count;
 }
 
 static void ventoy_linux_fill_override_data(    grub_uint64_t isosize, void *override)
@@ -697,6 +773,8 @@ static void ventoy_linux_fill_override_data(    grub_uint64_t isosize, void *ove
     grub_uint32_t newlen;
     grub_uint64_t sector;
     ventoy_override_chunk *cur;
+    ventoy_iso9660_override *dirent;
+    ventoy_udf_override *udf;
 
     sector = (isosize + 2047) / 2048;
 
@@ -712,12 +790,12 @@ static void ventoy_linux_fill_override_data(    grub_uint64_t isosize, void *ove
         mod = newlen % 4; 
         if (mod > 0)
         {
-            newlen += 4 - mod;
+            newlen += 4 - mod; /* cpio must align with 4 */
         }
 
         if (node->iso_type == 0)
         {
-            ventoy_iso9660_override *dirent = (ventoy_iso9660_override *)node->override_data;
+            dirent = (ventoy_iso9660_override *)node->override_data;
 
             node->override_length   = sizeof(ventoy_iso9660_override);
             dirent->first_sector    = (grub_uint32_t)sector;
@@ -729,7 +807,7 @@ static void ventoy_linux_fill_override_data(    grub_uint64_t isosize, void *ove
         }
         else
         {
-            ventoy_udf_override *udf = (ventoy_udf_override *)node->override_data;
+            udf = (ventoy_udf_override *)node->override_data;
             
             node->override_length = sizeof(ventoy_udf_override);
             udf->length   = newlen;
@@ -744,6 +822,31 @@ static void ventoy_linux_fill_override_data(    grub_uint64_t isosize, void *ove
         cur++;
     }
 
+    if (g_conf_replace_offset > 0)
+    {        
+        cur->img_offset = g_conf_replace_offset;
+        cur->override_size = sizeof(ventoy_iso9660_override);
+
+        newlen = (grub_uint32_t)(g_conf_replace_new_len);
+
+        dirent = (ventoy_iso9660_override *)cur->override_data;
+        dirent->first_sector    = (grub_uint32_t)sector;
+        dirent->size            = newlen;
+        dirent->first_sector_be = grub_swap_bytes32(dirent->first_sector);
+        dirent->size_be         = grub_swap_bytes32(dirent->size);
+
+        sector += (dirent->size + 2047) / 2048;
+        cur++;
+    }
+    
+    if (g_svd_replace_offset > 0)
+    {        
+        cur->img_offset = g_svd_replace_offset;
+        cur->override_size = 1;
+        cur->override_data[0] = 0xFF;
+        cur++;
+    }
+
     return;
 }
 
@@ -910,12 +1013,15 @@ grub_err_t ventoy_cmd_linux_locate_initrd(grub_extcmd_context_t ctxt, int argc,
     VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 }
 
-static int ventoy_cpio_busybox64(cpio_newc_header *head)
+static int ventoy_cpio_busybox64(cpio_newc_header *head, const char *file)
 {
     char *name;
     int namelen;
     int offset;
     int count = 0;
+    char filepath[128];
+
+    grub_snprintf(filepath, sizeof(filepath), "ventoy/busybox/%s", file);
     
     name = (char *)(head + 1);
     while (name[0] && count < 2)
@@ -925,7 +1031,7 @@ static int ventoy_cpio_busybox64(cpio_newc_header *head)
             grub_memcpy(name, "ventoy/busybox/32h", 18);
             count++;
         }
-        else if (grub_strcmp(name, "ventoy/busybox/64h") == 0)
+        else if (grub_strcmp(name, filepath) == 0)
         {
             grub_memcpy(name, "ventoy/busybox/ash", 18);
             count++;
@@ -952,18 +1058,60 @@ grub_err_t ventoy_cmd_cpio_busybox_64(grub_extcmd_context_t ctxt, int argc, char
     (void)args;
 
     debug("ventoy_cmd_busybox_64 %d\n", argc);
-    ventoy_cpio_busybox64((cpio_newc_header *)g_ventoy_cpio_buf);
+    ventoy_cpio_busybox64((cpio_newc_header *)g_ventoy_cpio_buf, args[0]);
     return 0;
 }
 
+grub_err_t ventoy_cmd_skip_svd(grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    int i;
+    grub_file_t file;
+    char buf[16];
+    
+    (void)ctxt;
+    (void)argc;
+
+    file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
+    if (!file)
+    {
+        return grub_error(GRUB_ERR_BAD_ARGUMENT, "Can't open file %s\n", args[0]); 
+    }
+
+    for (i = 0; i < 10; i++)
+    {
+        buf[0] = 0;
+        grub_file_seek(file, (17 + i) * 2048);
+        grub_file_read(file, buf, 16);
+
+        if (buf[0] == 2 && grub_strncmp(buf + 1, "CD001", 5) == 0)
+        {
+            debug("Find SVD at VD %d\n", i);
+            g_svd_replace_offset = (17 + i) * 2048;
+            break;
+        }
+    }
+
+    if (i >= 10)
+    {
+        debug("SVD not found %d\n", (int)g_svd_replace_offset);
+    }
+
+    grub_file_close(file);
+
+    VENTOY_CMD_RETURN(GRUB_ERR_NONE);
+}
 
 grub_err_t ventoy_cmd_load_cpio(grub_extcmd_context_t ctxt, int argc, char **args)
 {
+    int i;
     int rc;
+    char *pos = NULL;
     char *template_file = NULL;
     char *template_buf = NULL;
     char *persistent_buf = NULL;
     char *injection_buf = NULL;
+    dud *dudnode = NULL;
+    char tmpname[128];
     const char *injection_file = NULL;
     grub_uint8_t *buf = NULL;
     grub_uint32_t mod;
@@ -974,6 +1122,7 @@ grub_err_t ventoy_cmd_load_cpio(grub_extcmd_context_t ctxt, int argc, char **arg
     grub_uint32_t template_size = 0;
     grub_uint32_t persistent_size = 0;
     grub_uint32_t injection_size = 0;
+    grub_uint32_t dud_size = 0;
     grub_file_t file;
     grub_file_t tmpfile;
     ventoy_img_chunk_list chunk_list;
@@ -1067,11 +1216,30 @@ grub_err_t ventoy_cmd_load_cpio(grub_extcmd_context_t ctxt, int argc, char **arg
         debug("injection not configed %s\n", args[1]);
     }
 
-    g_ventoy_cpio_buf = grub_malloc(file->size + 4096 + template_size + persistent_size + injection_size + img_chunk_size);
+    dudnode = ventoy_plugin_find_dud(args[1]);
+    if (dudnode)
+    {
+        debug("dud file: <%d>\n", dudnode->dudnum);
+        ventoy_plugin_load_dud(dudnode, args[2]);
+        for (i = 0; i < dudnode->dudnum; i++)
+        {
+            if (dudnode->files[i].size > 0)
+            {
+                dud_size += dudnode->files[i].size + sizeof(cpio_newc_header);                
+            }
+        }
+    }
+    else
+    {
+        debug("dud not configed %s\n", args[1]);
+    }
+
+    g_ventoy_cpio_buf = grub_malloc(file->size + 40960 + template_size + 
+        persistent_size + injection_size + dud_size + img_chunk_size);
     if (NULL == g_ventoy_cpio_buf)
     {
         grub_file_close(file);
-        return grub_error(GRUB_ERR_BAD_ARGUMENT, "Can't alloc memory %llu\n", file->size + 4096 + img_chunk_size); 
+        return grub_error(GRUB_ERR_BAD_ARGUMENT, "Can't alloc memory %llu\n", file->size);
     }
 
     grub_file_read(file, g_ventoy_cpio_buf, file->size);
@@ -1113,6 +1281,18 @@ grub_err_t ventoy_cmd_load_cpio(grub_extcmd_context_t ctxt, int argc, char **arg
         injection_buf = NULL;
     }
 
+    if (dud_size > 0)
+    {
+        for (i = 0; i < dudnode->dudnum; i++)
+        {
+            pos = grub_strrchr(dudnode->dudpath[i].path, '.');
+            grub_snprintf(tmpname, sizeof(tmpname), "ventoy/ventoy_dud%d%s", i, (pos ? pos : ".iso"));
+            dud_size = dudnode->files[i].size;
+            headlen = ventoy_cpio_newc_fill_head(buf, dud_size, dudnode->files[i].buf, tmpname);
+            buf += headlen + ventoy_align(dud_size, 4);
+        }
+    }
+
     /* step2: insert os param to cpio */
     headlen = ventoy_cpio_newc_fill_head(buf, 0, NULL, "ventoy/ventoy_os_param");
     padlen = sizeof(ventoy_os_param);
@@ -1137,7 +1317,12 @@ grub_err_t ventoy_cmd_load_cpio(grub_extcmd_context_t ctxt, int argc, char **arg
     if (grub_strcmp(args[3], "busybox=64") == 0)
     {
         debug("cpio busybox proc %s\n", args[3]);
-        ventoy_cpio_busybox64((cpio_newc_header *)g_ventoy_cpio_buf);
+        ventoy_cpio_busybox64((cpio_newc_header *)g_ventoy_cpio_buf, "64h");
+    }
+    else if (grub_strcmp(args[3], "busybox=a64") == 0)
+    {
+        debug("cpio busybox proc %s\n", args[3]);
+        ventoy_cpio_busybox64((cpio_newc_header *)g_ventoy_cpio_buf, "a64");
     }
 
     VENTOY_CMD_RETURN(GRUB_ERR_NONE);
@@ -1241,7 +1426,9 @@ grub_err_t ventoy_cmd_linux_chain_data(grub_extcmd_context_t ctxt, int argc, cha
     grub_uint64_t isosize = 0;
     grub_uint32_t boot_catlog = 0;
     grub_uint32_t img_chunk_size = 0;
+    grub_uint32_t override_count = 0;
     grub_uint32_t override_size = 0;
+    grub_uint32_t virt_chunk_count = 0;
     grub_uint32_t virt_chunk_size = 0;
     grub_file_t file;
     grub_disk_t disk;
@@ -1295,6 +1482,9 @@ grub_err_t ventoy_cmd_linux_chain_data(grub_extcmd_context_t ctxt, int argc, cha
     
     img_chunk_size = g_img_chunk_list.cur_chunk * sizeof(ventoy_img_chunk);
 
+    override_count = ventoy_linux_get_override_chunk_count();
+    virt_chunk_count = ventoy_linux_get_virt_chunk_count();
+    
     if (ventoy_compatible)
     {
         size = sizeof(ventoy_chain_head) + img_chunk_size;
@@ -1360,20 +1550,21 @@ grub_err_t ventoy_cmd_linux_chain_data(grub_extcmd_context_t ctxt, int argc, cha
         return 0;
     }
 
-    if (g_valid_initrd_count == 0)
+    /* part 4: override chunk */
+    if (override_count > 0)
     {
-        return 0;
+        chain->override_chunk_offset = chain->img_chunk_offset + img_chunk_size;
+        chain->override_chunk_num = override_count;
+        ventoy_linux_fill_override_data(isosize, (char *)chain + chain->override_chunk_offset);        
     }
 
-    /* part 4: override chunk */
-    chain->override_chunk_offset = chain->img_chunk_offset + img_chunk_size;
-    chain->override_chunk_num = g_valid_initrd_count;
-    ventoy_linux_fill_override_data(isosize, (char *)chain + chain->override_chunk_offset);
-
     /* part 5: virt chunk */
+    if (virt_chunk_count > 0)
+    {        
         chain->virt_chunk_offset = chain->override_chunk_offset + override_size;
-    chain->virt_chunk_num = g_valid_initrd_count;
+        chain->virt_chunk_num = virt_chunk_count;
         ventoy_linux_fill_virt_data(isosize, chain);
+    }
 
     VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 }

GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_plugin.c

@@ -32,6 +32,7 @@
 #include <grub/datetime.h>
 #include <grub/i18n.h>
 #include <grub/net.h>
+#include <grub/crypto.h>
 #include <grub/time.h>
 #include <grub/font.h>
 #include <grub/ventoy.h>
@@ -39,13 +40,19 @@
 
 GRUB_MOD_LICENSE ("GPLv3+");
 
+char g_arch_mode_suffix[64];
 static char g_iso_disk_name[128];
+static vtoy_password g_boot_pwd;
 static install_template *g_install_template_head = NULL;
+static dud *g_dud_head = NULL;
+static menu_password *g_pwd_head = NULL;
 static persistence_config *g_persistence_head = NULL;
 static menu_alias *g_menu_alias_head = NULL;
 static menu_class *g_menu_class_head = NULL;
 static injection_config *g_injection_head = NULL;
 static auto_memdisk *g_auto_memdisk_head = NULL;
+static image_list *g_image_list_head = NULL;
+static conf_replace *g_conf_replace_head = NULL;
 
 static int ventoy_plugin_control_check(VTOY_JSON *json, const char *isodisk)
 {
@@ -588,6 +595,362 @@ static int ventoy_plugin_auto_install_entry(VTOY_JSON *json, const char *isodisk
     return 0;
 }
 
+static int ventoy_plugin_dud_check(VTOY_JSON *json, const char *isodisk)
+{
+    int pathnum = 0;
+    const char *iso = NULL;
+    VTOY_JSON *pNode = NULL;
+
+    if (json->enDataType != JSON_TYPE_ARRAY)
+    {
+        grub_printf("Not array type %d\n", json->enDataType);
+        return 1;
+    }
+
+    for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
+    {
+        if (pNode->enDataType != JSON_TYPE_OBJECT)
+        {
+            grub_printf("NOT object type\n");
+        }
+    
+        iso = vtoy_json_get_string_ex(pNode->pstChild, "image");
+        if (iso)
+        {
+            if (0 == ventoy_plugin_check_path(isodisk, iso))
+            {
+                grub_printf("image: %s [OK]\n", iso);
+                ventoy_plugin_check_fullpath(pNode->pstChild, isodisk, "dud", &pathnum);
+            }
+            else
+            {
+                grub_printf("image: %s [FAIL]\n", iso);
+            }
+        }
+        else
+        {
+            grub_printf("image not found\n");
+        }
+    }
+
+    return 0;
+}
+
+static int ventoy_plugin_dud_entry(VTOY_JSON *json, const char *isodisk)
+{
+    int pathnum = 0;
+    const char *iso = NULL;
+    VTOY_JSON *pNode = NULL;
+    dud *node = NULL;
+    dud *next = NULL;
+    file_fullpath *dudpath = NULL;
+
+    if (json->enDataType != JSON_TYPE_ARRAY)
+    {
+        debug("Not array %d\n", json->enDataType);
+        return 0;
+    }
+
+    if (g_dud_head)
+    {
+        for (node = g_dud_head; node; node = next)
+        {
+            next = node->next;
+            grub_check_free(node->dudpath);
+            grub_free(node);
+        }
+
+        g_dud_head = NULL;
+    }
+
+    for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
+    {
+        iso = vtoy_json_get_string_ex(pNode->pstChild, "image");
+        if (iso && iso[0] == '/')
+        {
+            if (0 == ventoy_plugin_parse_fullpath(pNode->pstChild, isodisk, "dud", &dudpath, &pathnum))
+            {
+                node = grub_zalloc(sizeof(dud));
+                if (node)
+                {
+                    node->pathlen = grub_snprintf(node->isopath, sizeof(node->isopath), "%s", iso);
+                    node->dudpath = dudpath;
+                    node->dudnum = pathnum;
+                    node->files = grub_zalloc(sizeof(dudfile) * pathnum);
+
+                    if (node->files)
+                    {
+                        if (g_dud_head)
+                        {
+                            node->next = g_dud_head;
+                        }
+                        
+                        g_dud_head = node;
+                    }
+                    else
+                    {
+                        grub_free(node);
+                    }
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int ventoy_plugin_parse_pwdstr(char *pwdstr, vtoy_password *pwd)
+{
+    int i;
+    int len;
+    char ch;
+    char *pos;
+    char bytes[3];
+    vtoy_password tmpPwd;
+    
+    len = (int)grub_strlen(pwdstr);
+    if (len > 64)
+    {
+        if (NULL == pwd) grub_printf("Password too long %d\n", len);
+        return 1;
+    }
+
+    grub_memset(&tmpPwd, 0, sizeof(tmpPwd));
+
+    if (grub_strncmp(pwdstr, "txt#", 4) == 0)
+    {
+        tmpPwd.type = VTOY_PASSWORD_TXT;
+        grub_snprintf(tmpPwd.text, sizeof(tmpPwd.text), "%s", pwdstr + 4);
+    }
+    else if (grub_strncmp(pwdstr, "md5#", 4) == 0)
+    {
+        if ((len - 4) == 32)
+        {
+            for (i = 0; i < 16; i++)
+            {
+                bytes[0] = pwdstr[4 + i * 2];
+                bytes[1] = pwdstr[4 + i * 2 + 1];
+                bytes[2] = 0;
+                
+                if (grub_isxdigit(bytes[0]) && grub_isxdigit(bytes[1]))
+                {
+                    tmpPwd.md5[i] = (grub_uint8_t)grub_strtoul(bytes, NULL, 16);
+                }
+                else
+                {
+                    if (NULL == pwd) grub_printf("Invalid md5 hex format %s %d\n", pwdstr, i);
+                    return 1;
+                }
+            }
+            tmpPwd.type = VTOY_PASSWORD_MD5;
+        }
+        else if ((len - 4) > 32)
+        {
+            pos = grub_strchr(pwdstr + 4, '#');
+            if (!pos)
+            {
+                if (NULL == pwd) grub_printf("Invalid md5 password format %s\n", pwdstr);
+                return 1;
+            }
+
+            if (len - 1 - (int)(long)(pos - pwdstr) != 32)
+            {
+                if (NULL == pwd) grub_printf("Invalid md5 salt password format %s\n", pwdstr);
+                return 1;
+            }
+        
+            ch = *pos;
+            *pos = 0;
+            grub_snprintf(tmpPwd.salt, sizeof(tmpPwd.salt), "%s", pwdstr + 4);
+            *pos = ch;
+
+            pos++;
+            for (i = 0; i < 16; i++)
+            {
+                bytes[0] = pos[i * 2];
+                bytes[1] = pos[i * 2 + 1];
+                bytes[2] = 0;
+                
+                if (grub_isxdigit(bytes[0]) && grub_isxdigit(bytes[1]))
+                {
+                    tmpPwd.md5[i] = (grub_uint8_t)grub_strtoul(bytes, NULL, 16);
+                }
+                else
+                {
+                    if (NULL == pwd) grub_printf("Invalid md5 hex format %s %d\n", pwdstr, i);
+                    return 1;
+                }
+            }
+
+            tmpPwd.type = VTOY_PASSWORD_SALT_MD5;
+        }
+        else
+        {
+            if (NULL == pwd) grub_printf("Invalid md5 password format %s\n", pwdstr);
+            return 1;
+        }
+    }
+    else
+    {
+        if (NULL == pwd) grub_printf("Invalid password format %s\n", pwdstr);
+        return 1;
+    }
+
+    if (pwd)
+    {
+        grub_memcpy(pwd, &tmpPwd, sizeof(tmpPwd));
+    }
+
+    return 0;
+}
+
+static int ventoy_plugin_pwd_entry(VTOY_JSON *json, const char *isodisk)
+{
+    const char *iso = NULL;
+    const char *pwd = NULL;
+    VTOY_JSON *pNode = NULL;
+    VTOY_JSON *pCNode = NULL;
+    menu_password *node = NULL;
+    menu_password *tail = NULL;
+    menu_password *next = NULL;
+
+    (void)isodisk;
+
+    if (json->enDataType != JSON_TYPE_OBJECT)
+    {
+        debug("Not object %d\n", json->enDataType);
+        return 0;
+    }
+
+    if (g_pwd_head)
+    {
+        for (node = g_pwd_head; node; node = next)
+        {
+            next = node->next;
+            grub_free(node);
+        }
+
+        g_pwd_head = NULL;
+    }
+
+    for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
+    {
+        if (pNode->pcName && grub_strcmp("bootpwd", pNode->pcName) == 0)
+        {
+            ventoy_plugin_parse_pwdstr(pNode->unData.pcStrVal, &g_boot_pwd);
+        }
+        else if (pNode->pcName && grub_strcmp("menupwd", pNode->pcName) == 0)
+        {
+            for (pCNode = pNode->pstChild; pCNode; pCNode = pCNode->pstNext)
+            {
+                if (pCNode->enDataType != JSON_TYPE_OBJECT)
+                {
+                    continue;
+                }
+
+                iso = vtoy_json_get_string_ex(pCNode->pstChild, "file");
+                pwd = vtoy_json_get_string_ex(pCNode->pstChild, "pwd");
+                if (iso && pwd && iso[0] == '/')
+                {
+                    node = grub_zalloc(sizeof(menu_password));
+                    if (node)
+                    {
+                        node->pathlen = grub_snprintf(node->isopath, sizeof(node->isopath), "%s", iso);
+
+                        if (ventoy_plugin_parse_pwdstr((char *)pwd, &(node->password)))
+                        {
+                            grub_free(node);
+                            continue;
+                        }
+
+                        if (g_pwd_head)
+                        {
+                            tail->next = node;
+                        }
+                        else
+                        {
+                            g_pwd_head = node;
+                        }
+                        tail = node;
+                    }
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int ventoy_plugin_pwd_check(VTOY_JSON *json, const char *isodisk)
+{
+    const char *iso = NULL;
+    const char *pwd = NULL;
+    VTOY_JSON *pNode = NULL;
+    VTOY_JSON *pCNode = NULL;
+
+    if (json->enDataType != JSON_TYPE_OBJECT)
+    {
+        grub_printf("Not object %d\n", json->enDataType);
+        return 0;
+    }
+
+    for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
+    {
+        if (pNode->pcName && grub_strcmp("bootpwd", pNode->pcName) == 0)
+        {
+            if (0 == ventoy_plugin_parse_pwdstr(pNode->unData.pcStrVal, NULL))
+            {
+                grub_printf("bootpwd:<%s>\n", pNode->unData.pcStrVal);
+            }
+            else
+            {
+                grub_printf("Invalid bootpwd.\n");
+            }
+        }
+        else if (pNode->pcName && grub_strcmp("menupwd", pNode->pcName) == 0)
+        {
+            grub_printf("\n");
+            for (pCNode = pNode->pstChild; pCNode; pCNode = pCNode->pstNext)
+            {
+                if (pCNode->enDataType != JSON_TYPE_OBJECT)
+                {
+                    grub_printf("Not object %d\n", pCNode->enDataType);
+                    continue;
+                }
+
+                iso = vtoy_json_get_string_ex(pCNode->pstChild, "file");
+                if (iso)
+                {
+                    if (0 == ventoy_plugin_check_path(isodisk, iso))
+                    {
+                        pwd = vtoy_json_get_string_ex(pCNode->pstChild, "pwd");
+
+                        if (0 == ventoy_plugin_parse_pwdstr((char *)pwd, NULL))
+                        {
+                            grub_printf("file:<%s> [OK]\n", iso);
+                            grub_printf("pwd:<%s>\n\n", pwd);
+                        }
+                        else
+                        {
+                            grub_printf("Invalid password for <%s>\n", iso);
+                        }
+                    }
+                    else
+                    {
+                        grub_printf("<%s%s> not found\n", isodisk, iso);
+                    }
+                }
+                else
+                {
+                    grub_printf("No file item found in json.\n");
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
 static int ventoy_plugin_persistence_check(VTOY_JSON *json, const char *isodisk)
 {
     int autosel = 0;
@@ -1019,6 +1382,146 @@ static int ventoy_plugin_menuclass_check(VTOY_JSON *json, const char *isodisk)
     return 0;
 }
 
+static int ventoy_plugin_conf_replace_entry(VTOY_JSON *json, const char *isodisk)
+{
+    const char *isof = NULL;
+    const char *orgf = NULL;
+    const char *newf = NULL;
+    VTOY_JSON *pNode = NULL;
+    conf_replace *tail = NULL;
+    conf_replace *node = NULL;
+    conf_replace *next = NULL;
+
+    (void)isodisk;
+
+    if (json->enDataType != JSON_TYPE_ARRAY)
+    {
+        debug("Not array %d\n", json->enDataType);
+        return 0;
+    }
+
+    if (g_conf_replace_head)
+    {
+        for (node = g_conf_replace_head; node; node = next)
+        {
+            next = node->next;
+            grub_free(node);
+        }
+
+        g_conf_replace_head = NULL;
+    }
+
+    for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
+    {
+        isof = vtoy_json_get_string_ex(pNode->pstChild, "iso");
+        orgf = vtoy_json_get_string_ex(pNode->pstChild, "org");
+        newf = vtoy_json_get_string_ex(pNode->pstChild, "new");
+        if (isof && orgf && newf && isof[0] == '/' && orgf[0] == '/' && newf[0] == '/')
+        {
+            node = grub_zalloc(sizeof(conf_replace));
+            if (node)
+            {
+                node->pathlen = grub_snprintf(node->isopath, sizeof(node->isopath), "%s", isof);
+                grub_snprintf(node->orgconf, sizeof(node->orgconf), "%s", orgf);
+                grub_snprintf(node->newconf, sizeof(node->newconf), "%s", newf);
+
+                if (g_conf_replace_head)
+                {
+                    tail->next = node;
+                }
+                else
+                {
+                    g_conf_replace_head = node;
+                }
+                tail = node;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int ventoy_plugin_conf_replace_check(VTOY_JSON *json, const char *isodisk)
+{
+    const char *isof = NULL;
+    const char *orgf = NULL;
+    const char *newf = NULL;
+    VTOY_JSON *pNode = NULL;
+    grub_file_t file = NULL;
+    char cmd[256];
+
+    (void)isodisk;
+
+    if (json->enDataType != JSON_TYPE_ARRAY)
+    {
+        grub_printf("Not array %d\n", json->enDataType);
+        return 1;
+    }
+
+    for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
+    {
+        isof = vtoy_json_get_string_ex(pNode->pstChild, "iso");
+        orgf = vtoy_json_get_string_ex(pNode->pstChild, "org");
+        newf = vtoy_json_get_string_ex(pNode->pstChild, "new");
+        if (isof && orgf && newf && isof[0] == '/' && orgf[0] == '/' && newf[0] == '/')
+        {
+            if (ventoy_check_file_exist("%s%s", isodisk, isof))
+            {
+                grub_printf("iso:<%s> [OK]\n", isof);
+                
+                grub_snprintf(cmd, sizeof(cmd), "loopback vtisocheck \"%s%s\"", isodisk, isof);
+                grub_script_execute_sourcecode(cmd);
+
+                file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "(vtisocheck)/%s", orgf);
+                if (file)
+                {
+                    if (grub_strcmp(file->fs->name, "iso9660") == 0)
+                    {
+                        grub_printf("org:<%s> [OK]\n", orgf);
+                    }
+                    else
+                    {
+                        grub_printf("org:<%s> [Exist But NOT ISO9660]\n", orgf);
+                    }
+                    grub_file_close(file);
+                }
+                else
+                {
+                    grub_printf("org:<%s> [NOT Exist]\n", orgf);
+                }
+                
+                grub_script_execute_sourcecode("loopback -d vtisocheck");
+            }
+            else
+            {
+                grub_printf("iso:<%s> [NOT Exist]\n", isof);
+                grub_printf("org:<%s>\n", orgf);
+            }
+
+            file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s%s", isodisk, newf);
+            if (file)
+            {
+                if (file->size > vtoy_max_replace_file_size)
+                {
+                    grub_printf("new:<%s> [Too Big %lu] \n", newf, (ulong)file->size);
+                }
+                else
+                {
+                    grub_printf("new:<%s> [OK]\n", newf);                    
+                }
+                grub_file_close(file);
+            }
+            else
+            {
+                grub_printf("new:<%s> [NOT Exist]\n", newf);   
+            }
+            grub_printf("\n");
+        }
+    }
+
+    return 0;
+}
+
 static int ventoy_plugin_auto_memdisk_entry(VTOY_JSON *json, const char *isodisk)
 {
     VTOY_JSON *pNode = NULL;
@@ -1096,6 +1599,89 @@ static int ventoy_plugin_auto_memdisk_check(VTOY_JSON *json, const char *isodisk
     return 0;
 }
 
+static int ventoy_plugin_image_list_entry(VTOY_JSON *json, const char *isodisk)
+{
+    VTOY_JSON *pNode = NULL;
+    image_list *node = NULL;
+    image_list *next = NULL;
+    image_list *tail = NULL;
+
+    (void)isodisk;
+
+    if (json->enDataType != JSON_TYPE_ARRAY)
+    {
+        debug("Not array %d\n", json->enDataType);
+        return 0;
+    }
+
+    if (g_image_list_head)
+    {
+        for (node = g_image_list_head; node; node = next)
+        {
+            next = node->next;
+            grub_free(node);
+        }
+
+        g_image_list_head = NULL;
+    }
+
+    g_plugin_image_list = 1;
+
+    for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
+    {
+        if (pNode->enDataType == JSON_TYPE_STRING)
+        {
+            node = grub_zalloc(sizeof(image_list));
+            if (node)
+            {
+                node->pathlen = grub_snprintf(node->isopath, sizeof(node->isopath), "%s", pNode->unData.pcStrVal);
+
+                if (g_image_list_head)
+                {
+                    tail->next = node;
+                }
+                else
+                {
+                    g_image_list_head = node;
+                }
+                tail = node;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int ventoy_plugin_image_list_check(VTOY_JSON *json, const char *isodisk)
+{
+    VTOY_JSON *pNode = NULL;
+
+    if (json->enDataType != JSON_TYPE_ARRAY)
+    {
+        grub_printf("Not array %d\n", json->enDataType);
+        return 1;
+    }
+
+    for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
+    {
+        if (pNode->enDataType == JSON_TYPE_STRING)
+        {
+            grub_printf("<%s> ", pNode->unData.pcStrVal);
+
+            if (ventoy_check_file_exist("%s%s", isodisk, pNode->unData.pcStrVal))
+            {
+                grub_printf(" [OK]\n");
+            }
+            else
+            {
+                grub_printf(" [NOT EXIST]\n");
+            }
+        }
+    }
+
+    return 0;
+}
+
 static plugin_entry g_plugin_entries[] = 
 {
     { "control", ventoy_plugin_control_entry, ventoy_plugin_control_check },
@@ -1106,11 +1692,16 @@ static plugin_entry g_plugin_entries[] =
     { "menu_class", ventoy_plugin_menuclass_entry, ventoy_plugin_menuclass_check },
     { "injection", ventoy_plugin_injection_entry, ventoy_plugin_injection_check },
     { "auto_memdisk", ventoy_plugin_auto_memdisk_entry, ventoy_plugin_auto_memdisk_check },
+    { "image_list", ventoy_plugin_image_list_entry, ventoy_plugin_image_list_check },
+    { "conf_replace", ventoy_plugin_conf_replace_entry, ventoy_plugin_conf_replace_check },
+    { "dud", ventoy_plugin_dud_entry, ventoy_plugin_dud_check },
+    { "password", ventoy_plugin_pwd_entry, ventoy_plugin_pwd_check },
 };
 
 static int ventoy_parse_plugin_config(VTOY_JSON *json, const char *isodisk)
 {
     int i;
+    char key[128];
     VTOY_JSON *cur = json;
 
     grub_snprintf(g_iso_disk_name, sizeof(g_iso_disk_name), "%s", isodisk);
@@ -1119,7 +1710,8 @@ static int ventoy_parse_plugin_config(VTOY_JSON *json, const char *isodisk)
     {
         for (i = 0; i < (int)ARRAY_SIZE(g_plugin_entries); i++)
         {
-            if (grub_strcmp(g_plugin_entries[i].key, cur->pcName) == 0)
+            grub_snprintf(key, sizeof(key), "%s_%s", g_plugin_entries[i].key, g_arch_mode_suffix);
+            if (grub_strcmp(g_plugin_entries[i].key, cur->pcName) == 0 || grub_strcmp(key, cur->pcName) == 0)
             {
                 debug("Plugin entry for %s\n", g_plugin_entries[i].key);
                 g_plugin_entries[i].entryfunc(cur, isodisk);
@@ -1143,7 +1735,7 @@ grub_err_t ventoy_cmd_load_plugin(grub_extcmd_context_t ctxt, int argc, char **a
     (void)ctxt;
     (void)argc;
 
-    file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s/ventoy/ventoy.json", args[0]);
+    file = ventoy_grub_file_open(GRUB_FILE_TYPE_LINUX_INITRD, "%s/ventoy/ventoy.json", args[0]);
     if (!file)
     {
         return GRUB_ERR_NONE;
@@ -1173,6 +1765,9 @@ grub_err_t ventoy_cmd_load_plugin(grub_extcmd_context_t ctxt, int argc, char **a
     ret = vtoy_json_parse(json, buf);
     if (ret)
     {
+        grub_env_set("VTOY_PLUGIN_SYNTAX_ERROR", "1");
+        grub_env_export("VTOY_PLUGIN_SYNTAX_ERROR");
+        
         debug("Failed to parse json string %d\n", ret);
         grub_free(buf);
         return 1;
@@ -1184,6 +1779,18 @@ grub_err_t ventoy_cmd_load_plugin(grub_extcmd_context_t ctxt, int argc, char **a
 
     grub_free(buf);
 
+    if (g_boot_pwd.type)
+    {        
+        grub_printf("\n\n======= %s ======\n\n", grub_env_get("VTOY_TEXT_MENU_VER"));
+        if (ventoy_check_password(&g_boot_pwd, 3))
+        {
+            grub_printf("\n!!! Password check failed, will exit after 5 seconds. !!!\n");
+            grub_refresh();
+            grub_sleep(5);
+            grub_exit();
+        }
+    }
+
     VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 }
 
@@ -1472,11 +2079,173 @@ int ventoy_plugin_check_memdisk(const char *isopath)
     return 0;
 }
 
+int ventoy_plugin_get_image_list_index(int type, const char *name)
+{
+    int len;
+    int index = 1;
+    image_list *node = NULL;
+
+    if (!g_image_list_head)
+    {
+        return 0;
+    }
+
+    len = (int)grub_strlen(name);    
+    
+    for (node = g_image_list_head; node; node = node->next, index++)
+    {
+        if (vtoy_class_directory == type)
+        {
+            if (len < node->pathlen && grub_strncmp(name, node->isopath, len) == 0)
+            {
+                return index;
+            }
+        }
+        else
+        {
+            if (len == node->pathlen && grub_strncmp(name, node->isopath, len) == 0)
+            {
+                return index;
+            }
+        }
+    }
+
+    return 0;
+}
+
+conf_replace * ventoy_plugin_find_conf_replace(const char *iso)
+{
+    int len;
+    conf_replace *node;
+
+    if (!g_conf_replace_head)
+    {
+        return NULL;
+    }
+
+    len = (int)grub_strlen(iso);
+    
+    for (node = g_conf_replace_head; node; node = node->next)
+    {
+        if (node->pathlen == len && grub_strncmp(iso, node->isopath, len) == 0)
+        {
+            return node;
+        }
+    }
+    
+    return NULL;
+}
+
+dud * ventoy_plugin_find_dud(const char *iso)
+{
+    int len;
+    dud *node;
+
+    if (!g_dud_head)
+    {
+        return NULL;
+    }
+
+    len = (int)grub_strlen(iso);
+    for (node = g_dud_head; node; node = node->next)
+    {
+        if (node->pathlen == len && grub_strncmp(iso, node->isopath, len) == 0)
+        {
+            return node;
+        }
+    }
+    
+    return NULL;
+}
+
+int ventoy_plugin_load_dud(dud *node, const char *isopart)
+{
+    int i;
+    char *buf;
+    grub_file_t file;
+
+    for (i = 0; i < node->dudnum; i++)
+    {
+        if (node->files[i].size > 0)
+        {
+            debug("file %d has been loaded\n", i);
+            continue;
+        }
+    
+        file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s%s", isopart, node->dudpath[i].path);
+        if (file)
+        {
+            buf = grub_malloc(file->size);
+            if (buf)
+            {
+                grub_file_read(file, buf, file->size);            
+                node->files[i].size = (int)file->size;
+                node->files[i].buf = buf;                
+            }
+            grub_file_close(file);
+        }
+    }
+
+    return 0;
+}
+
+static const vtoy_password * ventoy_plugin_get_password(const char *isopath)
+{
+    int len;
+    menu_password *node = NULL;
+
+    if ((!g_pwd_head) || (!isopath))
+    {
+        return NULL;
+    }
+
+    len = (int)grub_strlen(isopath);    
+    for (node = g_pwd_head; node; node = node->next)
+    {
+        if (node->pathlen == len && grub_strncmp(isopath, node->isopath, len) == 0)
+        {
+            return &(node->password);
+        }
+    }
+
+    return NULL;
+}
+
+grub_err_t ventoy_cmd_check_password(grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    int ret;
+    const vtoy_password *pwd = NULL;
+    
+    (void)ctxt;
+    (void)argc;
+
+    pwd = ventoy_plugin_get_password(args[0]);
+    if (pwd)
+    {
+        if (0 == ventoy_check_password(pwd, 1))
+        {
+            ret = 1;
+        }
+        else
+        {
+            ret = 0;
+        }
+    }
+    else
+    {
+        ret = 1;
+    }
+
+    grub_errno = 0;
+    return ret;
+}
+
 grub_err_t ventoy_cmd_plugin_check_json(grub_extcmd_context_t ctxt, int argc, char **args)
 {
     int i = 0;
     int ret = 0;
     char *buf = NULL;
+    char key[128];
     grub_file_t file;
     VTOY_JSON *node = NULL;
     VTOY_JSON *json = NULL;
@@ -1488,10 +2257,11 @@ grub_err_t ventoy_cmd_plugin_check_json(grub_extcmd_context_t ctxt, int argc, ch
         return 0;
     }
 
-    file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s/ventoy/ventoy.json", args[0]);
+    file = ventoy_grub_file_open(GRUB_FILE_TYPE_LINUX_INITRD, "%s/ventoy/ventoy.json", args[0]);
     if (!file)
     {
         grub_printf("Plugin json file /ventoy/ventoy.json does NOT exist.\n");
+        grub_printf("Attention: directory name and filename are both case-sensitive.\n");
         goto end;
     }
 
@@ -1519,9 +2289,10 @@ grub_err_t ventoy_cmd_plugin_check_json(grub_extcmd_context_t ctxt, int argc, ch
         goto end;
     }
 
+    grub_snprintf(key, sizeof(key), "%s_%s", args[1], g_arch_mode_suffix);
     for (node = json->pstChild; node; node = node->pstNext)
     {
-        if (grub_strcmp(node->pcName, args[1]) == 0)
+        if (grub_strcmp(node->pcName, args[1]) == 0 || grub_strcmp(node->pcName, key) == 0)
         {
             break;
         }

GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_unix.c

@@ -235,6 +235,21 @@ static int ventoy_freebsd_append_conf(char *buf, const char *isopath)
     return pos;
 }
 
+static int ventoy_dragonfly_append_conf(char *buf, const char *isopath)
+{
+    int pos = 0;
+
+    debug("ventoy_dragonfly_append_conf %s\n", isopath);
+
+    vtoy_ssprintf(buf, pos, "tmpfs_load=\"%s\"\n", "YES");
+    vtoy_ssprintf(buf, pos, "dm_target_linear_load=\"%s\"\n", "YES");
+    vtoy_ssprintf(buf, pos, "initrd.img_load=\"%s\"\n", "YES");
+    vtoy_ssprintf(buf, pos, "initrd.img_type=\"%s\"\n", "md_image");
+    vtoy_ssprintf(buf, pos, "vfs.root.mountfrom=\"%s\"\n", "ufs:md0s0");
+
+    return pos;
+}
+
 grub_err_t ventoy_cmd_unix_reset(grub_extcmd_context_t ctxt, int argc, char **args)
 {
     (void)ctxt;
@@ -431,6 +446,10 @@ grub_err_t ventoy_cmd_unix_replace_conf(grub_extcmd_context_t ctxt, int argc, ch
     {
         g_conf_new_len += ventoy_freebsd_append_conf(data + file->size, args[1]);
     }
+    else if (grub_strcmp(args[0], "DragonFly") == 0)
+    {
+        g_conf_new_len += ventoy_dragonfly_append_conf(data + file->size, args[1]);
+    }
     
     VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 }
@@ -474,6 +493,7 @@ grub_err_t ventoy_cmd_unix_replace_ko(grub_extcmd_context_t ctxt, int argc, char
     data = grub_malloc(file->size);
     if (!data)
     {
+        debug("Failed to alloc memory for new ko %d\n", (int)file->size);
         grub_file_close(file);    
         return 1;
     }
@@ -487,6 +507,105 @@ grub_err_t ventoy_cmd_unix_replace_ko(grub_extcmd_context_t ctxt, int argc, char
     VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 }
 
+grub_err_t ventoy_cmd_unix_fill_image_desc(grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    int i;
+    grub_uint8_t *byte;
+    grub_uint32_t memsize;
+    ventoy_image_desc *desc;
+    grub_uint8_t flag[32] = {
+        0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x00,
+        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
+    };
+
+    (void)ctxt;
+    (void)argc;
+    (void)args;
+
+    debug("ventoy_cmd_unix_fill_image_desc %p\n", g_mod_new_data);
+
+    if (!g_mod_new_data)
+    {
+        goto end;
+    }
+
+    byte = (grub_uint8_t *)g_mod_new_data;
+    for (i = 0; i < g_mod_new_len - 32; i += 16)
+    {
+        if (byte[i] == 0xFF && byte[i + 1] == 0xEE)
+        {
+            if (grub_memcmp(flag, byte + i, 32) == 0)
+            {
+                debug("Find position flag at %d(0x%x)\n", i, i);
+                break;                
+            }
+        }
+    }
+
+    if (i >= g_mod_new_len - 32)
+    {
+        debug("Failed to find position flag %d\n", i);
+        goto end;
+    }
+
+    desc = (ventoy_image_desc *)(byte + i);
+    desc->disk_size = g_ventoy_disk_size;
+    desc->part1_size = ventoy_get_part1_size(g_ventoy_part_info);
+    grub_memcpy(desc->disk_uuid, g_ventoy_part_info->MBR.BootCode + 0x180, 16);
+    grub_memcpy(desc->disk_signature, g_ventoy_part_info->MBR.BootCode + 0x1B8, 4);
+
+    desc->img_chunk_count = g_img_chunk_list.cur_chunk;
+    memsize = g_img_chunk_list.cur_chunk * sizeof(ventoy_img_chunk);
+
+    debug("image chunk count:%u  memsize:%u\n", desc->img_chunk_count, memsize);
+
+    if (memsize >= VTOY_SIZE_1MB * 8)
+    {
+        grub_printf("image chunk count:%u  memsize:%u too big\n", desc->img_chunk_count, memsize);
+        goto end;
+    }
+
+    grub_memcpy(desc + 1, g_img_chunk_list.chunk, memsize);
+
+end:
+    VENTOY_CMD_RETURN(GRUB_ERR_NONE);
+}
+
+grub_err_t ventoy_cmd_unix_gzip_newko(grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    int newlen;
+    grub_uint8_t *buf;
+
+    (void)ctxt;
+    (void)argc;
+    (void)args;
+
+    debug("ventoy_cmd_unix_gzip_newko %p\n", g_mod_new_data);
+
+    if (!g_mod_new_data)
+    {
+        goto end;
+    }
+
+    buf = grub_malloc(g_mod_new_len);
+    if (!buf)
+    {
+        goto end;
+    }
+
+    newlen = ventoy_gzip_compress(g_mod_new_data, g_mod_new_len, buf, g_mod_new_len);
+
+    grub_free(g_mod_new_data);
+
+    debug("gzip org len:%d  newlen:%d\n", g_mod_new_len, newlen);
+
+    g_mod_new_data = (char *)buf;
+    g_mod_new_len = newlen;
+
+end:
+    VENTOY_CMD_RETURN(GRUB_ERR_NONE);
+}
+
 grub_err_t ventoy_cmd_unix_chain_data(grub_extcmd_context_t ctxt, int argc, char **args)
 {
     int ventoy_compatible = 0;

GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_vhd.c

@@ -342,8 +342,10 @@ static int ventoy_raw_trim_head(grub_uint64_t offset)
 grub_err_t ventoy_cmd_get_vtoy_type(grub_extcmd_context_t ctxt, int argc, char **args)
 {
     int i;
+    int altboot = 0;
     int offset = -1;
     grub_file_t file;
+    grub_uint8_t data = 0;
     vhd_footer_t vhdfoot;
     VDIPREHEADER vdihdr;
     char type[16] = {0};
@@ -427,6 +429,7 @@ grub_err_t ventoy_cmd_get_vtoy_type(grub_extcmd_context_t ctxt, int argc, char *
                     if (grub_memcmp(gpt->PartTbl[i].PartType, "Hah!IdontNeedEFI", 16) == 0)
                     {
                         debug("part %d is grub_bios part\n", i);
+                        altboot = 1;
                         grub_env_set(args[3], "1");
                         break;
                     }
@@ -436,6 +439,20 @@ grub_err_t ventoy_cmd_get_vtoy_type(grub_extcmd_context_t ctxt, int argc, char *
                     }
                 }
             }
+
+            if (!altboot)
+            {
+                if (gpt->MBR.BootCode[92] == 0x22)
+                {
+                    grub_file_seek(file, offset + 17908);
+                    grub_file_read(file, &data, 1);
+                    if (data == 0x23)
+                    {
+                        altboot = 1;
+                        grub_env_set(args[3], "1");                        
+                    }
+                }
+            }
         }
         else
         {
@@ -447,6 +464,7 @@ grub_err_t ventoy_cmd_get_vtoy_type(grub_extcmd_context_t ctxt, int argc, char *
                 if (gpt->MBR.PartTbl[i].FsFlag == 0xEF)
                 {
                     debug("part %d is esp part in MBR mode\n", i);
+                    altboot = 1;
                     grub_env_set(args[3], "1");
                     break;
                 }

GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_windows.c

@@ -1492,7 +1492,7 @@ static grub_uint32_t ventoy_get_wim_iso_offset(const char *filepath)
     grub_file_t file;
     char cmdbuf[128];
     
-    grub_snprintf(cmdbuf, sizeof(cmdbuf), "loopback wimiso %s", filepath);
+    grub_snprintf(cmdbuf, sizeof(cmdbuf), "loopback wimiso \"%s\"", filepath);
     grub_script_execute_sourcecode(cmdbuf);
 
     file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", "(wimiso)/boot/boot.wim");
@@ -1542,6 +1542,41 @@ static int ventoy_get_wim_chunklist(const char *filename, ventoy_img_chunk_list
     return 0;
 }
 
+grub_err_t ventoy_cmd_wim_check_bootable(grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    grub_uint32_t boot_index;
+    grub_file_t file = NULL;
+    wim_header *wimhdr = NULL;
+    
+    (void)ctxt;
+    (void)argc;
+
+    wimhdr = grub_zalloc(sizeof(wim_header));
+    if (!wimhdr)
+    {
+        return 1;
+    }
+
+    file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
+    if (!file)
+    {
+        grub_free(wimhdr);
+        return 1;
+    }
+
+    grub_file_read(file, wimhdr, sizeof(wim_header));
+    grub_file_close(file);
+    boot_index = wimhdr->boot_index;
+    grub_free(wimhdr);
+
+    if (boot_index == 0)
+    {
+        return 1;
+    }
+    
+    VENTOY_CMD_RETURN(GRUB_ERR_NONE);
+}
+
 grub_err_t ventoy_cmd_wim_chain_data(grub_extcmd_context_t ctxt, int argc, char **args)
 {
     grub_uint32_t i = 0;

GRUB2/MOD_SRC/grub-2.04/include/grub/term.h

@@ -0,0 +1,466 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2002,2003,2005,2007,2008,2009,2010  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GRUB_TERM_HEADER
+#define GRUB_TERM_HEADER	1
+
+#define GRUB_TERM_NO_KEY        0
+
+/* Internal codes used by GRUB to represent terminal input.  */
+/* Only for keys otherwise not having shifted modification.  */
+#define GRUB_TERM_SHIFT         0x01000000
+#define GRUB_TERM_CTRL          0x02000000
+#define GRUB_TERM_ALT           0x04000000
+
+/* Keys without associated character.  */
+#define GRUB_TERM_EXTENDED      0x00800000
+#define GRUB_TERM_KEY_MASK      0x00ffffff
+
+#define GRUB_TERM_KEY_LEFT      (GRUB_TERM_EXTENDED | 0x4b)
+#define GRUB_TERM_KEY_RIGHT     (GRUB_TERM_EXTENDED | 0x4d)
+#define GRUB_TERM_KEY_UP        (GRUB_TERM_EXTENDED | 0x48)
+#define GRUB_TERM_KEY_DOWN      (GRUB_TERM_EXTENDED | 0x50)
+#define GRUB_TERM_KEY_HOME      (GRUB_TERM_EXTENDED | 0x47)
+#define GRUB_TERM_KEY_END       (GRUB_TERM_EXTENDED | 0x4f)
+#define GRUB_TERM_KEY_DC        (GRUB_TERM_EXTENDED | 0x53)
+#define GRUB_TERM_KEY_PPAGE     (GRUB_TERM_EXTENDED | 0x49)
+#define GRUB_TERM_KEY_NPAGE     (GRUB_TERM_EXTENDED | 0x51)
+#define GRUB_TERM_KEY_F1        (GRUB_TERM_EXTENDED | 0x3b)
+#define GRUB_TERM_KEY_F2        (GRUB_TERM_EXTENDED | 0x3c)
+#define GRUB_TERM_KEY_F3        (GRUB_TERM_EXTENDED | 0x3d)
+#define GRUB_TERM_KEY_F4        (GRUB_TERM_EXTENDED | 0x3e)
+#define GRUB_TERM_KEY_F5        (GRUB_TERM_EXTENDED | 0x3f)
+#define GRUB_TERM_KEY_F6        (GRUB_TERM_EXTENDED | 0x40)
+#define GRUB_TERM_KEY_F7        (GRUB_TERM_EXTENDED | 0x41)
+#define GRUB_TERM_KEY_F8        (GRUB_TERM_EXTENDED | 0x42)
+#define GRUB_TERM_KEY_F9        (GRUB_TERM_EXTENDED | 0x43)
+#define GRUB_TERM_KEY_F10       (GRUB_TERM_EXTENDED | 0x44)
+#define GRUB_TERM_KEY_F11       (GRUB_TERM_EXTENDED | 0x57)
+#define GRUB_TERM_KEY_F12       (GRUB_TERM_EXTENDED | 0x58)
+#define GRUB_TERM_KEY_INSERT    (GRUB_TERM_EXTENDED | 0x52)
+#define GRUB_TERM_KEY_CENTER    (GRUB_TERM_EXTENDED | 0x4c)
+
+/* Hex value is used for ESC, since '\e' is nonstandard */
+#define GRUB_TERM_ESC		0x1b
+#define GRUB_TERM_TAB		'\t'
+#define GRUB_TERM_BACKSPACE	'\b'
+
+#define GRUB_PROGRESS_NO_UPDATE -1
+#define GRUB_PROGRESS_FAST      0
+#define GRUB_PROGRESS_SLOW      2
+
+#ifndef ASM_FILE
+
+#include <grub/err.h>
+#include <grub/symbol.h>
+#include <grub/types.h>
+#include <grub/unicode.h>
+#include <grub/list.h>
+
+/* These are used to represent the various color states we use.  */
+typedef enum
+  {
+    /* The color used to display all text that does not use the
+       user defined colors below.  */
+    GRUB_TERM_COLOR_STANDARD,
+    /* The user defined colors for normal text.  */
+    GRUB_TERM_COLOR_NORMAL,
+    /* The user defined colors for highlighted text.  */
+    GRUB_TERM_COLOR_HIGHLIGHT
+  }
+grub_term_color_state;
+
+/* Flags for representing the capabilities of a terminal.  */
+/* Some notes about the flags:
+   - These flags are used by higher-level functions but not terminals
+   themselves.
+   - If a terminal is dumb, you may assume that only putchar, getkey and
+   checkkey are called.
+   - Some fancy features (setcolorstate, setcolor and setcursor) can be set
+   to NULL.  */
+
+/* Set when input characters shouldn't be echoed back.  */
+#define GRUB_TERM_NO_ECHO	        (1 << 0)
+/* Set when the editing feature should be disabled.  */
+#define GRUB_TERM_NO_EDIT	        (1 << 1)
+/* Set when the terminal cannot do fancy things.  */
+#define GRUB_TERM_DUMB		        (1 << 2)
+/* Which encoding does terminal expect stream to be.  */
+#define GRUB_TERM_CODE_TYPE_SHIFT       3
+#define GRUB_TERM_CODE_TYPE_MASK	        (7 << GRUB_TERM_CODE_TYPE_SHIFT)
+/* Only ASCII characters accepted.  */
+#define GRUB_TERM_CODE_TYPE_ASCII	        (0 << GRUB_TERM_CODE_TYPE_SHIFT)
+/* Expects CP-437 characters (ASCII + pseudographics).  */
+#define GRUB_TERM_CODE_TYPE_CP437	                (1 << GRUB_TERM_CODE_TYPE_SHIFT)
+/* UTF-8 stream in logical order. Usually used for terminals
+   which just forward the stream to another computer.  */
+#define GRUB_TERM_CODE_TYPE_UTF8_LOGICAL       	(2 << GRUB_TERM_CODE_TYPE_SHIFT)
+/* UTF-8 in visual order. Like UTF-8 logical but for buggy endpoints.  */
+#define GRUB_TERM_CODE_TYPE_UTF8_VISUAL	        (3 << GRUB_TERM_CODE_TYPE_SHIFT)
+/* Glyph description in visual order.  */
+#define GRUB_TERM_CODE_TYPE_VISUAL_GLYPHS       (4 << GRUB_TERM_CODE_TYPE_SHIFT)
+
+
+/* Bitmasks for modifier keys returned by grub_getkeystatus.  */
+#define GRUB_TERM_STATUS_RSHIFT	(1 << 0)
+#define GRUB_TERM_STATUS_LSHIFT	(1 << 1)
+#define GRUB_TERM_STATUS_RCTRL	(1 << 2)
+#define GRUB_TERM_STATUS_RALT	(1 << 3)
+#define GRUB_TERM_STATUS_SCROLL	(1 << 4)
+#define GRUB_TERM_STATUS_NUM	(1 << 5)
+#define GRUB_TERM_STATUS_CAPS	(1 << 6)
+#define GRUB_TERM_STATUS_LCTRL	(1 << 8)
+#define GRUB_TERM_STATUS_LALT	(1 << 9)
+
+/* Menu-related geometrical constants.  */
+
+/* The number of columns/lines between messages/borders/etc.  */
+#define GRUB_TERM_MARGIN	1
+
+/* The number of columns of scroll information.  */
+#define GRUB_TERM_SCROLL_WIDTH	1
+
+struct grub_term_input
+{
+  /* The next terminal.  */
+  struct grub_term_input *next;
+  struct grub_term_input **prev;
+
+  /* The terminal name.  */
+  const char *name;
+
+  /* Initialize the terminal.  */
+  grub_err_t (*init) (struct grub_term_input *term);
+
+  /* Clean up the terminal.  */
+  grub_err_t (*fini) (struct grub_term_input *term);
+
+  /* Get a character if any input character is available. Otherwise return -1  */
+  int (*getkey) (struct grub_term_input *term);
+
+  /* Get keyboard modifier status.  */
+  int (*getkeystatus) (struct grub_term_input *term);
+
+  void *data;
+};
+typedef struct grub_term_input *grub_term_input_t;
+
+/* Made in a way to fit into uint32_t and so be passed in a register.  */
+struct grub_term_coordinate
+{
+  grub_uint16_t x;
+  grub_uint16_t y;
+};
+
+struct grub_term_output
+{
+  /* The next terminal.  */
+  struct grub_term_output *next;
+  struct grub_term_output **prev;
+
+  /* The terminal name.  */
+  const char *name;
+
+  /* Initialize the terminal.  */
+  grub_err_t (*init) (struct grub_term_output *term);
+
+  /* Clean up the terminal.  */
+  grub_err_t (*fini) (struct grub_term_output *term);
+
+  /* Put a character. C is encoded in Unicode.  */
+  void (*putchar) (struct grub_term_output *term,
+		   const struct grub_unicode_glyph *c);
+
+  /* Get the number of columns occupied by a given character C. C is
+     encoded in Unicode.  */
+  grub_size_t (*getcharwidth) (struct grub_term_output *term,
+			       const struct grub_unicode_glyph *c);
+
+  /* Get the screen size.  */
+  struct grub_term_coordinate (*getwh) (struct grub_term_output *term);
+
+  /* Get the cursor position. The return value is ((X << 8) | Y).  */
+  struct grub_term_coordinate (*getxy) (struct grub_term_output *term);
+
+  /* Go to the position (X, Y).  */
+  void (*gotoxy) (struct grub_term_output *term,
+		  struct grub_term_coordinate pos);
+
+  /* Clear the screen.  */
+  void (*cls) (struct grub_term_output *term);
+
+  /* Set the current color to be used */
+  void (*setcolorstate) (struct grub_term_output *term,
+			 grub_term_color_state state);
+
+  /* Turn on/off the cursor.  */
+  void (*setcursor) (struct grub_term_output *term, int on);
+
+  /* Update the screen.  */
+  void (*refresh) (struct grub_term_output *term);
+
+  /* gfxterm only: put in fullscreen mode.  */
+  grub_err_t (*fullscreen) (void);
+
+  /* The feature flags defined above.  */
+  grub_uint32_t flags;
+
+  /* Progress data. */
+  grub_uint32_t progress_update_divisor;
+  grub_uint32_t progress_update_counter;
+
+  void *data;
+};
+typedef struct grub_term_output *grub_term_output_t;
+
+#define GRUB_TERM_DEFAULT_NORMAL_COLOR 0x07
+#define GRUB_TERM_DEFAULT_HIGHLIGHT_COLOR 0x70
+#define GRUB_TERM_DEFAULT_STANDARD_COLOR 0x07
+
+/* Current color state.  */
+extern grub_uint8_t EXPORT_VAR(grub_term_normal_color);
+extern grub_uint8_t EXPORT_VAR(grub_term_highlight_color);
+
+extern struct grub_term_output *EXPORT_VAR(grub_term_outputs_disabled);
+extern struct grub_term_input *EXPORT_VAR(grub_term_inputs_disabled);
+extern struct grub_term_output *EXPORT_VAR(grub_term_outputs);
+extern struct grub_term_input *EXPORT_VAR(grub_term_inputs);
+
+static inline void
+grub_term_register_input (const char *name __attribute__ ((unused)),
+			  grub_term_input_t term)
+{
+  if (grub_term_inputs)
+    grub_list_push (GRUB_AS_LIST_P (&grub_term_inputs_disabled),
+		    GRUB_AS_LIST (term));
+  else
+    {
+      /* If this is the first terminal, enable automatically.  */
+      if (! term->init || term->init (term) == GRUB_ERR_NONE)
+	grub_list_push (GRUB_AS_LIST_P (&grub_term_inputs), GRUB_AS_LIST (term));
+    }
+}
+
+static inline void
+grub_term_register_input_inactive (const char *name __attribute__ ((unused)),
+				   grub_term_input_t term)
+{
+  grub_list_push (GRUB_AS_LIST_P (&grub_term_inputs_disabled),
+		  GRUB_AS_LIST (term));
+}
+
+static inline void
+grub_term_register_input_active (const char *name __attribute__ ((unused)),
+				 grub_term_input_t term)
+{
+  if (! term->init || term->init (term) == GRUB_ERR_NONE)
+    grub_list_push (GRUB_AS_LIST_P (&grub_term_inputs), GRUB_AS_LIST (term));
+}
+
+static inline void
+grub_term_register_output (const char *name __attribute__ ((unused)),
+			   grub_term_output_t term)
+{
+  if (grub_term_outputs)
+    grub_list_push (GRUB_AS_LIST_P (&grub_term_outputs_disabled),
+		    GRUB_AS_LIST (term));
+  else
+    {
+      /* If this is the first terminal, enable automatically.  */
+      if (! term->init || term->init (term) == GRUB_ERR_NONE)
+	grub_list_push (GRUB_AS_LIST_P (&grub_term_outputs),
+			GRUB_AS_LIST (term));
+    }
+}
+
+static inline void
+grub_term_register_output_inactive (const char *name __attribute__ ((unused)),
+				    grub_term_output_t term)
+{
+  grub_list_push (GRUB_AS_LIST_P (&grub_term_outputs_disabled),
+		  GRUB_AS_LIST (term));
+}
+
+static inline void
+grub_term_register_output_active (const char *name __attribute__ ((unused)),
+				  grub_term_output_t term)
+{
+  if (! term->init || term->init (term) == GRUB_ERR_NONE)
+    grub_list_push (GRUB_AS_LIST_P (&grub_term_outputs),
+		    GRUB_AS_LIST (term));
+}
+
+static inline void
+grub_term_unregister_input (grub_term_input_t term)
+{
+  grub_list_remove (GRUB_AS_LIST (term));
+  grub_list_remove (GRUB_AS_LIST (term));
+}
+
+static inline void
+grub_term_unregister_output (grub_term_output_t term)
+{
+  grub_list_remove (GRUB_AS_LIST (term));
+  grub_list_remove (GRUB_AS_LIST (term));
+}
+
+#define FOR_ACTIVE_TERM_INPUTS(var) FOR_LIST_ELEMENTS((var), (grub_term_inputs))
+#define FOR_DISABLED_TERM_INPUTS(var) FOR_LIST_ELEMENTS((var), (grub_term_inputs_disabled))
+#define FOR_ACTIVE_TERM_OUTPUTS(var) FOR_LIST_ELEMENTS((var), (grub_term_outputs))
+#define FOR_DISABLED_TERM_OUTPUTS(var) FOR_LIST_ELEMENTS((var), (grub_term_outputs_disabled))
+
+void grub_putcode (grub_uint32_t code, struct grub_term_output *term);
+int EXPORT_FUNC(grub_getkey) (void);
+int EXPORT_FUNC(grub_getkey_noblock) (void);
+extern int (*EXPORT_VAR (grub_key_remap))(int key);
+void grub_cls (void);
+void EXPORT_FUNC(grub_refresh) (void);
+void grub_puts_terminal (const char *str, struct grub_term_output *term);
+struct grub_term_coordinate *grub_term_save_pos (void);
+void grub_term_restore_pos (struct grub_term_coordinate *pos);
+
+static inline unsigned grub_term_width (struct grub_term_output *term)
+{
+  return term->getwh(term).x ? : 80;
+}
+
+static inline unsigned grub_term_height (struct grub_term_output *term)
+{
+  return term->getwh(term).y ? : 24;
+}
+
+static inline struct grub_term_coordinate
+grub_term_getxy (struct grub_term_output *term)
+{
+  return term->getxy (term);
+}
+
+static inline void
+grub_term_refresh (struct grub_term_output *term)
+{
+  if (term->refresh)
+    term->refresh (term);
+}
+
+static inline void
+grub_term_gotoxy (struct grub_term_output *term, struct grub_term_coordinate pos)
+{
+  term->gotoxy (term, pos);
+}
+
+static inline void 
+grub_term_setcolorstate (struct grub_term_output *term, 
+			 grub_term_color_state state)
+{
+  if (term->setcolorstate)
+    term->setcolorstate (term, state);
+}
+
+static inline void
+grub_setcolorstate (grub_term_color_state state)
+{
+  struct grub_term_output *term;
+  
+  FOR_ACTIVE_TERM_OUTPUTS(term)
+    grub_term_setcolorstate (term, state);
+}
+
+/* Turn on/off the cursor.  */
+static inline void 
+grub_term_setcursor (struct grub_term_output *term, int on)
+{
+  if (term->setcursor)
+    term->setcursor (term, on);
+}
+
+static inline void 
+grub_term_cls (struct grub_term_output *term)
+{
+  if (term->cls)
+    (term->cls) (term);
+  else
+    {
+      grub_putcode ('\n', term);
+      grub_term_refresh (term);
+    }
+}
+
+#if HAVE_FONT_SOURCE
+
+grub_size_t
+grub_unicode_estimate_width (const struct grub_unicode_glyph *c);
+
+#else
+
+static inline grub_size_t
+grub_unicode_estimate_width (const struct grub_unicode_glyph *c __attribute__ ((unused)))
+{
+  if (grub_unicode_get_comb_type (c->base))
+    return 0;
+  return 1;
+}
+
+#endif
+
+#define GRUB_TERM_TAB_WIDTH 8
+
+static inline grub_size_t
+grub_term_getcharwidth (struct grub_term_output *term,
+			const struct grub_unicode_glyph *c)
+{
+  if (c->base == '\t')
+    return GRUB_TERM_TAB_WIDTH;
+
+  if (term->getcharwidth)
+    return term->getcharwidth (term, c);
+  else if (((term->flags & GRUB_TERM_CODE_TYPE_MASK)
+	    == GRUB_TERM_CODE_TYPE_UTF8_LOGICAL)
+	   || ((term->flags & GRUB_TERM_CODE_TYPE_MASK)
+	       == GRUB_TERM_CODE_TYPE_UTF8_VISUAL)
+	   || ((term->flags & GRUB_TERM_CODE_TYPE_MASK)
+	       == GRUB_TERM_CODE_TYPE_VISUAL_GLYPHS))
+    return grub_unicode_estimate_width (c);
+  else
+    return 1;
+}
+
+struct grub_term_autoload
+{
+  struct grub_term_autoload *next;
+  char *name;
+  char *modname;
+};
+
+extern struct grub_term_autoload *grub_term_input_autoload;
+extern struct grub_term_autoload *grub_term_output_autoload;
+
+static inline void
+grub_print_spaces (struct grub_term_output *term, int number_spaces)
+{
+  while (--number_spaces >= 0)
+    grub_putcode (' ', term);
+}
+
+extern void (*EXPORT_VAR (grub_term_poll_usb)) (int wait_for_completion);
+
+#define GRUB_TERM_REPEAT_PRE_INTERVAL 400
+#define GRUB_TERM_REPEAT_INTERVAL 50
+
+#endif /* ! ASM_FILE */
+
+#endif /* ! GRUB_TERM_HEADER */

GRUB2/MOD_SRC/grub-2.04/include/grub/ventoy.h

@@ -21,7 +21,7 @@
 #ifndef __VENTOY_H__
 #define __VENTOY_H__
 
-#define COMPILE_ASSERT(expr)  extern char __compile_assert[(expr) ? 1 : -1]
+#define COMPILE_ASSERT(a, expr)  extern char __compile_assert##a[(expr) ? 1 : -1]
 
 #define VENTOY_COMPATIBLE_STR      "VENTOY COMPATIBLE"
 #define VENTOY_COMPATIBLE_STR_LEN  17
@@ -139,11 +139,21 @@ typedef struct ventoy_windows_data
 }ventoy_windows_data;
 
 
+typedef struct ventoy_secure_data
+{
+    grub_uint8_t magic1[16];     /* VENTOY_GUID */
+    grub_uint8_t diskuuid[16];   
+    grub_uint8_t Checksum[16];    
+    grub_uint8_t adminSHA256[32];
+    grub_uint8_t reserved[4000];
+    grub_uint8_t magic2[16];     /* VENTOY_GUID */
+}ventoy_secure_data;
 
 #pragma pack()
 
 // compile assert check : sizeof(ventoy_os_param) must be 512
-COMPILE_ASSERT(sizeof(ventoy_os_param) == 512);
+COMPILE_ASSERT(1,sizeof(ventoy_os_param) == 512);
+COMPILE_ASSERT(2,sizeof(ventoy_secure_data) == 4096);
 
 
 
@@ -176,6 +186,18 @@ typedef struct ventoy_chain_head
     grub_uint32_t virt_chunk_num;
 }ventoy_chain_head;
 
+typedef struct ventoy_image_desc
+{
+    grub_uint64_t disk_size;
+    grub_uint64_t part1_size;
+    grub_uint8_t  disk_uuid[16];
+    grub_uint8_t  disk_signature[4];
+    grub_uint32_t img_chunk_count;
+    /* ventoy_img_chunk list */
+}ventoy_image_desc;
+
+
+
 typedef struct ventoy_img_chunk
 {
     grub_uint32_t img_start_sector; // sector size: 2KB
@@ -242,7 +264,6 @@ typedef struct ventoy_grub_param
 
 #pragma pack()
 
-
 int grub_ext_get_file_chunk(grub_uint64_t part_start, grub_file_t file, ventoy_img_chunk_list *chunk_list);
 int grub_fat_get_file_chunk(grub_uint64_t part_start, grub_file_t file, ventoy_img_chunk_list *chunk_list);
 void grub_iso9660_set_nojoliet(int nojoliet);

GRUB2/MOD_SRC/grub-2.04/install.sh

@@ -12,16 +12,28 @@ make install
 PATH=$PATH:$VT_DIR/GRUB2/INSTALL/bin/:$VT_DIR/GRUB2/INSTALL/sbin/
 
 net_modules_legacy="net tftp http"
-all_modules_legacy="date drivemap blocklist newc vga_text ntldr search at_keyboard usb_keyboard  gcry_md5 hashsum gzio xzio lzopio lspci pci ext2 xfs ventoy chain read halt iso9660 linux16 test true sleep reboot echo videotest videoinfo videotest_checksum video_colors video_cirrus video_bochs vga vbe video_fb font video gettext extcmd terminal  linux minicmd help configfile tr trig boot biosdisk disk ls tar squash4 password_pbkdf2 all_video png jpeg part_gpt part_msdos fat exfat ntfs loopback gzio normal  udf gfxmenu gfxterm gfxterm_background gfxterm_menu"
+all_modules_legacy="setkey date drivemap blocklist regexp newc vga_text ntldr search at_keyboard usb_keyboard  gcry_md5 hashsum gzio xzio lzopio lspci pci ext2 xfs ventoy chain read halt iso9660 linux16 test true sleep reboot echo videotest videoinfo videotest_checksum video_colors video_cirrus video_bochs vga vbe video_fb font video gettext extcmd terminal  linux minicmd help configfile tr trig boot biosdisk disk ls tar squash4 password_pbkdf2 all_video png jpeg part_gpt part_msdos fat exfat ntfs loopback gzio normal  udf gfxmenu gfxterm gfxterm_background gfxterm_menu"
 
 net_modules_uefi="efinet net tftp http"
-all_modules_uefi="blocklist ventoy test newc search at_keyboard usb_keyboard  gcry_md5 hashsum gzio xzio lzopio ext2 xfs read halt sleep serial terminfo png password_pbkdf2 gcry_sha512 pbkdf2 part_gpt part_msdos ls tar squash4 loopback part_apple minicmd diskfilter linux relocator jpeg iso9660 udf hfsplus halt acpi mmap gfxmenu video_colors trig bitmap_scale gfxterm bitmap font fat exfat ntfs fshelp efifwsetup reboot echo configfile normal terminal gettext chain  priority_queue bufio datetime cat extcmd crypto gzio boot all_video efi_gop efi_uga video_bochs video_cirrus video video_fb gfxterm_background gfxterm_menu"
+all_modules_uefi="setkey blocklist ventoy test regexp newc search at_keyboard usb_keyboard  gcry_md5 hashsum gzio xzio lzopio ext2 xfs read halt sleep serial terminfo png password_pbkdf2 gcry_sha512 pbkdf2 part_gpt part_msdos ls tar squash4 loopback part_apple minicmd diskfilter linux relocator jpeg iso9660 udf hfsplus halt acpi mmap gfxmenu video_colors trig bitmap_scale gfxterm bitmap font fat exfat ntfs fshelp efifwsetup reboot echo configfile normal terminal gettext chain  priority_queue bufio datetime cat extcmd crypto gzio boot all_video efi_gop efi_uga video_bochs video_cirrus video video_fb gfxterm_background gfxterm_menu"
+
+all_modules_arm64_uefi="setkey blocklist ventoy test regexp newc search  gcry_md5 hashsum gzio xzio lzopio ext2 xfs read halt sleep serial terminfo png password_pbkdf2 gcry_sha512 pbkdf2 part_gpt part_msdos ls tar squash4 loopback part_apple minicmd diskfilter linux jpeg iso9660 udf hfsplus halt acpi mmap gfxmenu video_colors trig bitmap_scale gfxterm bitmap font fat exfat ntfs fshelp efifwsetup reboot echo configfile normal terminal gettext chain  priority_queue bufio datetime cat extcmd crypto gzio boot all_video efi_gop video video_fb gfxterm_background gfxterm_menu"
+
 
 if [ "$1" = "uefi" ]; then
     all_modules="$net_modules_uefi $all_modules_uefi "
-    grub-mkimage -v --directory "$VT_DIR/GRUB2/INSTALL/lib/grub/x86_64-efi" --prefix '(,2)/grub' --output "$VT_DIR/INSTALL/EFI/BOOT/grubx64_real.efi"  --format 'x86_64-efi' --compression 'auto'  $all_modules_uefi 'fat' 'part_msdos'
+
+    grub-mkimage -v --directory "$VT_DIR/GRUB2/INSTALL/lib/grub/x86_64-efi" --prefix '(,2)/grub' --output "$VT_DIR/INSTALL/EFI/BOOT/grubx64_real.efi"  --format 'x86_64-efi' --compression 'auto'  $all_modules_uefi
 
     #grub-mkimage -v --directory "$VT_DIR/GRUB2/INSTALL/lib/grub/x86_64-efi" -c "$VT_DIR/LiveCD/GRUB/embed.cfg" --prefix '/EFI/boot' --output "$VT_DIR/LiveCD/GRUB/bootx64.efi"  --format 'x86_64-efi' --compression 'auto'  $all_modules_uefi 'fat' 'part_msdos'
+elif [ "$1" = "i386efi" ]; then
+    all_modules="$net_modules_uefi $all_modules_uefi "
+
+    grub-mkimage -v --directory "$VT_DIR/GRUB2/INSTALL/lib/grub/i386-efi" --prefix '(,2)/grub' --output "$VT_DIR/INSTALL/EFI/BOOT/grubia32_real.efi"  --format 'i386-efi' --compression 'auto'  $all_modules_uefi
+elif [ "$1" = "arm64" ]; then
+    all_modules="$net_modules_uefi $all_modules_arm64_uefi "
+
+    grub-mkimage -v --directory "$VT_DIR/GRUB2/INSTALL/lib/grub/arm64-efi" --prefix '(,2)/grub' --output "$VT_DIR/INSTALL/EFI/BOOT/BOOTAA64.EFI"  --format 'arm64-efi' --compression 'auto'  $all_modules_arm64_uefi
 else
     all_modules="$net_modules_legacy $all_modules_legacy "
     grub-mkimage -v --directory "$VT_DIR/GRUB2/INSTALL/lib/grub/i386-pc" --prefix '(,2)/grub' --output "$VT_DIR/INSTALL/grub/i386-pc/core.img"  --format 'i386-pc' --compression 'auto'  $all_modules_legacy  'fat' 'part_msdos' 'biosdisk' 
@@ -37,17 +49,50 @@ if [ "$1" = "uefi" ]; then
     rm -f $VT_DIR/GRUB2/NBP/core.efi
     cp -a $VT_DIR/GRUB2/PXE/grub2/x86_64-efi/core.efi  $VT_DIR/GRUB2/NBP/core.efi || exit 1
     
-    rm -f $VT_DIR/INSTALL/grub/x86_64-efi/normal.mod
+    rm -rf $VT_DIR/INSTALL/grub/x86_64-efi
+    mkdir -p $VT_DIR/INSTALL/grub/x86_64-efi
+        
     cp -a $VT_DIR/GRUB2/PXE/grub2/x86_64-efi/normal.mod    $VT_DIR/INSTALL/grub/x86_64-efi/normal.mod  || exit 1      
 
     #copy other modules
     ls -1 $VT_DIR/GRUB2/INSTALL/lib/grub/x86_64-efi/ | egrep '\.(lst|mod)$' | while read line; do
         if ! echo $all_modules | grep -q " ${line%.mod} "; then
             echo "Copy $line ..."
-            rm -f $VT_DIR/INSTALL/grub/x86_64-efi/$line
             cp -a $VT_DIR/GRUB2/INSTALL/lib/grub/x86_64-efi/$line    $VT_DIR/INSTALL/grub/x86_64-efi/
         fi
     done
+elif [ "$1" = "i386efi" ]; then
+    rm -f $VT_DIR/GRUB2/NBP/core.efi
+    cp -a $VT_DIR/GRUB2/PXE/grub2/i386-efi/core.efi  $VT_DIR/GRUB2/NBP/core.efi || exit 1
+    
+    rm -rf $VT_DIR/INSTALL/grub/i386-efi
+    mkdir -p $VT_DIR/INSTALL/grub/i386-efi
+
+    cp -a $VT_DIR/GRUB2/PXE/grub2/i386-efi/normal.mod    $VT_DIR/INSTALL/grub/i386-efi/normal.mod  || exit 1      
+
+    #copy other modules
+    ls -1 $VT_DIR/GRUB2/INSTALL/lib/grub/i386-efi/ | egrep '\.(lst|mod)$' | while read line; do
+        if ! echo $all_modules | grep -q " ${line%.mod} "; then
+            echo "Copy $line ..."
+            cp -a $VT_DIR/GRUB2/INSTALL/lib/grub/i386-efi/$line    $VT_DIR/INSTALL/grub/i386-efi/
+        fi
+    done
+elif [ "$1" = "arm64" ]; then
+    rm -f $VT_DIR/GRUB2/NBP/core.efi
+    cp -a $VT_DIR/GRUB2/PXE/grub2/arm64-efi/core.efi  $VT_DIR/GRUB2/NBP/core.efi || exit 1
+    
+    rm -rf $VT_DIR/INSTALL/grub/arm64-efi
+    mkdir -p $VT_DIR/INSTALL/grub/arm64-efi
+
+    cp -a $VT_DIR/GRUB2/PXE/grub2/arm64-efi/normal.mod    $VT_DIR/INSTALL/grub/arm64-efi/normal.mod  || exit 1      
+
+    #copy other modules
+    ls -1 $VT_DIR/GRUB2/INSTALL/lib/grub/arm64-efi/ | egrep '\.(lst|mod)$' | while read line; do
+        if ! echo $all_modules | grep -q " ${line%.mod} "; then
+            echo "Copy $line ..."
+            cp -a $VT_DIR/GRUB2/INSTALL/lib/grub/arm64-efi/$line    $VT_DIR/INSTALL/grub/arm64-efi/
+        fi
+    done
 else
     rm -f $VT_DIR/GRUB2/NBP/core.0
     cp -a $VT_DIR/GRUB2/PXE/grub2/i386-pc/core.0    $VT_DIR/GRUB2/NBP/core.0  || exit 1

GRUB2/buildgrub.sh

@@ -31,5 +31,13 @@ make -j 16
 sh install.sh  uefi
 
 
+#build for IA32 EFI
+make distclean
+./autogen.sh
+./configure --target=i386 --with-platform=efi  --prefix=$VT_GRUB_DIR/INSTALL/
+make -j 16
+sh install.sh  i386efi
+
+
 cd ../../
 

GenUUID/build.sh

@@ -1,14 +0,0 @@
-#!/bin/bash
-
-/opt/diet32/bin/diet gcc -Os -m32 vtoy_gen_uuid.c -o  vtoy_gen_uuid
-
-if [ -e vtoy_gen_uuid ]; then
-    echo -e '\n############### SUCCESS ###############\n'
-
-    rm -f ../INSTALL/tool/vtoy_gen_uuid
-    cp -a vtoy_gen_uuid ../INSTALL/tool/vtoy_gen_uuid
-else
-    echo -e '\n############### FAILED ################\n'
-    exit 1
-fi
-

GenUUID/vtoy_gen_uuid.c

@@ -1,50 +0,0 @@
-/******************************************************************************
- * vtoy_gen_uuid.c 
- *
- * Copyright (c) 2020, longpanda <admin@ventoy.net>
- *
- * This program 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.
- * 
- * This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#include <unistd.h>
-#include <fcntl.h>
-
-int main()
-{
-    int i;
-    int fd;
-    unsigned char uuid[16];
-    
-    fd = open("/dev/random", O_RDONLY);
-    if (fd < 0)
-    {
-        srand(time(NULL));        
-        for (i = 0; i < 16; i++)
-        {
-            uuid[i] = (unsigned char)(rand());
-        }
-    }
-    else
-    {
-        read(fd, uuid, 16);
-    }
-    
-    fwrite(uuid, 1, 16, stdout);
-    return 0;
-}

IMG/cpio/sbin/init

@@ -36,18 +36,25 @@ export SED=$BUSYBOX_PATH/sed
 export SLEEP=$BUSYBOX_PATH/sleep
 export HEAD=$BUSYBOX_PATH/head
 
+if [ -e $BUSYBOX_PATH/32h ]; then
     if [ -e $BUSYBOX_PATH/64h ]; then
-    $BUSYBOX_PATH/xzminidec32 < $BUSYBOX_PATH/busybox32.xz > $BUSYBOX_PATH/busybox
-    $BUSYBOX_PATH/vtchmod32 $BUSYBOX_PATH/busybox
+        #this is arm64
+        $BUSYBOX_PATH/xzminidecaa64 < $BUSYBOX_PATH/busyboxaa64.xz > $BUSYBOX_PATH/busybox
+        $BUSYBOX_PATH/vtchmodaa64 $BUSYBOX_PATH/busybox
     else
+        #this is x86_64
         $BUSYBOX_PATH/xzminidec64 < $BUSYBOX_PATH/busybox64.xz > $BUSYBOX_PATH/busybox
         if [ -s $BUSYBOX_PATH/busybox ]; then
             $BUSYBOX_PATH/vtchmod64 $BUSYBOX_PATH/busybox
         else
-        $BUSYBOX_PATH/xzminidec64_uclibc < $BUSYBOX_PATH/busybox64.xz > $BUSYBOX_PATH/busybox 
-        $BUSYBOX_PATH/vtchmod64_uclibc $BUSYBOX_PATH/busybox
+            $BUSYBOX_PATH/xzminidec64_musl < $BUSYBOX_PATH/busybox64.xz > $BUSYBOX_PATH/busybox 
+            $BUSYBOX_PATH/vtchmod64_musl $BUSYBOX_PATH/busybox
         fi
     fi
+else
+    $BUSYBOX_PATH/xzminidec32 < $BUSYBOX_PATH/busybox32.xz > $BUSYBOX_PATH/busybox
+    $BUSYBOX_PATH/vtchmod32 $BUSYBOX_PATH/busybox
+fi
 
 if [ -e $BUSYBOX_PATH/busybox ]; then
     $BUSYBOX_PATH/busybox --install $BUSYBOX_PATH
@@ -84,16 +91,35 @@ else
     xz -d -c loop.cpio.xz | cpio -idm 2>>$VTLOG
 fi
 
+if [ -e $BUSYBOX_PATH/32h ]; then
     if [ -e $BUSYBOX_PATH/64h ]; then
-    echo "Use busybox32 toolkit ..." >>$VTLOG
-    ln -s $BUSYBOX_PATH/xzminidec32 $BUSYBOX_PATH/xzminidec
-    ln -s $VTOY_PATH/tool/dmsetup32 $VTOY_PATH/tool/dmsetup
-    ln -s $VTOY_PATH/tool/lunzip32 $VTOY_PATH/tool/lunzip
+        echo "Use ARM64 busybox toolkit ..." >>$VTLOG
+        echo aarch64 > $VTOY_PATH/ventoy_arch
+        ln -s $BUSYBOX_PATH/xzminidecaa64 $BUSYBOX_PATH/xzminidec
+        ln -s $VTOY_PATH/tool/dmsetupaa64 $VTOY_PATH/tool/dmsetup
+        ln -s $VTOY_PATH/tool/lunzipaa64 $VTOY_PATH/tool/lunzip
+        
+        rm -f $VTOY_PATH/tool/lz4cat $VTOY_PATH/tool/zstdcat
+        ln -s $VTOY_PATH/tool/lz4cataa64 $VTOY_PATH/tool/lz4cat
+        ln -s $VTOY_PATH/tool/zstdcataa64 $VTOY_PATH/tool/zstdcat
+        
     else
-    echo "Use busybox64 toolkit ..." >>$VTLOG
+        echo "Use x86_64 busybox toolkit ..." >>$VTLOG
+        echo x86_64 > $VTOY_PATH/ventoy_arch
         ln -s $BUSYBOX_PATH/xzminidec64 $BUSYBOX_PATH/xzminidec
         ln -s $VTOY_PATH/tool/dmsetup64 $VTOY_PATH/tool/dmsetup
         ln -s $VTOY_PATH/tool/lunzip64 $VTOY_PATH/tool/lunzip
+        
+        rm -f $VTOY_PATH/tool/lz4cat $VTOY_PATH/tool/zstdcat
+        ln -s $VTOY_PATH/tool/lz4cat64 $VTOY_PATH/tool/lz4cat
+        ln -s $VTOY_PATH/tool/zstdcat64 $VTOY_PATH/tool/zstdcat
+    fi
+else
+    echo "Use i386 busybox toolkit ..." >>$VTLOG
+    echo i386 > $VTOY_PATH/ventoy_arch
+    ln -s $BUSYBOX_PATH/xzminidec32 $BUSYBOX_PATH/xzminidec
+    ln -s $VTOY_PATH/tool/dmsetup32 $VTOY_PATH/tool/dmsetup
+    ln -s $VTOY_PATH/tool/lunzip32 $VTOY_PATH/tool/lunzip
 fi
 
 rm -f *.xz

IMG/cpio/ventoy/hook/austrumi/disk_hook.sh

@@ -0,0 +1,54 @@
+#!/ventoy/busybox/sh
+#************************************************************************************
+# Copyright (c) 2020, longpanda <admin@ventoy.net>
+# 
+# This program 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.
+# 
+# This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
+# 
+#************************************************************************************
+
+. /ventoy/hook/ventoy-hook-lib.sh
+
+VTPATH_OLD=$PATH; PATH=$BUSYBOX_PATH:$VTOY_PATH/tool:$PATH
+
+vtdiskname=$(get_ventoy_disk_name)
+if [ "$vtdiskname" = "unknown" ]; then
+    vtlog "ventoy disk not found"
+    PATH=$VTPATH_OLD
+    exit 0
+fi
+
+if check_usb_disk_ready "$vtdiskname"; then
+    vtlog "check_usb_disk_ready ok"
+else
+    vtlog "check_usb_disk_ready error"
+    PATH=$VTPATH_OLD
+    exit 0
+fi
+
+ventoy_udev_disk_common_hook "${vtdiskname#/dev/}2"
+
+# blkdev_num=$($VTOY_PATH/tool/dmsetup ls | grep ventoy | sed 's/.*(\([0-9][0-9]*\),.*\([0-9][0-9]*\).*/\1:\2/')
+# blkdev_num_mknod=$($VTOY_PATH/tool/dmsetup ls | grep ventoy | sed 's/.*(\([0-9][0-9]*\),.*\([0-9][0-9]*\).*/\1 \2/')
+# vtDM=$(ventoy_find_dm_id ${blkdev_num})
+
+# vtlog "blkdev_num=$blkdev_num blkdev_num_mknod=$blkdev_num_mknod vtDM=$vtDM"
+
+# if [ -b /dev/$vtDM ]; then
+    # vtlog "dev already exist ..."
+# else
+    # vtlog "mknode dev ..."
+    # mknod -m 660 /dev/$vtDM  b  $blkdev_num_mknod
+# fi
+
+PATH=$VTPATH_OLD

IMG/cpio/ventoy/hook/austrumi/ventoy-hook.sh

@@ -0,0 +1,24 @@
+#!/ventoy/busybox/sh
+#************************************************************************************
+# Copyright (c) 2020, longpanda <admin@ventoy.net>
+# 
+# This program 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.
+# 
+# This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
+# 
+#************************************************************************************
+
+. $VTOY_PATH/hook/ventoy-os-lib.sh
+
+$SED "/find_usb *(/a $BUSYBOX_PATH/sh $VTOY_PATH/hook/austrumi/disk_hook.sh" -i /init
+$SED "s/BOOT_TYPE=livecd/BOOT_TYPE=usb/g" -i /init
+

IMG/cpio/ventoy/hook/debian/antix-disk.sh

@@ -43,6 +43,7 @@ ventoy_os_install_dmsetup_by_unsquashfs() {
     vtoy_unsquashfs -d $VTOY_PATH/sqfs -n -q -e $VTOY_PATH/fsextract $VTOY_PATH/fsdisk
 
     if ! [ -e $VTOY_PATH/sqfs${dmModPath} ]; then
+        rm -rf $VTOY_PATH/sqfs
         dmModPath="/lib/modules/$vtKerVer/kernel/drivers/md/dm-mod.$vtKoPo"
         echo $dmModPath > $VTOY_PATH/fsextract
         vtoy_unsquashfs -d $VTOY_PATH/sqfs -n -q -e $VTOY_PATH/fsextract $VTOY_PATH/fsdisk

IMG/cpio/ventoy/hook/debian/antix-hook.sh

@@ -23,7 +23,12 @@ elif $GREP -q '\[ "$FILTERED_LIST" \]' /init; then
     $SED '/\[ "$FILTERED_LIST" \]/i\    FILTERED_LIST="/dev/mapper/ventoy $FILTERED_LIST"' -i /init
 fi
 
+if $GREP -q '_search_for_boot_device_' /init; then
     $SED -i "/_search_for_boot_device_/a\ $BUSYBOX_PATH/sh $VTOY_PATH/hook/debian/antix-disk.sh" /init
+elif $GREP -q 'FILTERED_LIST=.*ventoy' /init; then
+    $SED -i "/FILTERED_LIST=.*ventoy/i\ $BUSYBOX_PATH/sh $VTOY_PATH/hook/debian/antix-disk.sh" /init
+fi
+
 
 if [ -f $VTOY_PATH/ventoy_persistent_map ]; then
     $SED 's#for param in $cmdline#for param in persist_all $cmdline#g' -i /init

IMG/cpio/ventoy/hook/debian/default-hook.sh

@@ -33,12 +33,11 @@ if [ -e /init ] && $GREP -q '^mountroot$' /init; then
     fi
 elif [ -e "$CD_DETECT" ]; then
     echo "$CD_DETECT exist, now add hook in it..." >> $VTLOG
-
     $SED  "1 a $BUSYBOX_PATH/sh $VTOY_PATH/hook/debian/disk_mount_hook.sh"  -i "$CD_DETECT"
-    TITLE_LINE=$($GREP -m1 '^hw-detect.*detect_progress_title' "$CD_DETECT")
-    if [ $? -eq 0 ]; then
-        echo "add $TITLE_LINE for hook" >> $VTLOG
-        $SED  "1 a$TITLE_LINE"  -i "$CD_DETECT"
+    
+    if [ -e /bin/list-devices ]; then
+        mv /bin/list-devices /bin/list-devices-bk
+        cp -a /ventoy/hook/debian/list-devices /bin/list-devices
     fi
 elif [ -e /init ] && $GREP -q '/start-udev$' /init; then
     echo "Here use notify ..." >> $VTLOG
@@ -73,5 +72,8 @@ if [ -f /mod.img ] && [ -f /mod/fs/cramfs.ko ]; then
     $BUSYBOX_PATH/rmmod cramfs
 fi
 
-
+#for siduction-patience-nox-
+if [ -f /scripts/fll ]; then
+    $SED  "/unset FINGERED/a\\echo '/dev/mapper/ventoy';return;"  -i /scripts/fll
+fi
 

IMG/cpio/ventoy/hook/debian/kylin-disk.sh

@@ -0,0 +1,68 @@
+#!/ventoy/busybox/sh
+#************************************************************************************
+# Copyright (c) 2020, longpanda <admin@ventoy.net>
+# 
+# This program 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.
+# 
+# This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
+# 
+#************************************************************************************
+
+. /ventoy/hook/ventoy-hook-lib.sh
+
+VTPATH_OLD=$PATH; PATH=$BUSYBOX_PATH:$VTOY_PATH/tool:$PATH
+
+
+ventoy_os_install_dmsetup_by_fuse() {
+    vtlog "ventoy_os_install_dmsetup_by_fuse $*"
+
+    mkdir -p $VTOY_PATH/mnt/fuse $VTOY_PATH/mnt/iso $VTOY_PATH/mnt/squashfs
+
+    vtoydm -p -f $VTOY_PATH/ventoy_image_map -d $1 > $VTOY_PATH/ventoy_dm_table
+    vtoy_fuse_iso -f $VTOY_PATH/ventoy_dm_table -m $VTOY_PATH/mnt/fuse
+
+    mount -t iso9660  $VTOY_PATH/mnt/fuse/ventoy.iso    $VTOY_PATH/mnt/iso
+    
+    sfsfile=$VTOY_PATH/mnt/iso/casper/filesystem.squashfs
+    
+    mount -t squashfs $sfsfile  $VTOY_PATH/mnt/squashfs
+
+    kVer=$(uname -r)
+    KoName=$(ls $VTOY_PATH/mnt/squashfs/lib/modules/$kVer/kernel/drivers/md/dm-mod.ko*)
+    vtlog "insmod $KoName"
+    insmod $KoName 
+
+    umount $VTOY_PATH/mnt/squashfs
+    umount $VTOY_PATH/mnt/iso
+    umount $VTOY_PATH/mnt/fuse
+}
+
+
+wait_for_usb_disk_ready
+
+vtdiskname=$(get_ventoy_disk_name)
+if [ "$vtdiskname" = "unknown" ]; then
+    vtlog "ventoy disk not found"
+    PATH=$VTPATH_OLD
+    exit 0
+fi
+
+if ! grep -q 'device-mapper' /proc/devices; then
+    ventoy_os_install_dmsetup_by_fuse  $vtdiskname
+fi
+
+ventoy_udev_disk_common_hook "${vtdiskname#/dev/}2" "noreplace"
+
+PATH=$VTPATH_OLD
+
+# OK finish
+set_ventoy_hook_finish

IMG/cpio/ventoy/hook/debian/kylin-hook.sh

@@ -0,0 +1,26 @@
+#!/ventoy/busybox/sh
+#************************************************************************************
+# Copyright (c) 2020, longpanda <admin@ventoy.net>
+# 
+# This program 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.
+# 
+# This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
+# 
+#************************************************************************************
+
+if [ -e /init ] && $GREP -q '^mountroot$' /init; then
+    echo "Here before mountroot ..." >> $VTLOG
+    
+    $SED  "/^mountroot$/i\\$BUSYBOX_PATH/sh $VTOY_PATH/hook/debian/kylin-disk.sh"  -i /init
+    $SED  "/^mountroot$/i\\export LIVEMEDIA=/dev/mapper/ventoy"  -i /init
+    $SED  "/^mountroot$/i\\export LIVE_MEDIA=/dev/mapper/ventoy"  -i /init    
+fi

IMG/cpio/ventoy/hook/debian/list-devices

@@ -0,0 +1,9 @@
+#! /bin/sh
+
+if [ "$1" = "usb-partition" -a -z "$2" ]; then
+    if [ -f /ventoy/list-devices-usb-part ]; then
+        cat /ventoy/list-devices-usb-part
+    fi
+fi
+
+/bin/list-devices-bk $*

IMG/cpio/ventoy/hook/debian/puppy-hook.sh

@@ -20,3 +20,9 @@
 $SED '1 apmedia=usbhd'  -i /init
 $SED "/^ *HAVE_PARTS=/a\ $BUSYBOX_PATH/sh $VTOY_PATH/hook/debian/puppy-disk.sh"  -i /init
 $SED "/^ *HAVE_PARTS=/a\ HAVE_PARTS='ventoy|iso9660'"  -i /init
+
+if [ -f /DISTRO_SPECS ]; then
+    if ! [ -d /dev ]; then
+        $BUSYBOX_PATH/mkdir /dev
+    fi
+fi

IMG/cpio/ventoy/hook/debian/udev_disk_hook.sh

@@ -126,6 +126,7 @@ fi
 
 if [ -n "$VT_BUS_USB" ]; then
     vtlog "$1 is USB device"
+    echo /dev/$1 > /ventoy/list-devices-usb-part
 else
     vtlog "$1 is NOT USB device (bus $ID_BUS)"
     
@@ -133,15 +134,7 @@ else
         vtlog "boot=, or casper, don't mount"
     else
         vtlog "No boot param, need to mount"
-        $BUSYBOX_PATH/mkdir /cdrom
-        
-        if [ -b $VTOY_DM_PATH ]; then
-            vtlog "mount $VTOY_DM_PATH ..."
-            $BUSYBOX_PATH/mount -t iso9660 $VTOY_DM_PATH  /cdrom
-        else
-            vtlog "mount /dev/$1 ..."
-            $BUSYBOX_PATH/mount -t iso9660 /dev/$1  /cdrom
-        fi
+        echo /dev/$1 > /ventoy/list-devices-usb-part
     fi
 fi
 

IMG/cpio/ventoy/hook/debian/ventoy-hook.sh

@@ -70,6 +70,10 @@ ventoy_get_debian_distro() {
         echo 'vyos'; return
     fi
     
+    if $GREP -q 'kylin' /proc/version; then
+        echo 'kylin'; return
+    fi
+    
     echo 'default'
 }
 

IMG/cpio/ventoy/hook/gentoo/ventoy-hook.sh

@@ -21,6 +21,9 @@
 
 if $GREP -q kaspersky /proc/version; then
     $SED "/sysresccd_stage1_normal[^(]*$/i\ $BUSYBOX_PATH/sh $VTOY_PATH/hook/gentoo/disk_hook.sh"  -i /init
+    if [ -f /ventoy/ventoy_persistent_map ]; then
+        $SED "/sysresccd_parsecmdline[^(]*$/a\ BACKSTORE_CMD='LABEL=casper-rw,noloop'"  -i /init
+    fi
 elif [ -d /etc/udev/rules.d ] || [ -d /lib/udev/rules.d ]; then    
     ventoy_systemd_udevd_work_around
     ventoy_add_udev_rule "$VTOY_PATH/hook/default/udev_disk_hook.sh %k noreplace"

IMG/cpio/ventoy/hook/primeos/ventoy-disk.sh

@@ -0,0 +1,38 @@
+#!/ventoy/busybox/sh
+#************************************************************************************
+# Copyright (c) 2020, longpanda <admin@ventoy.net>
+# 
+# This program 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.
+# 
+# This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
+# 
+#************************************************************************************
+
+. /ventoy/hook/ventoy-hook-lib.sh
+
+VTPATH_OLD=$PATH; PATH=$BUSYBOX_PATH:$VTOY_PATH/tool:$PATH
+
+wait_for_usb_disk_ready
+vtdiskname=$(get_ventoy_disk_name)
+if [ "$vtdiskname" = "unknown" ]; then
+    vtlog "ventoy disk not found"
+    PATH=$VTPATH_OLD
+    exit 0
+fi
+
+ventoy_udev_disk_common_hook "${vtdiskname#/dev/}2" "noreplace"
+
+blkdev_num=$($VTOY_PATH/tool/dmsetup ls | grep ventoy | sed 's/.*(\([0-9][0-9]*\),.*\([0-9][0-9]*\).*/\1:\2/')
+vtDM=$(ventoy_find_dm_id ${blkdev_num})
+echo -n "/dev/$vtDM" > /ventoy/rootdev
+
+PATH=$VTPATH_OLD

IMG/cpio/ventoy/hook/primeos/ventoy-hook.sh

@@ -0,0 +1,25 @@
+#!/ventoy/busybox/sh
+#************************************************************************************
+# Copyright (c) 2020, longpanda <admin@ventoy.net>
+# 
+# This program 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.
+# 
+# This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
+# 
+#************************************************************************************
+
+. $VTOY_PATH/hook/ventoy-os-lib.sh
+
+$BUSYBOX_PATH/mkdir /dev
+
+$SED '/Detecting *PrimeOS/a\ ROOT=$(cat /ventoy/rootdev)' -i /init
+$SED "/Detecting *PrimeOS/a\ $BUSYBOX_PATH/sh  $VTOY_PATH/hook/primeos/ventoy-disk.sh" -i /init

IMG/cpio/ventoy/hook/rhel7/ventoy-hook.sh

@@ -42,10 +42,17 @@ fi
 
 echo "VTKS=$VTKS" >> $VTLOG
 
+if ls $VTOY_PATH | $GREP -q 'ventoy_dud[0-9]'; then
+    for vtDud in $(ls $VTOY_PATH/ventoy_dud*); do
+        vtInstDD="$vtInstDD inst.dd=file:$vtDud"
+    done
+fi
+echo "vtInstDD=$vtInstDD" >> $VTLOG
+
 if $GREP -q 'root=live' /proc/cmdline; then
-    $SED "s#printf\(.*\)\$CMDLINE#printf\1\$CMDLINE root=live:/dev/dm-0 $VTKS#" -i /lib/dracut-lib.sh
+    $SED "s#printf\(.*\)\$CMDLINE#printf\1\$CMDLINE root=live:/dev/dm-0 $VTKS $vtInstDD#" -i /lib/dracut-lib.sh
 else
-    $SED "s#printf\(.*\)\$CMDLINE#printf\1\$CMDLINE inst.stage2=hd:/dev/dm-0 $VTKS#" -i /lib/dracut-lib.sh
+    $SED "s#printf\(.*\)\$CMDLINE#printf\1\$CMDLINE inst.stage2=hd:/dev/dm-0 $VTKS $vtInstDD#" -i /lib/dracut-lib.sh
 fi
 
 ventoy_set_inotify_script  rhel7/ventoy-inotifyd-hook.sh

IMG/cpio/ventoy/hook/rhel7/ventoy-inotifyd-hook.sh

@@ -39,7 +39,17 @@ if is_inotify_ventoy_part $3; then
     fi
 
     vtlog "find ventoy partition ..."
-    $BUSYBOX_PATH/sh $VTOY_PATH/hook/default/udev_disk_hook.sh $3 noreplace
+    
+    vtReplaceOpt=noreplace
+    
+    if $GREP -q el8 /proc/version && [ -f /etc/system-release ]; then
+        vtRhel8Ver=$($SED "s#.*8\.\([0-9]*\).*#\1#" /etc/system-release)
+        if [ $vtRhel8Ver -ge 3 ]; then
+            vtReplaceOpt=""
+        fi
+    fi
+    
+    $BUSYBOX_PATH/sh $VTOY_PATH/hook/default/udev_disk_hook.sh $3 $vtReplaceOpt
     
     blkdev_num=$($VTOY_PATH/tool/dmsetup ls | grep ventoy | sed 's/.*(\([0-9][0-9]*\),.*\([0-9][0-9]*\).*/\1:\2/')  
     vtDM=$(ventoy_find_dm_id ${blkdev_num})

IMG/cpio/ventoy/hook/suse/ventoy-hook.sh

@@ -26,6 +26,32 @@ if [ -f $VTOY_PATH/autoinstall ]; then
     fi
 fi
 
+if $BUSYBOX_PATH/ls $VTOY_PATH | $GREP -q 'ventoy_dud[0-9]'; then
+    if [ -f /linuxrc.config ]; then
+        vtKerVer=$($BUSYBOX_PATH/uname -r)
+        ventoy_check_insmod /modules/loop.ko
+        ventoy_check_insmod /modules/squashfs.ko
+        
+        ventoy_check_mount /parts/00_lib /modules
+        ventoy_check_insmod /modules/lib/modules/$vtKerVer/initrd/isofs.ko
+        $BUSYBOX_PATH/umount /modules
+    
+        for vtDud in $($BUSYBOX_PATH/ls $VTOY_PATH/ventoy_dud*); do
+            $BUSYBOX_PATH/mkdir -p ${vtDud%.*}_mnt
+            if $BUSYBOX_PATH/mount $vtDud ${vtDud%.*}_mnt > /dev/null 2>&1; then
+                $BUSYBOX_PATH/cp -a ${vtDud%.*}_mnt  ${vtDud%.*}_data
+                $BUSYBOX_PATH/umount ${vtDud%.*}_mnt
+                echo "dud: file://${vtDud%.*}_data" >> /linuxrc.config
+            else
+                echo "mount $vtDud failed" >> $VTLOG
+            fi
+        done
+        
+        $BUSYBOX_PATH/rmmod isofs >> $VTLOG 2>&1
+        $BUSYBOX_PATH/rmmod squashfs >> $VTLOG 2>&1
+        $BUSYBOX_PATH/rmmod loop >> $VTLOG 2>&1
+    fi
+fi
 
 #echo "Exec: /bin/sh $VTOY_PATH/hook/suse/cdrom-hook.sh" >> /info-ventoy
 #echo "install: hd:/?device=/dev/mapper/ventoy" >> /info-ventoy

IMG/cpio/ventoy/hook/ventoy-hook-lib.sh

@@ -102,6 +102,16 @@ wait_for_usb_disk_ready() {
 	done
 }
 
+check_usb_disk_ready() {
+    if echo $1 | $EGREP -q "nvme|mmc"; then
+        vtpart2=${1}p2
+    else
+        vtpart2=${1}2
+    fi
+    
+    [ -e "${vtpart2}" ]
+}
+
 is_ventoy_disk() {
     if $VTOY_PATH/tool/vtoydump -f $VTOY_PATH/ventoy_os_param -c "$1"; then
         $BUSYBOX_PATH/true

IMG/cpio/ventoy/hook/ventoy-os-lib.sh

@@ -110,4 +110,14 @@ ventoy_set_loop_inotify_script() {
     echo $VTOY_PATH/loop/$1 > $VTOY_PATH/inotifyd-loop-script.txt
 }
 
+ventoy_check_insmod() {
+    if [ -e $1 ]; then
+        $BUSYBOX_PATH/insmod $1
+    fi
+}
 
+ventoy_check_mount() {
+    if [ -e $1 ]; then
+        $BUSYBOX_PATH/mount $1 $2
+    fi
+}

IMG/cpio/ventoy/hook/wifislax/ventoy-hook.sh

@@ -19,7 +19,13 @@
 
 . $VTOY_PATH/hook/ventoy-os-lib.sh
 
-$SED "/mount.*devtmpfs/a $BUSYBOX_PATH/sh $VTOY_PATH/hook/wifislax/disk_hook.sh" -i /linuxrc
+if [ -e /linuxrc ]; then
+    INITFILE=/linuxrc
+elif [ -e /init ]; then
+    INITFILE=/init
+fi
+
+$SED "/mount.*devtmpfs/a $BUSYBOX_PATH/sh $VTOY_PATH/hook/wifislax/disk_hook.sh" -i $INITFILE
 
 #replace original blkid
 $BUSYBOX_PATH/rm -f /usr/bin/blkid

IMG/cpio/ventoy/tool/vtoytool_install.sh

@@ -19,10 +19,28 @@
 
 echo "#### install vtoytool #####" >> $VTLOG
 
-if ! [ -e $BUSYBOX_PATH/ar ]; then
-    $BUSYBOX_PATH/ln -s $VTOY_PATH/tool/ar $BUSYBOX_PATH/ar
+for app in ar inotifyd; do
+    if [ -e $BUSYBOX_PATH/$app ]; then
+        $BUSYBOX_PATH/rm -f $VTOY_PATH/tool/$app
+        $BUSYBOX_PATH/ln -s $BUSYBOX_PATH/$app $VTOY_PATH/tool/$app
+    else
+        $BUSYBOX_PATH/ln -s $VTOY_PATH/tool/$app $BUSYBOX_PATH/$app
     fi
+done
 
+
+if $GREP -q aarch64 $VTOY_PATH/ventoy_arch; then
+    for vtdir in $(ls $VTOY_PATH/tool/vtoytool/); do
+        echo "try $VTOY_PATH/tool/vtoytool/$vtdir/ ..." >> $VTLOG
+        if $VTOY_PATH/tool/vtoytool/$vtdir/vtoytool_aa64 --install 2>>$VTLOG; then
+            echo "vtoytool_aa64 OK" >> $VTLOG
+            break
+        fi        
+    done
+    
+    $BUSYBOX_PATH/cp -a $VTOY_PATH/tool/vtoy_fuse_iso_aa64  $VTOY_PATH/tool/vtoy_fuse_iso
+    $BUSYBOX_PATH/cp -a $VTOY_PATH/tool/unsquashfs_aa64  $VTOY_PATH/tool/vtoy_unsquashfs    
+else
     for vtdir in $(ls $VTOY_PATH/tool/vtoytool/); do
         echo "try $VTOY_PATH/tool/vtoytool/$vtdir/ ..." >> $VTLOG
         if $VTOY_PATH/tool/vtoytool/$vtdir/vtoytool_64 --install 2>>$VTLOG; then
@@ -52,13 +70,5 @@ else
         $BUSYBOX_PATH/cp -a $VTOY_PATH/tool/unsquashfs_32 $VTOY_PATH/tool/vtoy_unsquashfs
     fi
     
-
-
-if $VTOY_PATH/tool/unsquashfs_64 -t 2>>$VTLOG; then
-    echo "use unsquashfs_64" >>$VTLOG
-    $BUSYBOX_PATH/cp -a $VTOY_PATH/tool/unsquashfs_64  $VTOY_PATH/tool/vtoy_unsquashfs
-else
-    echo "use unsquashfs_32" >>$VTLOG    
-    $BUSYBOX_PATH/cp -a $VTOY_PATH/tool/unsquashfs_32 $VTOY_PATH/tool/vtoy_unsquashfs
 fi
 

IMG/cpio/ventoy/ventoy_chain.sh

@@ -305,6 +305,20 @@ ventoy_get_os_type() {
         echo 'blackPanther'; return
     fi
     
+    if $GREP -q 'primeos' /proc/version; then
+        echo 'primeos'; return
+    fi
+    
+    if $GREP -q 'austrumi' /proc/version; then
+        echo 'austrumi'; return
+    fi
+    
+    if [ -f /DISTRO_SPECS ]; then
+        if $GREP -q '[Pp]uppy' /DISTRO_SPECS; then
+            echo 'debian'; return
+        fi
+    fi
+    
     echo "default"
 }
 

IMG/mkcpio.sh

@@ -21,8 +21,10 @@ cp -a $VENTOY_PATH/SQUASHFS/unsquashfs_* tool/
 cp -a $VENTOY_PATH/FUSEISO/vtoy_fuse_iso_* tool/
 cp -a $VENTOY_PATH/VtoyTool/vtoytool tool/
 cp -a $VENTOY_PATH/VBLADE/vblade-master/vblade_* tool/
+
 cp -a $VENTOY_PATH/LZIP/lunzip32 tool/
 cp -a $VENTOY_PATH/LZIP/lunzip64 tool/
+cp -a $VENTOY_PATH/LZIP/lunzipaa64 tool/
 
 
 chmod -R 777 ./tool

INSTALL/CreatePersistentImg.sh

@@ -3,13 +3,15 @@
 size=1024
 fstype=ext4
 label=casper-rw
+config=''
 
 print_usage() {
-    echo 'Usage:  CreatePersistentImg.sh [ -s size ] [ -t fstype ] [ -l LABEL ]'
+    echo 'Usage:  CreatePersistentImg.sh [ -s size ] [ -t fstype ] [ -l LABEL ] [ -c CFG ]'
     echo '  OPTION: (optional)'
     echo '   -s size in MB, default is 1024'
     echo '   -t filesystem type, default is ext4  ext2/ext3/ext4/xfs are supported now'
     echo '   -l label, default is casper-rw'
+    echo '   -c configfile name inside the persistence file. File content is "/ union"'
     echo ''
 }
 
@@ -23,6 +25,9 @@ while [ -n "$1" ]; do
     elif [ "$1" = "-l" ]; then
         shift
         label=$1
+    elif [ "$1" = "-c" ]; then
+        shift
+        config=$1
     elif [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
         print_usage
         exit 0
@@ -76,5 +81,18 @@ mkfs -t $fstype $fsopt -L $label $freeloop
 
 sync
 
-losetup -d $freeloop
+if [ -n "$config" ]; then
+    if [ -d ./persist_tmp_mnt ]; then
+        rm -rf ./persist_tmp_mnt
+    fi
     
+    mkdir ./persist_tmp_mnt
+    if mount $freeloop ./persist_tmp_mnt; then
+        echo '/ union' > ./persist_tmp_mnt/$config
+        sync
+        umount ./persist_tmp_mnt
+    fi
+    rm -rf ./persist_tmp_mnt
+fi
+
+losetup -d $freeloop