1.0.45 release

2. Add WIMBOOT for UEFI mode.

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

@@ -148,7 +148,7 @@ STATIC EFI_STATUS EFIAPI ventoy_read_iso_sector
     ventoy_override_chunk *pOverride = g_override_chunk;
     EFI_BLOCK_IO_PROTOCOL *pRawBlockIo = gBlockData.pRawBlockIo;
     
-    debug("read iso sector %lu  count %u", Sector, Count);
+    debug("read iso sector %lu count %u Buffer:%p Align:%u", Sector, Count, Buffer, pRawBlockIo->Media->IoAlign);
 
     ReadStart = Sector * 2048;
     ReadEnd = (Sector + Count) * 2048;
@@ -173,7 +173,6 @@ STATIC EFI_STATUS EFIAPI ventoy_read_iso_sector
             {
                 MapLba = ((Sector - pchunk->img_start_sector) >> 1) + pchunk->disk_start_sector;
             }
-            
 
             secLeft = pchunk->img_end_sector + 1 - Sector;
             secRead = (Count < secLeft) ? Count : secLeft;
@@ -182,7 +181,7 @@ STATIC EFI_STATUS EFIAPI ventoy_read_iso_sector
                                      MapLba, secRead * 2048, pCurBuf);
             if (EFI_ERROR(Status))
             {
-                debug("Raw disk read block failed %r LBA:%lu Count:%u", Status, MapLba, secRead);
+                debug("Raw disk read block failed %r LBA:%lu Count:%u %p", Status, MapLba, secRead, pCurBuf);
                 return Status;
             }
 
@@ -425,7 +424,7 @@ end:
     return Lba;
 }
 
-EFI_STATUS EFIAPI ventoy_block_io_read 
+EFI_STATUS EFIAPI ventoy_block_io_read_real 
 (
     IN EFI_BLOCK_IO_PROTOCOL          *This,
     IN UINT32                          MediaId,
@@ -438,6 +437,8 @@ EFI_STATUS EFIAPI ventoy_block_io_read
     UINT32 j = 0;
     UINT32 lbacount = 0;
     UINT32 secNum = 0;
+    UINT32 TmpNum = 0;
+    UINT64 VirtSec = 0;
     UINT64 offset = 0;
     EFI_LBA curlba = 0;
     EFI_LBA lastlba = 0;
@@ -445,7 +446,7 @@ EFI_STATUS EFIAPI ventoy_block_io_read
     ventoy_sector_flag *cur_flag;
     ventoy_virt_chunk *node;
     
-    //debug("### ventoy_block_io_read sector:%u count:%u", (UINT32)Lba, (UINT32)BufferSize / 2048);
+    debug("### block_io_read_real sector:%u count:%u Buffer:%p", (UINT32)Lba, (UINT32)BufferSize / 2048, Buffer);
 
     secNum = BufferSize / 2048;
 
@@ -461,6 +462,26 @@ EFI_STATUS EFIAPI ventoy_block_io_read
     {
         return ventoy_read_iso_sector(Lba, secNum, Buffer);
     }
+    else if (offset < g_chain->real_img_size_in_bytes)
+    {
+        TmpNum = (g_chain->real_img_size_in_bytes - offset) / 2048;
+        ventoy_read_iso_sector(Lba, TmpNum, Buffer);
+
+        Lba += TmpNum;
+        secNum -= TmpNum;
+        Buffer = (UINT8 *)Buffer + (g_chain->real_img_size_in_bytes - offset);
+        offset = Lba * 2048;
+    }
+
+    VirtSec = g_chain->virt_img_size_in_bytes / 2048;
+    if (Lba >= VirtSec)
+    {
+        return EFI_SUCCESS;
+    }
+    else if (Lba + secNum > VirtSec)
+    {
+        secNum = VirtSec - Lba;
+    }
 
     if (secNum > g_sector_flag_num)
     {
@@ -529,6 +550,42 @@ EFI_STATUS EFIAPI ventoy_block_io_read
 	return EFI_SUCCESS;
 }
 
+EFI_STATUS EFIAPI ventoy_block_io_read
+(
+    IN EFI_BLOCK_IO_PROTOCOL          *This,
+    IN UINT32                          MediaId,
+    IN EFI_LBA                         Lba,
+    IN UINTN                           BufferSize,
+    OUT VOID                          *Buffer
+) 
+{
+    UINT32 IoAlign = 0;
+    VOID *NewBuf = NULL;
+    EFI_STATUS Status = EFI_OUT_OF_RESOURCES;
+
+    if (gBlockData.pRawBlockIo && gBlockData.pRawBlockIo->Media)
+    {
+        IoAlign = gBlockData.pRawBlockIo->Media->IoAlign;
+    }
+
+    if ((IoAlign == 0) || (((UINTN) Buffer & (IoAlign - 1)) == 0))
+    {
+        Status = ventoy_block_io_read_real(This, MediaId, Lba, BufferSize, Buffer);
+    }
+    else
+    {
+        NewBuf = AllocatePages(EFI_SIZE_TO_PAGES(BufferSize + IoAlign));
+        if (NewBuf)
+        {
+            Status = ventoy_block_io_read_real(This, MediaId, Lba, BufferSize, NewBuf);
+            CopyMem(Buffer, NewBuf, BufferSize);
+            FreePages(NewBuf, EFI_SIZE_TO_PAGES(BufferSize + IoAlign));
+        }
+    }
+
+    return Status;
+}
+
 EFI_STATUS EFIAPI ventoy_block_io_write 
 (
     IN EFI_BLOCK_IO_PROTOCOL          *This,
@@ -698,7 +755,7 @@ EFI_STATUS EFIAPI ventoy_block_io_read_512
     UINT8 *CurBuf = NULL;
     EFI_STATUS Status = EFI_SUCCESS;
 
-    debug("ventoy_block_io_read_512 %lu %lu\n", Lba, BufferSize / 512);
+    debug("ventoy_block_io_read_512 %lu %lu Buffer:%p\n", Lba, BufferSize / 512, Buffer);
 
     CurBuf = (UINT8 *)Buffer;
 

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

@@ -1603,6 +1603,7 @@ module = {
 module = {
   name = ventoy;
   common = ventoy/ventoy.c;
+  common = ventoy/ventoy_cmd.c;
   common = ventoy/ventoy_linux.c;
   common = ventoy/ventoy_unix.c;
   common = ventoy/ventoy_windows.c;

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

@@ -0,0 +1,343 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/extcmd.h>
+#include <grub/file.h>
+#include <grub/disk.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/crypto.h>
+#include <grub/normal.h>
+#include <grub/i18n.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static const struct grub_arg_option options[] = {
+  {"hash", 'h', 0, N_("Specify hash to use."), N_("HASH"), ARG_TYPE_STRING},
+  {"check", 'c', 0, N_("Check hashes of files with hash list FILE."),
+   N_("FILE"), ARG_TYPE_STRING},
+  {"prefix", 'p', 0, N_("Base directory for hash list."), N_("DIR"),
+   ARG_TYPE_STRING},
+  {"keep-going", 'k', 0, N_("Don't stop after first error."), 0, 0},
+  {"uncompress", 'u', 0, N_("Uncompress file before checksumming."), 0, 0},
+  {0, 0, 0, 0, 0, 0}
+};
+
+static struct { const char *name; const char *hashname; } aliases[] = 
+  {
+    {"sha256sum", "sha256"},
+    {"sha512sum", "sha512"},
+    {"sha1sum", "sha1"},
+    {"md5sum", "md5"},
+    {"crc", "crc32"},
+  };
+
+static inline int
+hextoval (char c)
+{
+  if (c >= '0' && c <= '9')
+    return c - '0';
+  if (c >= 'a' && c <= 'f')
+    return c - 'a' + 10;
+  if (c >= 'A' && c <= 'F')
+    return c - 'A' + 10;
+  return -1;
+}
+
+static grub_err_t
+hash_file (grub_file_t file, const gcry_md_spec_t *hash, void *result)
+{
+  int progress = 0;
+  grub_uint64_t ro = 0;
+  grub_uint64_t div = 0;
+  grub_uint64_t total = 0;
+  void *context;
+  grub_uint8_t *readbuf;
+#define BUF_SIZE 4096
+  readbuf = grub_malloc (BUF_SIZE);
+  if (!readbuf)
+    return grub_errno;
+  context = grub_zalloc (hash->contextsize);
+  if (!readbuf || !context)
+    goto fail;
+
+  if (file->size > 16 * 1024 * 1024)
+    progress = 1;
+
+  hash->init (context);
+  while (1)
+    {
+      grub_ssize_t r;
+      r = grub_file_read (file, readbuf, BUF_SIZE);
+      if (r < 0)
+	goto fail;
+      if (r == 0)
+	break;
+      hash->write (context, readbuf, r);
+      if (progress)
+      {
+          total += r;
+          div = grub_divmod64(total * 100, (grub_uint64_t)file->size, &ro);
+          grub_printf("\rCalculating   %d%%    ", (int)div);
+          grub_refresh();
+      }
+    }
+  hash->final (context);
+  grub_memcpy (result, hash->read (context), hash->mdlen);
+
+  grub_free (readbuf);
+  grub_free (context);
+  if (progress)
+  {
+    grub_printf("\rCalculating   100%%    \n\r\n");
+    grub_refresh();      
+  }
+  return GRUB_ERR_NONE;
+
+ fail:
+  grub_free (readbuf);
+  grub_free (context);
+  return grub_errno;
+}
+
+static grub_err_t
+check_list (const gcry_md_spec_t *hash, const char *hashfilename,
+	    const char *prefix, int keep, int uncompress)
+{
+  grub_file_t hashlist, file;
+  char *buf = NULL;
+  grub_uint8_t expected[GRUB_CRYPTO_MAX_MDLEN];
+  grub_uint8_t actual[GRUB_CRYPTO_MAX_MDLEN];
+  grub_err_t err;
+  unsigned i;
+  unsigned unread = 0, mismatch = 0;
+
+  if (hash->mdlen > GRUB_CRYPTO_MAX_MDLEN)
+    return grub_error (GRUB_ERR_BUG, "mdlen is too long");
+
+  hashlist = grub_file_open (hashfilename, GRUB_FILE_TYPE_HASHLIST);
+  if (!hashlist)
+    return grub_errno;
+  
+  while (grub_free (buf), (buf = grub_file_getline (hashlist)))
+    {
+      const char *p = buf;
+      while (grub_isspace (p[0]))
+	p++;
+      for (i = 0; i < hash->mdlen; i++)
+	{
+	  int high, low;
+	  high = hextoval (*p++);
+	  low = hextoval (*p++);
+	  if (high < 0 || low < 0)
+	    return grub_error (GRUB_ERR_BAD_FILE_TYPE, "invalid hash list");
+	  expected[i] = (high << 4) | low;
+	}
+      if ((p[0] != ' ' && p[0] != '\t') || (p[1] != ' ' && p[1] != '\t'))
+	return grub_error (GRUB_ERR_BAD_FILE_TYPE, "invalid hash list");
+      p += 2;
+      if (prefix)
+	{
+	  char *filename;
+	  
+	  filename = grub_xasprintf ("%s/%s", prefix, p);
+	  if (!filename)
+	    return grub_errno;
+	  file = grub_file_open (filename, GRUB_FILE_TYPE_TO_HASH
+				 | (!uncompress ? GRUB_FILE_TYPE_NO_DECOMPRESS
+				    : GRUB_FILE_TYPE_NONE));
+	  grub_free (filename);
+	}
+      else
+	file = grub_file_open (p, GRUB_FILE_TYPE_TO_HASH
+			       | (!uncompress ? GRUB_FILE_TYPE_NO_DECOMPRESS
+				  : GRUB_FILE_TYPE_NONE));
+      if (!file)
+	{
+	  grub_file_close (hashlist);
+	  grub_free (buf);
+	  return grub_errno;
+	}
+      err = hash_file (file, hash, actual);
+      grub_file_close (file);
+      if (err)
+	{
+	  grub_printf_ (N_("%s: READ ERROR\n"), p);
+	  if (!keep)
+	    {
+	      grub_file_close (hashlist);
+	      grub_free (buf);
+	      return err;
+	    }
+	  grub_print_error ();
+	  grub_errno = GRUB_ERR_NONE;
+	  unread++;
+	  continue;
+	}
+      if (grub_crypto_memcmp (expected, actual, hash->mdlen) != 0)
+	{
+	  grub_printf_ (N_("%s: HASH MISMATCH\n"), p);
+	  if (!keep)
+	    {
+	      grub_file_close (hashlist);
+	      grub_free (buf);
+	      return grub_error (GRUB_ERR_TEST_FAILURE,
+				 "hash of '%s' mismatches", p);
+	    }
+	  mismatch++;
+	  continue;	  
+	}
+      grub_printf_ (N_("%s: OK\n"), p);
+    }
+  if (mismatch || unread)
+    return grub_error (GRUB_ERR_TEST_FAILURE,
+		       "%d files couldn't be read and hash "
+		       "of %d files mismatches", unread, mismatch);
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_cmd_hashsum (struct grub_extcmd_context *ctxt,
+		  int argc, char **args)
+{
+  struct grub_arg_list *state = ctxt->state;
+  const char *hashname = NULL;
+  const char *prefix = NULL;
+  const gcry_md_spec_t *hash;
+  unsigned i;
+  int keep = state[3].set;
+  int uncompress = state[4].set;
+  unsigned unread = 0;
+
+  for (i = 0; i < ARRAY_SIZE (aliases); i++)
+    if (grub_strcmp (ctxt->extcmd->cmd->name, aliases[i].name) == 0)
+      hashname = aliases[i].hashname;
+  if (state[0].set)
+    hashname = state[0].arg;
+
+  if (!hashname)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "no hash specified");
+
+  hash = grub_crypto_lookup_md_by_name (hashname);
+  if (!hash)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "unknown hash");
+
+  if (hash->mdlen > GRUB_CRYPTO_MAX_MDLEN)
+    return grub_error (GRUB_ERR_BUG, "mdlen is too long");
+
+  if (state[2].set)
+    prefix = state[2].arg;
+
+  if (state[1].set)
+    {
+      if (argc != 0)
+	return grub_error (GRUB_ERR_BAD_ARGUMENT,
+			   "--check is incompatible with file list");
+      return check_list (hash, state[1].arg, prefix, keep, uncompress);
+    }
+
+  for (i = 0; i < (unsigned) argc; i++)
+    {
+      GRUB_PROPERLY_ALIGNED_ARRAY (result, GRUB_CRYPTO_MAX_MDLEN);
+      grub_file_t file;
+      grub_err_t err;
+      unsigned j;
+      file = grub_file_open (args[i], GRUB_FILE_TYPE_TO_HASH
+			     | (!uncompress ? GRUB_FILE_TYPE_NO_DECOMPRESS
+				: GRUB_FILE_TYPE_NONE));
+      if (!file)
+	{
+	  if (!keep)
+	    return grub_errno;
+	  grub_print_error ();
+	  grub_errno = GRUB_ERR_NONE;
+	  unread++;
+	  continue;
+	}
+      err = hash_file (file, hash, result);
+      grub_file_close (file);
+      if (err)
+	{
+	  if (!keep)
+	    return err;
+	  grub_print_error ();
+	  grub_errno = GRUB_ERR_NONE;
+	  unread++;
+	  continue;
+	}
+      for (j = 0; j < hash->mdlen; j++)
+	grub_printf ("%02x", ((grub_uint8_t *) result)[j]);
+      grub_printf ("  %s\n", args[i]);
+    }
+
+  if (unread)
+    return grub_error (GRUB_ERR_TEST_FAILURE, "%d files couldn't be read",
+		       unread);
+  return GRUB_ERR_NONE;
+}
+
+static grub_extcmd_t cmd, cmd_md5, cmd_sha1, cmd_sha256, cmd_sha512, cmd_crc;
+
+GRUB_MOD_INIT(hashsum)
+{
+  cmd = grub_register_extcmd ("hashsum", grub_cmd_hashsum, 0,
+			      N_("-h HASH [-c FILE [-p PREFIX]] "
+				 "[FILE1 [FILE2 ...]]"),
+			      /* TRANSLATORS: "hash checksum" is just to
+				 be a bit more precise, you can treat it as
+				 just "hash".  */
+			      N_("Compute or check hash checksum."),
+			      options);
+  cmd_md5 = grub_register_extcmd ("md5sum", grub_cmd_hashsum, 0,
+				  N_("[-c FILE [-p PREFIX]] "
+				     "[FILE1 [FILE2 ...]]"),
+				  N_("Compute or check hash checksum."),
+				  options);
+  cmd_sha1 = grub_register_extcmd ("sha1sum", grub_cmd_hashsum, 0,
+				   N_("[-c FILE [-p PREFIX]] "
+				      "[FILE1 [FILE2 ...]]"),
+				   N_("Compute or check hash checksum."),
+				   options);
+  cmd_sha256 = grub_register_extcmd ("sha256sum", grub_cmd_hashsum, 0,
+				     N_("[-c FILE [-p PREFIX]] "
+					"[FILE1 [FILE2 ...]]"),
+				     N_("Compute or check hash checksum."),
+				     options);
+  cmd_sha512 = grub_register_extcmd ("sha512sum", grub_cmd_hashsum, 0,
+				     N_("[-c FILE [-p PREFIX]] "
+					"[FILE1 [FILE2 ...]]"),
+				     N_("Compute or check hash checksum."),
+				     options);
+
+  cmd_crc = grub_register_extcmd ("crc", grub_cmd_hashsum, 0,
+				     N_("[-c FILE [-p PREFIX]] "
+					"[FILE1 [FILE2 ...]]"),
+				     N_("Compute or check hash checksum."),
+				     options);
+}
+
+GRUB_MOD_FINI(hashsum)
+{
+  grub_unregister_extcmd (cmd);
+  grub_unregister_extcmd (cmd_md5);
+  grub_unregister_extcmd (cmd_sha1);
+  grub_unregister_extcmd (cmd_sha256);
+  grub_unregister_extcmd (cmd_sha512);
+  grub_unregister_extcmd (cmd_crc);
+}

GRUB2/MOD_SRC/grub-2.04/grub-core/gfxmenu/gui_label.c

@@ -28,6 +28,8 @@
 
 extern int g_ventoy_memdisk_mode;
 extern int g_ventoy_iso_raw;
+extern int g_ventoy_grub2_mode;
+extern int g_ventoy_wimboot_mode;
 extern int g_ventoy_iso_uefi_drv;
 
 static const char *align_options[] =
@@ -205,6 +207,12 @@ label_set_property (void *vself, const char *name, const char *value)
        else if (grub_strcmp (value, "@VTOY_ISO_RAW@") == 0) {
             value = g_ventoy_iso_raw ? grub_env_get("VTOY_ISO_RAW_STR") : " ";
        }
+       else if (grub_strcmp (value, "@VTOY_GRUB2_MODE@") == 0) {
+            value = g_ventoy_grub2_mode ? grub_env_get("VTOY_GRUB2_MODE_STR") : " ";
+       }
+       else if (grub_strcmp (value, "@VTOY_WIMBOOT_MODE@") == 0) {
+            value = g_ventoy_wimboot_mode ? grub_env_get("VTOY_WIMBOOT_MODE_STR") : " ";
+       }
        else if (grub_strcmp (value, "@VTOY_ISO_UEFI_DRV@") == 0) {
             value = g_ventoy_iso_uefi_drv ? grub_env_get("VTOY_ISO_UEFI_DRV_STR") : " ";
        }

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

@@ -964,3 +964,20 @@ void * grub_efi_allocate_iso_buf(grub_uint64_t size)
     
     return (void *)(unsigned long)address;
 }
+
+void * grub_efi_allocate_chain_buf(grub_uint64_t size)
+{
+    grub_efi_boot_services_t *b;
+    grub_efi_status_t status;
+    grub_efi_physical_address_t address = 0;
+    grub_efi_uintn_t pages = GRUB_EFI_BYTES_TO_PAGES(size);
+
+    b = grub_efi_system_table->boot_services;
+    status = efi_call_4 (b->allocate_pages, GRUB_EFI_ALLOCATE_ANY_PAGES, GRUB_EFI_LOADER_DATA, pages, &address);
+    if (status != GRUB_EFI_SUCCESS)
+    {
+        return NULL;
+    }
+    
+    return (void *)(unsigned long)address;
+}

GRUB2/MOD_SRC/grub-2.04/grub-core/loader/linux.c

@@ -0,0 +1,316 @@
+#include <grub/types.h>
+#include <grub/err.h>
+#include <grub/linux.h>
+#include <grub/misc.h>
+#include <grub/file.h>
+#include <grub/mm.h>
+#include <grub/env.h>
+#include <grub/term.h>
+
+struct newc_head
+{
+  char magic[6];
+  char ino[8];
+  char mode[8];
+  char uid[8];
+  char gid[8];
+  char nlink[8];
+  char mtime[8];
+  char filesize[8];
+  char devmajor[8];
+  char devminor[8];
+  char rdevmajor[8];
+  char rdevminor[8];
+  char namesize[8];
+  char check[8];
+} GRUB_PACKED;
+
+struct grub_linux_initrd_component
+{
+  grub_file_t file;
+  char *newc_name;
+  grub_off_t size;
+};
+
+struct dir
+{
+  char *name;
+  struct dir *next;
+  struct dir *child;
+};
+
+static char
+hex (grub_uint8_t val)
+{
+  if (val < 10)
+    return '0' + val;
+  return 'a' + val - 10;
+}
+
+static void
+set_field (char *var, grub_uint32_t val)
+{
+  int i;
+  char *ptr = var;
+  for (i = 28; i >= 0; i -= 4)
+    *ptr++ = hex((val >> i) & 0xf);
+}
+
+static grub_uint8_t *
+make_header (grub_uint8_t *ptr,
+	     const char *name, grub_size_t len,
+	     grub_uint32_t mode,
+	     grub_off_t fsize)
+{
+  struct newc_head *head = (struct newc_head *) ptr;
+  grub_uint8_t *optr;
+  grub_size_t oh = 0;
+  grub_memcpy (head->magic, "070701", 6);
+  set_field (head->ino, 0);
+  set_field (head->mode, mode);
+  set_field (head->uid, 0);
+  set_field (head->gid, 0);
+  set_field (head->nlink, 1);
+  set_field (head->mtime, 0);
+  set_field (head->filesize, fsize);
+  set_field (head->devmajor, 0);
+  set_field (head->devminor, 0);
+  set_field (head->rdevmajor, 0);
+  set_field (head->rdevminor, 0);
+  set_field (head->namesize, len);
+  set_field (head->check, 0);
+  optr = ptr;
+  ptr += sizeof (struct newc_head);
+  grub_memcpy (ptr, name, len);
+  ptr += len;
+  oh = ALIGN_UP_OVERHEAD (ptr - optr, 4);
+  grub_memset (ptr, 0, oh);
+  ptr += oh;
+  return ptr;
+}
+
+static void
+free_dir (struct dir *root)
+{
+  if (!root)
+    return;
+  free_dir (root->next);
+  free_dir (root->child);
+  grub_free (root->name);
+  grub_free (root);
+}
+
+static grub_size_t
+insert_dir (const char *name, struct dir **root,
+	    grub_uint8_t *ptr)
+{
+  struct dir *cur, **head = root;
+  const char *cb, *ce = name;
+  grub_size_t size = 0;
+  while (1)
+    {
+      for (cb = ce; *cb == '/'; cb++);
+      for (ce = cb; *ce && *ce != '/'; ce++);
+      if (!*ce)
+	break;
+
+      for (cur = *root; cur; cur = cur->next)
+	if (grub_memcmp (cur->name, cb, ce - cb)
+	    && cur->name[ce - cb] == 0)
+	  break;
+      if (!cur)
+	{
+	  struct dir *n;
+	  n = grub_zalloc (sizeof (*n));
+	  if (!n)
+	    return 0;
+	  n->next = *head;
+	  n->name = grub_strndup (cb, ce - cb);
+	  if (ptr)
+	    {
+	      grub_dprintf ("linux", "Creating directory %s, %s\n", name, ce);
+	      ptr = make_header (ptr, name, ce - name,
+				 040777, 0);
+	    }
+	  size += ALIGN_UP ((ce - (char *) name)
+			    + sizeof (struct newc_head), 4);
+	  *head = n;
+	  cur = n;
+	}
+      root = &cur->next;
+    }
+  return size;
+}
+
+grub_err_t
+grub_initrd_init (int argc, char *argv[],
+		  struct grub_linux_initrd_context *initrd_ctx)
+{
+  int i;
+  int newc = 0;
+  struct dir *root = 0;
+
+  initrd_ctx->nfiles = 0;
+  initrd_ctx->components = 0;
+
+  initrd_ctx->components = grub_zalloc (argc
+					* sizeof (initrd_ctx->components[0]));
+  if (!initrd_ctx->components)
+    return grub_errno;
+
+  initrd_ctx->size = 0;
+
+  for (i = 0; i < argc; i++)
+    {
+      const char *fname = argv[i];
+
+      initrd_ctx->size = ALIGN_UP (initrd_ctx->size, 4);
+
+      if (grub_memcmp (argv[i], "newc:", 5) == 0)
+	{
+	  const char *ptr, *eptr;
+	  ptr = argv[i] + 5;
+	  while (*ptr == '/')
+	    ptr++;
+	  eptr = grub_strchr (ptr, ':');
+	  if (eptr)
+	    {
+	      initrd_ctx->components[i].newc_name = grub_strndup (ptr, eptr - ptr);
+	      if (!initrd_ctx->components[i].newc_name)
+		{
+		  grub_initrd_close (initrd_ctx);
+		  return grub_errno;
+		}
+	      initrd_ctx->size
+		+= ALIGN_UP (sizeof (struct newc_head)
+			    + grub_strlen (initrd_ctx->components[i].newc_name),
+			     4);
+	      initrd_ctx->size += insert_dir (initrd_ctx->components[i].newc_name,
+					      &root, 0);
+	      newc = 1;
+	      fname = eptr + 1;
+	    }
+	}
+      else if (newc)
+	{
+	  initrd_ctx->size += ALIGN_UP (sizeof (struct newc_head)
+					+ sizeof ("TRAILER!!!") - 1, 4);
+	  free_dir (root);
+	  root = 0;
+	  newc = 0;
+	}
+      initrd_ctx->components[i].file = grub_file_open (fname,
+						       GRUB_FILE_TYPE_LINUX_INITRD
+						       | GRUB_FILE_TYPE_NO_DECOMPRESS);
+      if (!initrd_ctx->components[i].file)
+	{
+	  grub_initrd_close (initrd_ctx);
+	  return grub_errno;
+	}
+      initrd_ctx->nfiles++;
+      initrd_ctx->components[i].size
+	= grub_file_size (initrd_ctx->components[i].file);
+      initrd_ctx->size += initrd_ctx->components[i].size;
+    }
+
+  if (newc)
+    {
+      initrd_ctx->size = ALIGN_UP (initrd_ctx->size, 4);
+      initrd_ctx->size += ALIGN_UP (sizeof (struct newc_head)
+				    + sizeof ("TRAILER!!!") - 1, 4);
+      free_dir (root);
+      root = 0;
+    }
+  
+  return GRUB_ERR_NONE;
+}
+
+grub_size_t
+grub_get_initrd_size (struct grub_linux_initrd_context *initrd_ctx)
+{
+  return initrd_ctx->size;
+}
+
+void
+grub_initrd_close (struct grub_linux_initrd_context *initrd_ctx)
+{
+  int i;
+  if (!initrd_ctx->components)
+    return;
+  for (i = 0; i < initrd_ctx->nfiles; i++)
+    {
+      grub_free (initrd_ctx->components[i].newc_name);
+      grub_file_close (initrd_ctx->components[i].file);
+    }
+  grub_free (initrd_ctx->components);
+  initrd_ctx->components = 0;
+}
+
+extern int ventoy_need_prompt_load_file(void);
+extern grub_ssize_t ventoy_load_file_with_prompt(grub_file_t file, void *buf, grub_ssize_t size);
+grub_err_t
+grub_initrd_load (struct grub_linux_initrd_context *initrd_ctx,
+		  char *argv[], void *target)
+{
+  grub_uint8_t *ptr = target;
+  int i;
+  int newc = 0;
+  struct dir *root = 0;
+  grub_ssize_t cursize = 0;
+  grub_ssize_t readsize = 0;
+  
+  for (i = 0; i < initrd_ctx->nfiles; i++)
+    {
+      grub_memset (ptr, 0, ALIGN_UP_OVERHEAD (cursize, 4));
+      ptr += ALIGN_UP_OVERHEAD (cursize, 4);
+
+      if (initrd_ctx->components[i].newc_name)
+	{
+	  ptr += insert_dir (initrd_ctx->components[i].newc_name,
+			     &root, ptr);
+	  ptr = make_header (ptr, initrd_ctx->components[i].newc_name,
+			     grub_strlen (initrd_ctx->components[i].newc_name),
+			     0100777,
+			     initrd_ctx->components[i].size);
+	  newc = 1;
+	}
+      else if (newc)
+	{
+	  ptr = make_header (ptr, "TRAILER!!!", sizeof ("TRAILER!!!") - 1,
+			     0, 0);
+	  free_dir (root);
+	  root = 0;
+	  newc = 0;
+	}
+
+    cursize = initrd_ctx->components[i].size;
+    if (ventoy_need_prompt_load_file() && initrd_ctx->components[i].newc_name && 
+        grub_strcmp(initrd_ctx->components[i].newc_name, "boot.wim") == 0)
+    {
+        readsize = ventoy_load_file_with_prompt(initrd_ctx->components[i].file, ptr, cursize);
+    }
+    else
+    {
+        readsize = grub_file_read (initrd_ctx->components[i].file, ptr, cursize);
+    }
+
+      if (readsize != cursize)
+	{
+	  if (!grub_errno)
+	    grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
+			argv[i]);
+	  grub_initrd_close (initrd_ctx);
+	  return grub_errno;
+	}
+      ptr += cursize;
+    }
+  if (newc)
+    {
+      grub_memset (ptr, 0, ALIGN_UP_OVERHEAD (cursize, 4));
+      ptr += ALIGN_UP_OVERHEAD (cursize, 4);
+      ptr = make_header (ptr, "TRAILER!!!", sizeof ("TRAILER!!!") - 1, 0, 0);
+    }
+  free_dir (root);
+  root = 0;
+  return GRUB_ERR_NONE;
+}

GRUB2/MOD_SRC/grub-2.04/grub-core/normal/menu.c

@@ -37,11 +37,14 @@
 int g_ventoy_menu_refresh = 0;
 int g_ventoy_memdisk_mode = 0;
 int g_ventoy_iso_raw = 0;
+int g_ventoy_grub2_mode = 0;
+int g_ventoy_wimboot_mode = 0;
 int g_ventoy_iso_uefi_drv = 0;
 int g_ventoy_last_entry = -1;
 int g_ventoy_suppress_esc = 0;
 int g_ventoy_menu_esc = 0;
 int g_ventoy_fn_mutex = 0;
+int g_ventoy_terminal_output = 0;
 
 /* Time to delay after displaying an error message about a default/fallback
    entry failing to boot.  */
@@ -871,15 +874,18 @@ run_menu (grub_menu_t menu, int nested, int *auto_boot)
             }
             break;
         case GRUB_TERM_KEY_F7:
-        case '7':
-            cmdstr = grub_env_get("VTOY_F7_CMD");
-            if (cmdstr)
+            menu_fini ();
+            if (g_ventoy_terminal_output == 0)
             {
-                menu_fini ();
-                grub_script_execute_sourcecode(cmdstr);
-                goto refresh;
+                grub_script_execute_sourcecode("terminal_output console");
+                g_ventoy_terminal_output = 1;
             }
-            break;
+            else
+            {
+                grub_script_execute_sourcecode("terminal_output gfxterm");
+                g_ventoy_terminal_output = 0;
+            }
+            goto refresh;
         case GRUB_TERM_KEY_F1:
         case '1':
             menu_fini ();
@@ -893,6 +899,18 @@ run_menu (grub_menu_t menu, int nested, int *auto_boot)
             g_ventoy_menu_refresh = 1;
             goto refresh;
             
+        case (GRUB_TERM_CTRL | 'r'):
+            menu_fini ();
+            g_ventoy_grub2_mode = 1 - g_ventoy_grub2_mode;
+            g_ventoy_menu_refresh = 1;
+            goto refresh;
+            
+        case (GRUB_TERM_CTRL | 'w'):
+            menu_fini ();
+            g_ventoy_wimboot_mode = 1 - g_ventoy_wimboot_mode;
+            g_ventoy_menu_refresh = 1;
+            goto refresh;
+            
         case (GRUB_TERM_CTRL | 'u'):
             menu_fini ();
             g_ventoy_iso_uefi_drv = 1 - g_ventoy_iso_uefi_drv;

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

@@ -0,0 +1,795 @@
+
+#define ventoy_keyboard_set_layout(name) if (grub_strcmp(layout, #name) == 0) return ventoy_keyboard_layout_##name()
+
+static void ventoy_keyboard_layout_QWERTY_USA(void) {
+    grub_keymap_reset();
+    grub_keymap_disable();
+}
+static void ventoy_keyboard_layout_AZERTY(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("a", "q"); 
+grub_keymap_add_by_string("A", "Q"); 
+grub_keymap_add_by_string("z", "w"); 
+grub_keymap_add_by_string("Z", "W"); 
+grub_keymap_add_by_string("q", "a"); 
+grub_keymap_add_by_string("Q", "A"); 
+grub_keymap_add_by_string("m", "semicolon"); 
+grub_keymap_add_by_string("M", "colon"); 
+grub_keymap_add_by_string("w", "z"); 
+grub_keymap_add_by_string("W", "Z"); 
+grub_keymap_add_by_string("comma", "m"); 
+grub_keymap_add_by_string("question", "M"); 
+grub_keymap_add_by_string("semicolon", "comma"); 
+grub_keymap_add_by_string("period", "less"); 
+grub_keymap_add_by_string("colon", "period"); 
+grub_keymap_add_by_string("slash", "greater"); 
+grub_keymap_add_by_string("exclam", "slash"); 
+grub_keymap_add_by_string("dollar", "bracketright"); 
+grub_keymap_add_by_string("asterisk", "backslash"); 
+grub_keymap_add_by_string("percent", "doublequote"); 
+grub_keymap_add_by_string("ampersand", "1"); 
+grub_keymap_add_by_string("1", "exclam"); 
+grub_keymap_add_by_string("tilde", "2"); 
+grub_keymap_add_by_string("2", "at"); 
+grub_keymap_add_by_string("doublequote", "3"); 
+grub_keymap_add_by_string("3", "numbersign"); 
+grub_keymap_add_by_string("quote", "4"); 
+grub_keymap_add_by_string("4", "dollar"); 
+grub_keymap_add_by_string("parenleft", "5"); 
+grub_keymap_add_by_string("5", "percent"); 
+grub_keymap_add_by_string("minus", "6"); 
+grub_keymap_add_by_string("6", "caret"); 
+grub_keymap_add_by_string("backquote", "7"); 
+grub_keymap_add_by_string("7", "ampersand"); 
+grub_keymap_add_by_string("underscore", "8"); 
+grub_keymap_add_by_string("8", "asterisk"); 
+grub_keymap_add_by_string("caret", "9"); 
+grub_keymap_add_by_string("9", "parenleft"); 
+grub_keymap_add_by_string("at", "0"); 
+grub_keymap_add_by_string("0", "parenright"); 
+grub_keymap_add_by_string("parenright", "minus"); 
+grub_keymap_add_by_string("less", "backquote"); 
+grub_keymap_add_by_string("greater", "tilde"); 
+grub_keymap_add_by_string("numbersign", "braceright"); 
+grub_keymap_add_by_string("backslash", "question"); 
+grub_keymap_add_by_string("bracketright", "braceleft"); 
+grub_keymap_add_by_string("braceleft", "quote"); 
+grub_keymap_add_by_string("braceright", "underscore"); 
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_CZECH_QWERTY(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("semicolon", "backquote");
+grub_keymap_add_by_string("plus", "1");
+grub_keymap_add_by_string("equal", "minus");
+grub_keymap_add_by_string("quote", "equal");
+grub_keymap_add_by_string("parenright", "bracketright");
+grub_keymap_add_by_string("doublequote", "backslash");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("1", "exclam");
+grub_keymap_add_by_string("2", "at");
+grub_keymap_add_by_string("3", "numbersign");
+grub_keymap_add_by_string("4", "dollar");
+grub_keymap_add_by_string("5", "percent");
+grub_keymap_add_by_string("6", "caret");
+grub_keymap_add_by_string("7", "ampersand");
+grub_keymap_add_by_string("8", "asterisk");
+grub_keymap_add_by_string("9", "parenleft");
+grub_keymap_add_by_string("0", "parenright");
+grub_keymap_add_by_string("percent", "underscore");
+grub_keymap_add_by_string("slash", "braceleft");
+grub_keymap_add_by_string("parenleft", "braceright");
+grub_keymap_add_by_string("doublequote", "colon");
+grub_keymap_add_by_string("exclam", "doublequote");
+grub_keymap_add_by_string("quote", "bar");
+grub_keymap_add_by_string("question", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("backquote", "Abackquote");
+grub_keymap_add_by_string("exclam", "A1");
+grub_keymap_add_by_string("at", "A2");
+grub_keymap_add_by_string("numbersign", "A3");
+grub_keymap_add_by_string("dollar", "A4");
+grub_keymap_add_by_string("percent", "A5");
+grub_keymap_add_by_string("caret", "A6");
+grub_keymap_add_by_string("ampersand", "A7");
+grub_keymap_add_by_string("asterisk", "A8");
+grub_keymap_add_by_string("parenleft", "A9");
+grub_keymap_add_by_string("parenright", "A0");
+grub_keymap_add_by_string("minus", "Aminus");
+grub_keymap_add_by_string("equal", "Aequal");
+grub_keymap_add_by_string("bracketleft", "Abracketleft");
+grub_keymap_add_by_string("bracketright", "Abracketright");
+grub_keymap_add_by_string("semicolon", "Asemicolon");
+grub_keymap_add_by_string("backslash", "Abackslash");
+grub_keymap_add_by_string("less", "Acomma");
+grub_keymap_add_by_string("greater", "Aperiod");
+grub_keymap_add_by_string("slash", "Aslash");
+grub_keymap_add_by_string("tilde", "Atilde");
+grub_keymap_add_by_string("underscore", "Aunderscore");
+grub_keymap_add_by_string("plus", "Aplus");
+grub_keymap_add_by_string("braceleft", "Abraceleft");
+grub_keymap_add_by_string("braceright", "Abraceright");
+grub_keymap_add_by_string("caret", "Adoublequote");
+grub_keymap_add_by_string("colon", "Acolon");
+grub_keymap_add_by_string("question", "Aquestion");
+grub_keymap_add_by_string("bar", "Abar");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_CZECH_QWERTZ(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("y", "z"); 
+grub_keymap_add_by_string("z", "y"); 
+grub_keymap_add_by_string("Y", "Z"); 
+grub_keymap_add_by_string("Z", "Y");
+grub_keymap_add_by_string("semicolon", "backquote");
+grub_keymap_add_by_string("plus", "1");
+grub_keymap_add_by_string("equal", "minus");
+grub_keymap_add_by_string("quote", "equal");
+grub_keymap_add_by_string("parenright", "bracketright");
+grub_keymap_add_by_string("doublequote", "backslash");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("1", "exclam");
+grub_keymap_add_by_string("2", "at");
+grub_keymap_add_by_string("3", "numbersign");
+grub_keymap_add_by_string("4", "dollar");
+grub_keymap_add_by_string("5", "percent");
+grub_keymap_add_by_string("6", "caret");
+grub_keymap_add_by_string("7", "ampersand");
+grub_keymap_add_by_string("8", "asterisk");
+grub_keymap_add_by_string("9", "parenleft");
+grub_keymap_add_by_string("0", "parenright");
+grub_keymap_add_by_string("percent", "underscore");
+grub_keymap_add_by_string("slash", "braceleft");
+grub_keymap_add_by_string("parenleft", "braceright");
+grub_keymap_add_by_string("doublequote", "colon");
+grub_keymap_add_by_string("exclam", "doublequote");
+grub_keymap_add_by_string("quote", "bar");
+grub_keymap_add_by_string("question", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("tilde", "A1");
+grub_keymap_add_by_string("caret", "A3");
+grub_keymap_add_by_string("backslash", "Aq");
+grub_keymap_add_by_string("bar", "Aw");
+grub_keymap_add_by_string("bracketleft", "Af");
+grub_keymap_add_by_string("bracketright", "Ag");
+grub_keymap_add_by_string("dollar", "Asemicolon");
+grub_keymap_add_by_string("numbersign", "Ax");
+grub_keymap_add_by_string("ampersand", "Ac");
+grub_keymap_add_by_string("at", "Av");
+grub_keymap_add_by_string("braceleft", "Ab");
+grub_keymap_add_by_string("braceright", "An");
+grub_keymap_add_by_string("less", "Acomma");
+grub_keymap_add_by_string("greater", "Aperiod");
+grub_keymap_add_by_string("asterisk", "Aslash");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_DANISH(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("plus", "minus");
+grub_keymap_add_by_string("quote", "equal");
+grub_keymap_add_by_string("doublequote", "bracketright");
+grub_keymap_add_by_string("quote", "backslash");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("caret", "braceright");
+grub_keymap_add_by_string("asterisk", "bar");
+grub_keymap_add_by_string("backquote", "plus");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("bar", "Atilde");
+grub_keymap_add_by_string("backslash", "Abackquote");
+grub_keymap_add_by_string("greater", "tilde");
+grub_keymap_add_by_string("at", "A2");
+grub_keymap_add_by_string("dollar", "A4");
+grub_keymap_add_by_string("braceleft", "A7");
+grub_keymap_add_by_string("bracketleft", "A8");
+grub_keymap_add_by_string("bracketright", "A9");
+grub_keymap_add_by_string("braceright", "A0");
+grub_keymap_add_by_string("backslash", "Aminus");
+grub_keymap_add_by_string("less", "quote");
+grub_keymap_add_by_string("greater", "doublequote");
+grub_keymap_add_by_string("tilde", "Abracketright");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_DVORAK_USA(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("[", "minus");
+grub_keymap_add_by_string("braceleft", "underscore");
+grub_keymap_add_by_string("quote", "q"); 
+grub_keymap_add_by_string("doublequote", "Q"); 
+grub_keymap_add_by_string("comma", "w"); 
+grub_keymap_add_by_string("less", "W"); 
+grub_keymap_add_by_string("s", "semicolon"); 
+grub_keymap_add_by_string("S", "colon"); 
+grub_keymap_add_by_string("semicolon", "z"); 
+grub_keymap_add_by_string("colon", "Z"); 
+grub_keymap_add_by_string("w", "comma"); 
+grub_keymap_add_by_string("W", "less"); 
+grub_keymap_add_by_string("v", "period"); 
+grub_keymap_add_by_string("z", "greater"); 
+grub_keymap_add_by_string("z", "slash"); 
+grub_keymap_add_by_string("equal", "bracketright"); 
+grub_keymap_add_by_string("backslash", "backslash"); 
+grub_keymap_add_by_string("underscore", "doublequote"); 
+grub_keymap_add_by_string("quote", "q");
+grub_keymap_add_by_string("doublequote", "Q");
+grub_keymap_add_by_string("comma", "w");
+grub_keymap_add_by_string("less", "W");
+grub_keymap_add_by_string("period", "e");
+grub_keymap_add_by_string("greater", "E");
+grub_keymap_add_by_string("p", "r");
+grub_keymap_add_by_string("P", "R");
+grub_keymap_add_by_string("y", "t");
+grub_keymap_add_by_string("Y", "T");
+grub_keymap_add_by_string("f", "y");
+grub_keymap_add_by_string("F", "Y");
+grub_keymap_add_by_string("g", "u");
+grub_keymap_add_by_string("G", "U");
+grub_keymap_add_by_string("c", "c");
+grub_keymap_add_by_string("C", "I");
+grub_keymap_add_by_string("r", "o");
+grub_keymap_add_by_string("R", "O");
+grub_keymap_add_by_string("l", "p");
+grub_keymap_add_by_string("L", "P");
+grub_keymap_add_by_string("bracketright", "equal");
+grub_keymap_add_by_string("braceright", "plus");
+grub_keymap_add_by_string("a", "a");
+grub_keymap_add_by_string("A", "A");
+grub_keymap_add_by_string("o", "s");
+grub_keymap_add_by_string("O", "S");
+grub_keymap_add_by_string("e", "d");
+grub_keymap_add_by_string("E", "D");
+grub_keymap_add_by_string("u", "f");
+grub_keymap_add_by_string("U", "F");
+grub_keymap_add_by_string("i", "g");
+grub_keymap_add_by_string("I", "G");
+grub_keymap_add_by_string("d", "h");
+grub_keymap_add_by_string("D", "H");
+grub_keymap_add_by_string("h", "j");
+grub_keymap_add_by_string("H", "J");
+grub_keymap_add_by_string("t", "k");
+grub_keymap_add_by_string("T", "K");
+grub_keymap_add_by_string("n", "l");
+grub_keymap_add_by_string("N", "L");
+grub_keymap_add_by_string("s", "semicolon");
+grub_keymap_add_by_string("S", "colon");
+grub_keymap_add_by_string("minus", "quote");
+grub_keymap_add_by_string("underscore", "doublequote");
+grub_keymap_add_by_string("semicolon", "z");
+grub_keymap_add_by_string("colon", "Z");
+grub_keymap_add_by_string("q", "x");
+grub_keymap_add_by_string("Q", "X");
+grub_keymap_add_by_string("j", "c");
+grub_keymap_add_by_string("J", "C");
+grub_keymap_add_by_string("k", "v");
+grub_keymap_add_by_string("K", "V");
+grub_keymap_add_by_string("x", "b");
+grub_keymap_add_by_string("X", "B");
+grub_keymap_add_by_string("b", "n");
+grub_keymap_add_by_string("B", "N");
+grub_keymap_add_by_string("w", "comma");
+grub_keymap_add_by_string("W", "less");
+grub_keymap_add_by_string("v", "period");
+grub_keymap_add_by_string("V", "greater");
+grub_keymap_add_by_string("z", "slash");
+grub_keymap_add_by_string("Z", "question");
+grub_keymap_add_by_string("slash", "bracketleft");
+grub_keymap_add_by_string("question", "braceleft");
+grub_keymap_add_by_string("equal", "bracketright");
+grub_keymap_add_by_string("plus", "braceright");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_FRENCH(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("less", "backquote");
+grub_keymap_add_by_string("greater", "tilde");
+grub_keymap_add_by_string("ampersand", "1");
+grub_keymap_add_by_string("1", "exclam");
+grub_keymap_add_by_string("tilde", "2");
+grub_keymap_add_by_string("2", "at");
+grub_keymap_add_by_string("doublequote", "3");
+grub_keymap_add_by_string("3", "numbersign");
+grub_keymap_add_by_string("quote", "4");
+grub_keymap_add_by_string("4", "dollar");
+grub_keymap_add_by_string("parenleft", "5");
+grub_keymap_add_by_string("5", "percent");
+grub_keymap_add_by_string("minus", "6");
+grub_keymap_add_by_string("6", "caret");
+grub_keymap_add_by_string("backquote", "7");
+grub_keymap_add_by_string("7", "ampersand");
+grub_keymap_add_by_string("underscore", "8");
+grub_keymap_add_by_string("8", "asterisk");
+grub_keymap_add_by_string("backslash", "9");
+grub_keymap_add_by_string("9", "parenleft");
+grub_keymap_add_by_string("at", "0");
+grub_keymap_add_by_string("0", "parenright");
+grub_keymap_add_by_string("parenright", "minus");
+grub_keymap_add_by_string("numbersign", "underscore");
+grub_keymap_add_by_string("a", "q");
+grub_keymap_add_by_string("A", "Q");
+grub_keymap_add_by_string("z", "w");
+grub_keymap_add_by_string("Z", "W");
+grub_keymap_add_by_string("caret", "bracketleft");
+grub_keymap_add_by_string("dollar", "bracketright");
+grub_keymap_add_by_string("q", "a");
+grub_keymap_add_by_string("Q", "A");
+grub_keymap_add_by_string("m", "semicolon");
+grub_keymap_add_by_string("M", "colon");
+grub_keymap_add_by_string("bracketleft", "quote");
+grub_keymap_add_by_string("percent", "doublequote");
+grub_keymap_add_by_string("asterisk", "backslash");
+grub_keymap_add_by_string("bracketright", "bar");
+grub_keymap_add_by_string("w", "z");
+grub_keymap_add_by_string("W", "Z");
+grub_keymap_add_by_string("comma", "m");
+grub_keymap_add_by_string("question", "M");
+grub_keymap_add_by_string("semicolon", "comma");
+grub_keymap_add_by_string("period", "less");
+grub_keymap_add_by_string("colon", "period");
+grub_keymap_add_by_string("slash", "greater");
+grub_keymap_add_by_string("exclam", "slash");
+grub_keymap_add_by_string("bar", "question");
+grub_keymap_add_by_string("tilde", "A2");
+grub_keymap_add_by_string("numbersign", "A3");
+grub_keymap_add_by_string("braceleft", "A4");
+grub_keymap_add_by_string("bracketleft", "A5");
+grub_keymap_add_by_string("bar", "A6");
+grub_keymap_add_by_string("quote", "A7");
+grub_keymap_add_by_string("backslash", "A8");
+grub_keymap_add_by_string("caret", "A9");
+grub_keymap_add_by_string("at", "A0");
+grub_keymap_add_by_string("bracketright", "Aminus");
+grub_keymap_add_by_string("braceright", "Aequal");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_GERMAN(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("backslash", "minus");
+grub_keymap_add_by_string("z", "y");
+grub_keymap_add_by_string("Z", "Y");
+grub_keymap_add_by_string("y", "z");
+grub_keymap_add_by_string("Y", "Z");
+grub_keymap_add_by_string("plus", "bracketright");
+grub_keymap_add_by_string("asterisk", "braceright");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("backslash", "Aminus");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("caret", "backquote");
+grub_keymap_add_by_string("quote", "equal");
+grub_keymap_add_by_string("backquote", "plus");
+grub_keymap_add_by_string("braceright", "doublequote");
+grub_keymap_add_by_string("bar", "bracketleft");
+grub_keymap_add_by_string("at", "braceleft");
+grub_keymap_add_by_string("numbersign", "backslash");
+grub_keymap_add_by_string("at", "Aq");
+grub_keymap_add_by_string("less", "backquote");
+grub_keymap_add_by_string("greater", "tilde");
+grub_keymap_add_by_string("braceleft", "A7");
+grub_keymap_add_by_string("bracketleft", "A8");
+grub_keymap_add_by_string("bracketright", "A9");
+grub_keymap_add_by_string("braceright", "A0");
+grub_keymap_add_by_string("tilde", "Abracketright");
+grub_keymap_add_by_string("backslash", "Aminus");
+grub_keymap_add_by_string("quote", "bar");
+grub_keymap_add_by_string("greater", "semicolon");
+grub_keymap_add_by_string("less", "colon");
+grub_keymap_add_by_string("bar", "quote");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_ITALIANO(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("backslash", "backquote");
+grub_keymap_add_by_string("bar", "tilde");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("tilde", "numbersign");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("quote", "minus");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("caret", "plus");
+grub_keymap_add_by_string("bracketleft", "bracketleft");
+grub_keymap_add_by_string("bracketright", "braceleft");
+grub_keymap_add_by_string("plus", "bracketright");
+grub_keymap_add_by_string("asterisk", "braceright");
+grub_keymap_add_by_string("at", "semicolon");
+grub_keymap_add_by_string("braceleft", "colon");
+grub_keymap_add_by_string("numbersign", "quote");
+grub_keymap_add_by_string("braceright", "doublequote");
+grub_keymap_add_by_string("less", "backslash");
+grub_keymap_add_by_string("greater", "bar");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("bracketleft", "Abracketleft");
+grub_keymap_add_by_string("bracketright", "Abracketright");
+grub_keymap_add_by_string("at", "Asemicolon");
+grub_keymap_add_by_string("numbersign", "Aquote");
+grub_keymap_add_by_string("braceright", "Abraceright");
+grub_keymap_add_by_string("braceleft", "Abraceleft");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_JAPAN_106(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("at", "bracketleft");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("quote", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("underscore", "parenright");
+grub_keymap_add_by_string("equal", "underscore");
+grub_keymap_add_by_string("plus", "colon");
+grub_keymap_add_by_string("colon", "quote");
+grub_keymap_add_by_string("asterisk", "doublequote");
+grub_keymap_add_by_string("bracketleft", "bracketright");
+grub_keymap_add_by_string("braceleft", "braceright");
+grub_keymap_add_by_string("bracketright", "backslash");
+grub_keymap_add_by_string("braceright", "bar");
+grub_keymap_add_by_string("backslash", "backquote");
+grub_keymap_add_by_string("tilde", "plus");
+grub_keymap_add_by_string("caret", "equal");
+grub_keymap_add_by_string("backquote", "braceleft");
+grub_keymap_add_by_string("bar", "tilde");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_LATIN_USA(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("bar", "backquote");
+grub_keymap_add_by_string("quote", "minus");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("backquote", "bracketleft");
+grub_keymap_add_by_string("plus", "bracketright");
+grub_keymap_add_by_string("braceleft", "quote");
+grub_keymap_add_by_string("braceright", "backslash");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("asterisk", "braceright");
+grub_keymap_add_by_string("bracketleft", "doublequote");
+grub_keymap_add_by_string("bracketright", "bar");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("caret", "Aquote");
+grub_keymap_add_by_string("doublequote", "braceleft");
+grub_keymap_add_by_string("at", "Aq");
+grub_keymap_add_by_string("backquote", "Abackslash");
+grub_keymap_add_by_string("backslash", "Aminus");
+grub_keymap_add_by_string("greater", "plus");
+grub_keymap_add_by_string("less", "equal");
+grub_keymap_add_by_string("backslash", "Aminus");
+grub_keymap_add_by_string("backquote", "Abackslash");
+grub_keymap_add_by_string("tilde", "Abracketright");
+grub_keymap_add_by_string("caret", "Aquote");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_PORTU_BRAZIL(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("quote", "backquote");
+grub_keymap_add_by_string("quote", "bracketleft");
+grub_keymap_add_by_string("bracketleft", "bracketright");
+grub_keymap_add_by_string("tilde", "quote");
+grub_keymap_add_by_string("bracketright", "backslash");
+grub_keymap_add_by_string("semicolon", "slash");
+grub_keymap_add_by_string("bar", "colon");
+grub_keymap_add_by_string("doublequote", "tilde");
+grub_keymap_add_by_string("backquote", "braceleft");
+grub_keymap_add_by_string("braceleft", "braceright");
+grub_keymap_add_by_string("caret", "doublequote");
+grub_keymap_add_by_string("braceright", "bar");
+grub_keymap_add_by_string("colon", "question");
+grub_keymap_add_by_string("backslash", "semicolon");
+grub_keymap_add_by_string("bar", "Atilde");
+grub_keymap_add_by_string("backslash", "Abackquote");
+grub_keymap_add_by_string("slash", "Aq");
+grub_keymap_add_by_string("question", "Aw");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_QWERTY_UK(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("at", "doublequote");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("tilde", "bar");
+grub_keymap_add_by_string("numbersign", "backslash");
+grub_keymap_add_by_string("backslash", "numbersign");
+grub_keymap_add_by_string("bar", "tilde");
+grub_keymap_add_by_string("backslash", "Atilde");
+grub_keymap_add_by_string("backslash", "Abackquote");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_QWERTZ(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("ampersand", "percent");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("backslash", "minus");
+grub_keymap_add_by_string("z", "y");
+grub_keymap_add_by_string("Z", "Y");
+grub_keymap_add_by_string("y", "z");
+grub_keymap_add_by_string("Y", "Z");
+grub_keymap_add_by_string("plus", "bracketright");
+grub_keymap_add_by_string("asterisk", "braceright");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("caret", "backquote");
+grub_keymap_add_by_string("backquote", "equal");
+grub_keymap_add_by_string("numbersign", "backslash");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("percent", "caret"); 
+grub_keymap_add_by_string("less", "numbersign"); 
+grub_keymap_add_by_string("greater", "bar"); 
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_QWERTZ_HUN(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("y", "z"); 
+grub_keymap_add_by_string("z", "y"); 
+grub_keymap_add_by_string("Y", "Z"); 
+grub_keymap_add_by_string("Z", "Y"); 
+grub_keymap_add_by_string("0", "backquote");
+grub_keymap_add_by_string("quote", "exclam");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("plus", "numbersign");
+grub_keymap_add_by_string("exclam", "dollar");
+grub_keymap_add_by_string("slash", "caret");
+grub_keymap_add_by_string("equal", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk"); 
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("backslash", "Aq");
+grub_keymap_add_by_string("bar", "Aw");
+grub_keymap_add_by_string("bracketleft", "Af"); 
+grub_keymap_add_by_string("bracketright", "Ag");
+grub_keymap_add_by_string("greater", "Az");
+grub_keymap_add_by_string("numbersign", "Ax");
+grub_keymap_add_by_string("ampersand", "Ac");
+grub_keymap_add_by_string("at", "Av");
+grub_keymap_add_by_string("braceleft", "Ab"); 
+grub_keymap_add_by_string("braceright", "An");
+grub_keymap_add_by_string("less", "Am");
+grub_keymap_add_by_string("dollar", "colon");
+grub_keymap_add_by_string("question", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("at", "doublequote");
+grub_keymap_add_by_string("tilde", "A1");
+grub_keymap_add_by_string("caret", "A3");
+grub_keymap_add_by_string("backquote", "A7");
+grub_keymap_add_by_string("asterisk", "0");
+grub_keymap_add_by_string("dollar", "Asemicolon");
+grub_keymap_add_by_string("semicolon", "Acomma");
+grub_keymap_add_by_string("greater", "Aperiod");
+grub_keymap_add_by_string("asterisk", "Aslash");
+grub_keymap_add_by_string("backquote", "A9");
+grub_keymap_add_by_string("doublequote", "A0");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_QWERTZ_SLOV_CROAT(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("quote", "minus");
+grub_keymap_add_by_string("plus", "equal");
+grub_keymap_add_by_string("y", "z");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("doublequote", "tilde");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("asterisk", "plus");
+grub_keymap_add_by_string("Y", "Z");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("tilde", "A1");
+grub_keymap_add_by_string("caret", "A3");
+grub_keymap_add_by_string("backquote", "A7");
+grub_keymap_add_by_string("backslash", "Aq");
+grub_keymap_add_by_string("bar", "Aw");
+grub_keymap_add_by_string("bracketleft", "Af");
+grub_keymap_add_by_string("bracketright", "Ag");
+grub_keymap_add_by_string("at", "Av");
+grub_keymap_add_by_string("braceleft", "Ab");
+grub_keymap_add_by_string("braceright", "An");
+grub_keymap_add_by_string("less", "Acomma");
+grub_keymap_add_by_string("greater", "Aperiod");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_SPANISH(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("caret", "braceleft");
+grub_keymap_add_by_string("asterisk", "braceright");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("quote", "minus");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("greater", "bar");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("backslash", "backquote");
+grub_keymap_add_by_string("less", "backslash");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("backquote", "bracketleft");
+grub_keymap_add_by_string("plus", "bracketright");
+grub_keymap_add_by_string("plus", "colon");
+grub_keymap_add_by_string("at", "semicolon");
+grub_keymap_add_by_string("bar", "A1");
+grub_keymap_add_by_string("at", "A2");
+grub_keymap_add_by_string("numbersign", "A3");
+grub_keymap_add_by_string("tilde", "A4");
+grub_keymap_add_by_string("bracketleft", "Abracketleft");
+grub_keymap_add_by_string("bracketright", "Abracketright");
+grub_keymap_add_by_string("braceleft", "Aquote");
+grub_keymap_add_by_string("braceright", "Abackslash");
+grub_keymap_add_by_string("greater", "bar");
+grub_keymap_add_by_string("less", "backslash");
+grub_keymap_add_by_string("backslash", "Abackquote");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_SWEDISH(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("plus", "minus");
+grub_keymap_add_by_string("quote", "equal");
+grub_keymap_add_by_string("doublequote", "bracketright");
+grub_keymap_add_by_string("quote", "backslash");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("caret", "braceright");
+grub_keymap_add_by_string("asterisk", "bar");
+grub_keymap_add_by_string("backquote", "plus");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("bar", "Atilde");
+grub_keymap_add_by_string("backslash", "Abackquote");
+grub_keymap_add_by_string("greater", "tilde");
+grub_keymap_add_by_string("at", "A2");
+grub_keymap_add_by_string("dollar", "A4");
+grub_keymap_add_by_string("braceleft", "A7");
+grub_keymap_add_by_string("bracketleft", "A8");
+grub_keymap_add_by_string("bracketright", "A9");
+grub_keymap_add_by_string("braceright", "A0");
+grub_keymap_add_by_string("backslash", "Aminus");
+grub_keymap_add_by_string("less", "quote");
+grub_keymap_add_by_string("greater", "doublequote");
+grub_keymap_add_by_string("tilde", "Abracketright");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_TURKISH_Q(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("doublequote", "backquote");
+grub_keymap_add_by_string("asterisk", "minus");
+grub_keymap_add_by_string("minus", "equal");
+grub_keymap_add_by_string("comma", "backslash");
+grub_keymap_add_by_string("period", "slash");
+grub_keymap_add_by_string("quote", "at");
+grub_keymap_add_by_string("caret", "numbersign");
+grub_keymap_add_by_string("plus", "dollar");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("underscore", "plus");
+grub_keymap_add_by_string("semicolon", "bar");
+grub_keymap_add_by_string("colon", "question");
+grub_keymap_add_by_string("less", "Abackquote");
+grub_keymap_add_by_string("greater", "A1");
+grub_keymap_add_by_string("numbersign", "A3");
+grub_keymap_add_by_string("dollar", "A4");
+grub_keymap_add_by_string("braceleft", "A7");
+grub_keymap_add_by_string("bracketleft", "A8");
+grub_keymap_add_by_string("bracketright", "A9");
+grub_keymap_add_by_string("braceright", "A0");
+grub_keymap_add_by_string("backslash", "Aminus");
+grub_keymap_add_by_string("bar", "Aequal");
+grub_keymap_add_by_string("at", "Aq");
+grub_keymap_add_by_string("doublequote", "Abracketleft");
+grub_keymap_add_by_string("tilde", "Abracketright");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_VIETNAMESE(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("exclam", "A1");
+grub_keymap_add_by_string("at", "A2");
+grub_keymap_add_by_string("numbersign", "A3");
+grub_keymap_add_by_string("dollar", "A4");
+grub_keymap_add_by_string("percent", "A5");
+grub_keymap_add_by_string("caret", "A6");
+grub_keymap_add_by_string("ampersand", "A7");
+grub_keymap_add_by_string("asterisk", "A8");
+grub_keymap_add_by_string("parenleft", "A9");
+grub_keymap_add_by_string("parenright", "A0");
+grub_keymap_add_by_string("plus", "Aplus");
+grub_keymap_add_by_string("equal", "Aequal");
+grub_keymap_add_by_string("braceleft", "Abraceleft");
+grub_keymap_add_by_string("braceright", "Abraceright");
+grub_keymap_add_by_string("colon", "Acolon");
+grub_keymap_add_by_string("semicolon", "Asemicolon");
+grub_keymap_add_by_string("quote", "Aquote");
+grub_keymap_add_by_string("backslash", "Abackslash");
+grub_keymap_add_by_string("less", "Aless");
+grub_keymap_add_by_string("greater", "Agreater");
+grub_keymap_add_by_string("comma", "Acomma");
+grub_keymap_add_by_string("period", "Aperiod");
+grub_keymap_add_by_string("question", "Aquestion");
+grub_keymap_add_by_string("slash", "Aslash");
+grub_keymap_add_by_string("tilde", "Atilde");
+grub_keymap_add_by_string("backquote", "Abackquote");
+grub_keymap_add_by_string("bracketright", "Abracketright");
+grub_keymap_add_by_string("bracketleft", "Abracketleft");
+grub_keymap_add_by_string("bar", "Abar");
+grub_keymap_add_by_string("doublequote", "Adoublequote");
+grub_keymap_add_by_string("colon", "Acolon");
+grub_keymap_add_by_string("minus", "Aminus");
+grub_keymap_add_by_string("underscore", "Aunderscore");
+grub_keymap_enable();
+}
+void ventoy_set_keyboard_layout(const char *layout);
+void ventoy_set_keyboard_layout(const char *layout) {
+ventoy_keyboard_set_layout(QWERTY_USA);
+ventoy_keyboard_set_layout(AZERTY);
+ventoy_keyboard_set_layout(CZECH_QWERTY);
+ventoy_keyboard_set_layout(CZECH_QWERTZ);
+ventoy_keyboard_set_layout(DANISH);
+ventoy_keyboard_set_layout(DVORAK_USA);
+ventoy_keyboard_set_layout(FRENCH);
+ventoy_keyboard_set_layout(GERMAN);
+ventoy_keyboard_set_layout(ITALIANO);
+ventoy_keyboard_set_layout(JAPAN_106);
+ventoy_keyboard_set_layout(LATIN_USA);
+ventoy_keyboard_set_layout(PORTU_BRAZIL);
+ventoy_keyboard_set_layout(QWERTY_UK);
+ventoy_keyboard_set_layout(QWERTZ);
+ventoy_keyboard_set_layout(QWERTZ_HUN);
+ventoy_keyboard_set_layout(QWERTZ_SLOV_CROAT);
+ventoy_keyboard_set_layout(SPANISH);
+ventoy_keyboard_set_layout(SWEDISH);
+ventoy_keyboard_set_layout(TURKISH_Q);
+ventoy_keyboard_set_layout(VIETNAMESE);
+}

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

@@ -348,12 +348,38 @@ out:
   return grub_errno;
 }
 
-static grub_extcmd_t cmd;
+static void grub_keymap_add_by_string(const char *src, const char *dst)
+{
+    int in = 0;
+    int out = 0;
+    
+    in = parse_key(dst);
+    out = parse_key(src);
+
+    if (in && out)
+    {
+        grub_keymap_add (in, out);        
+    }
+}
+
+#include "keyboard_layout.c"
+
+static grub_err_t grub_cmd_set_keylayout (grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    (void)ctxt;
+    (void)argc;
+    ventoy_set_keyboard_layout(args[0]);
+    return 0;
+}
+
+static grub_extcmd_t cmd, setcmd;
 
 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);
+  setcmd = grub_register_extcmd ("set_keyboard_layout", grub_cmd_set_keylayout, 0, N_("layout"),
+                              N_("Set keyboard layout."), NULL);
 }
 
 GRUB_MOD_FINI(setkey)

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

@@ -29,6 +29,8 @@
 
 #define VTOY_SIZE_1GB     1073741824
 #define VTOY_SIZE_1MB     (1024 * 1024)
+#define VTOY_SIZE_2MB     (2 * 1024 * 1024)
+#define VTOY_SIZE_4MB     (4 * 1024 * 1024)
 #define VTOY_SIZE_512KB   (512 * 1024)
 #define VTOY_SIZE_1KB     1024
 
@@ -140,6 +142,7 @@ typedef struct cpio_newc_header
 typedef int (*grub_char_check_func)(int c);
 #define ventoy_is_decimal(str)  ventoy_string_check(str, grub_isdigit)
 
+#define OFFSET_OF(TYPE, MEMBER) ((grub_size_t) &((TYPE *)0)->MEMBER)
 
 #pragma pack(1)
 typedef struct ventoy_patch_vhd
@@ -193,12 +196,14 @@ typedef struct ventoy_iso9660_vd
 
 #pragma pack()
 
-#define img_type_iso  0
-#define img_type_wim  1
-#define img_type_efi  2
-#define img_type_img  3
-#define img_type_vhd  4
-#define img_type_vtoy 5
+#define img_type_start 0
+#define img_type_iso   0
+#define img_type_wim   1
+#define img_type_efi   2
+#define img_type_img   3
+#define img_type_vhd   4
+#define img_type_vtoy  5
+#define img_type_max   6
 
 typedef struct img_info
 {
@@ -281,10 +286,11 @@ 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 const char *g_menu_prefix[img_type_max];
 
 extern int g_ventoy_debug;
 void ventoy_debug(const char *fmt, ...);
-#define debug(fmt, ...) if (g_ventoy_debug) ventoy_debug("[VTOY]: "fmt, __VA_ARGS__)
+#define debug(fmt, args...) if (g_ventoy_debug) ventoy_debug("[VTOY]: "fmt, ##args)
 
 #define vtoy_ssprintf(buf, pos, fmt, ...) \
     pos += grub_snprintf(buf + pos, VTOY_MAX_SCRIPT_BUF - pos, fmt, __VA_ARGS__)
@@ -390,6 +396,15 @@ typedef struct wim_security_header
     grub_uint32_t count; /* Number of entries */
 }wim_security_header;
 
+typedef struct wim_stream_entry 
+{
+    grub_uint64_t len;
+    grub_uint64_t unused1;
+    wim_hash hash;
+    grub_uint16_t name_len;
+    /* name */
+}wim_stream_entry;
+
 /* Directory entry */
 typedef struct wim_directory_entry 
 {
@@ -518,7 +533,8 @@ typedef struct plugin_entry
     ventoy_plugin_check_pf checkfunc;
 }plugin_entry;
 
-
+int ventoy_strcmp(const char *pattern, const char *str);
+int ventoy_strncmp (const char *pattern, const char *str, grub_size_t n);
 void ventoy_fill_os_param(grub_file_t file, ventoy_os_param *param);
 grub_err_t ventoy_cmd_isolinux_initrd_collect(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_grub_initrd_collect(grub_extcmd_context_t ctxt, int argc, char **args);
@@ -543,10 +559,16 @@ int ventoy_is_dir_exist(const char *fmt, ...);
 int ventoy_fill_data(grub_uint32_t buflen, char *buffer);
 grub_err_t ventoy_cmd_load_plugin(grub_extcmd_context_t ctxt, int argc, char **args);
 grub_err_t ventoy_cmd_wimdows_reset(grub_extcmd_context_t ctxt, int argc, char **args);
+grub_err_t ventoy_cmd_is_pe64(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_windows_wimboot_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);
+grub_err_t ventoy_cmd_sel_wimboot(grub_extcmd_context_t ctxt, int argc, char **args);
+grub_err_t ventoy_cmd_set_wim_prompt(grub_extcmd_context_t ctxt, int argc, char **args);
+grub_ssize_t ventoy_load_file_with_prompt(grub_file_t file, void *buf, grub_ssize_t size);
+int ventoy_need_prompt_load_file(void);
 
 VTOY_JSON *vtoy_json_find_item
 (
@@ -756,8 +778,17 @@ typedef struct file_fullpath
     char path[256];
 }file_fullpath;
 
+typedef struct theme_list
+{
+    file_fullpath theme;
+    struct theme_list *next;
+}theme_list;
+
+#define auto_install_type_file   0
+#define auto_install_type_parent 1
 typedef struct install_template
 {
+    int type;
     int pathlen;
     char isopath[256];
 
@@ -820,6 +851,7 @@ typedef struct menu_class
 {
     int  type;
     int  patlen;
+    int  parent;
     char pattern[256];
     char class[64];
 
@@ -850,8 +882,11 @@ typedef struct conf_replace
     struct conf_replace *next;
 }conf_replace;
 
+#define injection_type_file   0
+#define injection_type_parent 1
 typedef struct injection_config
 {
+    int type;
     int pathlen;
     char isopath[256];
     char archive[256];
@@ -888,8 +923,12 @@ typedef struct vtoy_password
     grub_uint8_t md5[16];
 }vtoy_password;
 
+#define vtoy_menu_pwd_file   0
+#define vtoy_menu_pwd_parent 1
+
 typedef struct menu_password
 {
+    int type;
     int pathlen;
     char isopath[256];
 
@@ -903,6 +942,8 @@ extern int g_ventoy_suppress_esc;
 extern int g_ventoy_last_entry;
 extern int g_ventoy_memdisk_mode;
 extern int g_ventoy_iso_raw;
+extern int g_ventoy_grub2_mode;
+extern int g_ventoy_wimboot_mode;
 extern int g_ventoy_iso_uefi_drv;
 extern int g_ventoy_case_insensitive;
 extern grub_uint8_t g_ventoy_chain_type;
@@ -920,6 +961,8 @@ 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;
+extern grub_uint64_t g_ventoy_disk_part_size[2];
+extern grub_uint32_t g_ventoy_plat_data;
 
 #define ventoy_unix_fill_virt(new_data, new_len) \
 { \
@@ -937,19 +980,23 @@ extern grub_uint64_t g_ventoy_disk_size;
     chain->virt_img_size_in_bytes += data_secs * 2048; \
 }
 
+#define ventoy_syscall0(name) grub_##name()
+#define ventoy_syscall1(name, a) grub_##name(a)
+
 char * ventoy_get_line(char *start);
 int ventoy_cmp_img(img_info *img1, img_info *img2);
 void ventoy_swap_img(img_info *img1, img_info *img2);
 char * ventoy_plugin_get_cur_install_template(const char *isopath);
 install_template * ventoy_plugin_find_install_template(const char *isopath);
 persistence_config * ventoy_plugin_find_persistent(const char *isopath);
+grub_uint64_t ventoy_get_vtoy_partsize(int part);
 void ventoy_plugin_dump_injection(void);
 void ventoy_plugin_dump_auto_install(void);
 int ventoy_fill_windows_rtdata(void *buf, char *isopath);
 int ventoy_plugin_get_persistent_chunklist(const char *isopath, int index, ventoy_img_chunk_list *chunk_list);
 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);
+const char * ventoy_plugin_get_menu_class(int type, const char *name, const char *path);
 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);
@@ -958,6 +1005,7 @@ 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_set_theme(grub_extcmd_context_t ctxt, int argc, char **args);
 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);
@@ -973,6 +1021,7 @@ grub_err_t ventoy_cmd_unix_fill_image_desc(grub_extcmd_context_t ctxt, int argc,
 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);
+grub_err_t ventoy_cmd_unix_freebsd_ver_elf(grub_extcmd_context_t ctxt, int argc, char **args);
 int ventoy_check_device_result(int ret);
 int ventoy_check_device(grub_device_t dev);
 void ventoy_debug_dump_guid(const char *prefix, grub_uint8_t *guid);
@@ -981,11 +1030,22 @@ grub_err_t ventoy_cmd_patch_vhdboot(grub_extcmd_context_t ctxt, int argc, char *
 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);
 int ventoy_plugin_add_custom_boot(const char *vcfgpath);
 const char * ventoy_plugin_get_custom_boot(const char *isopath);
 grub_err_t ventoy_cmd_dump_custom_boot(grub_extcmd_context_t ctxt, int argc, char **args);
+int ventoy_gzip_compress(void *mem_in, int mem_in_len, void *mem_out, int mem_out_len);
+int ventoy_load_part_table(const char *diskname);
+int ventoy_env_init(void);
+int ventoy_register_all_cmd(void);
+int ventoy_unregister_all_cmd(void);
+int ventoy_chain_file_size(const char *path);
+int ventoy_chain_file_read(const char *path, int offset, int len, void *buf);
+
+#define VTOY_CMD_CHECK(a) if (33554432 != g_ventoy_disk_part_size[a]) ventoy_syscall0(exit)
+
+#define vtoy_theme_random_boot_second  0
+#define vtoy_theme_random_boot_day     1
+#define vtoy_theme_random_boot_month   2
 
 #endif /* __VENTOY_DEF_H__ */
 

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

@@ -43,6 +43,7 @@ GRUB_MOD_LICENSE ("GPLv3+");
 char g_arch_mode_suffix[64];
 static char g_iso_disk_name[128];
 static vtoy_password g_boot_pwd;
+static vtoy_password g_file_type_pwd[img_type_max];
 static install_template *g_install_template_head = NULL;
 static dud *g_dud_head = NULL;
 static menu_password *g_pwd_head = NULL;
@@ -55,6 +56,32 @@ 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 g_theme_num = 0;
+static theme_list *g_theme_head = NULL;
+static int g_theme_random = vtoy_theme_random_boot_second;
+static char g_theme_single_file[256];
+
+static int ventoy_plugin_is_parent(const char *pat, int patlen, const char *isopath)
+{
+    if (patlen > 1)
+    {
+        if (isopath[patlen] == '/' && ventoy_strncmp(pat, isopath, patlen) == 0 &&
+            grub_strchr(isopath + patlen + 1, '/') == NULL)
+        {
+            return 1;
+        }
+    }
+    else
+    {
+        if (pat[0] == '/' && grub_strchr(isopath + 1, '/') == NULL)
+        {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
 static int ventoy_plugin_control_check(VTOY_JSON *json, const char *isodisk)
 {
     int rc = 0;
@@ -155,6 +182,38 @@ static int ventoy_plugin_theme_check(VTOY_JSON *json, const char *isodisk)
             return 1;
         }
     }
+    else
+    {
+        node = vtoy_json_find_item(json->pstChild, JSON_TYPE_ARRAY, "file");
+        if (node)
+        {
+            for (node = node->pstChild; node; node = node->pstNext)
+            {
+                value = node->unData.pcStrVal;
+                grub_printf("file: %s\n", value);
+                if (value[0] == '/')
+                {
+                    exist = ventoy_is_file_exist("%s%s", isodisk, value);
+                }
+                else
+                {
+                    exist = ventoy_is_file_exist("%s/ventoy/%s", isodisk, value);
+                }
+
+                if (exist == 0)
+                {
+                    grub_printf("Theme file %s does NOT exist\n", value);
+                    return 1;
+                }
+            }
+
+            value = vtoy_json_get_string_ex(json->pstChild, "random");
+            if (value)
+            {
+                grub_printf("random: %s\n", value);
+            }
+        }
+    }
     
     value = vtoy_json_get_string_ex(json->pstChild, "gfxmode");
     if (value)
@@ -222,8 +281,10 @@ static int ventoy_plugin_theme_entry(VTOY_JSON *json, const char *isodisk)
 {
     const char *value;
     char filepath[256];
-    VTOY_JSON *node;
-    
+    VTOY_JSON *node = NULL;
+    theme_list *tail = NULL;
+    theme_list *themenode = NULL;
+
     value = vtoy_json_get_string_ex(json->pstChild, "file");
     if (value)
     {
@@ -236,7 +297,7 @@ static int ventoy_plugin_theme_entry(VTOY_JSON *json, const char *isodisk)
             grub_snprintf(filepath, sizeof(filepath), "%s/ventoy/%s", isodisk, value);
         }
         
-        if (ventoy_is_file_exist(filepath) == 0)
+        if (ventoy_check_file_exist(filepath) == 0)
         {
             debug("Theme file %s does not exist\n", filepath);
             return 0;
@@ -244,6 +305,65 @@ static int ventoy_plugin_theme_entry(VTOY_JSON *json, const char *isodisk)
 
         debug("vtoy_theme %s\n", filepath);
         grub_env_set("vtoy_theme", filepath);
+        grub_snprintf(g_theme_single_file, sizeof(g_theme_single_file), "%s", filepath);
+    }
+    else
+    {
+        node = vtoy_json_find_item(json->pstChild, JSON_TYPE_ARRAY, "file");
+        if (node)
+        {
+            for (node = node->pstChild; node; node = node->pstNext)
+            {
+                value = node->unData.pcStrVal;
+                if (value[0] == '/')
+                {
+                    grub_snprintf(filepath, sizeof(filepath), "%s%s", isodisk, value);
+                }
+                else
+                {
+                    grub_snprintf(filepath, sizeof(filepath), "%s/ventoy/%s", isodisk, value);
+                }
+
+                if (ventoy_check_file_exist(filepath) == 0)
+                {
+                    continue;
+                }
+
+                themenode = grub_zalloc(sizeof(theme_list));
+                if (themenode)
+                {
+                    grub_snprintf(themenode->theme.path, sizeof(themenode->theme.path), "%s", filepath);
+                    if (g_theme_head)
+                    {
+                        tail->next = themenode;
+                    }
+                    else
+                    {
+                        g_theme_head = themenode;
+                    }
+                    tail = themenode;
+                    g_theme_num++;
+                }
+            }
+
+            grub_env_set("vtoy_theme", "random");
+            value = vtoy_json_get_string_ex(json->pstChild, "random");
+            if (value)
+            {
+                if (grub_strcmp(value, "boot_second") == 0)
+                {
+                    g_theme_random = vtoy_theme_random_boot_second;
+                }
+                else if (grub_strcmp(value, "boot_day") == 0)
+                {
+                    g_theme_random = vtoy_theme_random_boot_day;
+                }
+                else if (grub_strcmp(value, "boot_month") == 0)
+                {
+                    g_theme_random = vtoy_theme_random_boot_month;
+                }
+            }
+        }
     }
     
     value = vtoy_json_get_string_ex(json->pstChild, "gfxmode");
@@ -481,6 +601,7 @@ static int ventoy_plugin_auto_install_check(VTOY_JSON *json, const char *isodisk
 {
     int pathnum = 0;
     int autosel = 0;
+    char *pos = NULL;
     const char *iso = NULL;
     VTOY_JSON *pNode = NULL;
 
@@ -497,12 +618,12 @@ static int ventoy_plugin_auto_install_check(VTOY_JSON *json, const char *isodisk
             grub_printf("NOT object type\n");
         }
     
-        iso = vtoy_json_get_string_ex(pNode->pstChild, "image");
-        if (iso)
+        if ((iso = vtoy_json_get_string_ex(pNode->pstChild, "image")) != NULL)
         {
-            if (0 == ventoy_plugin_check_path(isodisk, iso))
+            pos = grub_strchr(iso, '*');
+            if (pos || 0 == ventoy_plugin_check_path(isodisk, iso))
             {
-                grub_printf("image: %s [OK]\n", iso);
+                grub_printf("image: %s [%s]\n", iso, (pos ? "*" : "OK"));                
                 ventoy_plugin_check_fullpath(pNode->pstChild, isodisk, "template", &pathnum);
                 
                 if (JSON_SUCCESS == vtoy_json_get_int(pNode->pstChild, "autosel", &autosel))
@@ -522,6 +643,30 @@ static int ventoy_plugin_auto_install_check(VTOY_JSON *json, const char *isodisk
                 grub_printf("image: %s [FAIL]\n", iso);
             }
         }
+        else if ((iso = vtoy_json_get_string_ex(pNode->pstChild, "parent")) != NULL)
+        {
+            if (ventoy_is_dir_exist("%s%s", isodisk, iso))
+            {
+                grub_printf("parent: %s [OK]\n", iso);
+                ventoy_plugin_check_fullpath(pNode->pstChild, isodisk, "template", &pathnum);
+                
+                if (JSON_SUCCESS == vtoy_json_get_int(pNode->pstChild, "autosel", &autosel))
+                {
+                    if (autosel >= 0 && autosel <= pathnum)
+                    {
+                        grub_printf("autosel: %d [OK]\n", autosel);
+                    }
+                    else
+                    {
+                        grub_printf("autosel: %d [FAIL]\n", autosel);
+                    }
+                }
+            }
+            else
+            {
+                grub_printf("parent: %s [FAIL]\n", iso);
+            }
+        }
         else
         {
             grub_printf("image not found\n");
@@ -533,6 +678,7 @@ static int ventoy_plugin_auto_install_check(VTOY_JSON *json, const char *isodisk
 
 static int ventoy_plugin_auto_install_entry(VTOY_JSON *json, const char *isodisk)
 {
+    int type = 0;
     int pathnum = 0;
     int autosel = 0;
     const char *iso = NULL;
@@ -561,7 +707,14 @@ static int ventoy_plugin_auto_install_entry(VTOY_JSON *json, const char *isodisk
 
     for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
     {
+        type = auto_install_type_file;
         iso = vtoy_json_get_string_ex(pNode->pstChild, "image");
+        if (!iso)
+        {
+            type = auto_install_type_parent;
+            iso = vtoy_json_get_string_ex(pNode->pstChild, "parent");
+        }
+        
         if (iso && iso[0] == '/')
         {
             if (0 == ventoy_plugin_parse_fullpath(pNode->pstChild, isodisk, "template", &templatepath, &pathnum))
@@ -569,6 +722,7 @@ static int ventoy_plugin_auto_install_entry(VTOY_JSON *json, const char *isodisk
                 node = grub_zalloc(sizeof(install_template));
                 if (node)
                 {
+                    node->type = type;
                     node->pathlen = grub_snprintf(node->isopath, sizeof(node->isopath), "%s", iso);
                     node->templatepath = templatepath;
                     node->templatenum = pathnum;
@@ -599,6 +753,7 @@ static int ventoy_plugin_auto_install_entry(VTOY_JSON *json, const char *isodisk
 static int ventoy_plugin_dud_check(VTOY_JSON *json, const char *isodisk)
 {
     int pathnum = 0;
+    char *pos = NULL;
     const char *iso = NULL;
     VTOY_JSON *pNode = NULL;
 
@@ -618,9 +773,10 @@ static int ventoy_plugin_dud_check(VTOY_JSON *json, const char *isodisk)
         iso = vtoy_json_get_string_ex(pNode->pstChild, "image");
         if (iso)
         {
-            if (0 == ventoy_plugin_check_path(isodisk, iso))
+            pos = grub_strchr(iso, '*');
+            if (pos || 0 == ventoy_plugin_check_path(isodisk, iso))
             {
-                grub_printf("image: %s [OK]\n", iso);
+                grub_printf("image: %s [%s]\n", iso, (pos ? "*" : "OK"));
                 ventoy_plugin_check_fullpath(pNode->pstChild, isodisk, "dud", &pathnum);
             }
             else
@@ -805,8 +961,26 @@ static int ventoy_plugin_parse_pwdstr(char *pwdstr, vtoy_password *pwd)
     return 0;
 }
 
+static int ventoy_plugin_get_pwd_type(const char *pwd)
+{
+    int i;
+    char pwdtype[64];
+
+    for (i = 0; pwd && i < (int)ARRAY_SIZE(g_menu_prefix); i++)
+    {
+        grub_snprintf(pwdtype, sizeof(pwdtype), "%spwd", g_menu_prefix[i]);
+        if (grub_strcmp(pwdtype, pwd) == 0)
+        {
+            return img_type_start + i; 
+        }
+    }
+    
+    return -1;
+}
+
 static int ventoy_plugin_pwd_entry(VTOY_JSON *json, const char *isodisk)
 {
+    int type = -1;
     const char *iso = NULL;
     const char *pwd = NULL;
     VTOY_JSON *pNode = NULL;
@@ -840,6 +1014,10 @@ static int ventoy_plugin_pwd_entry(VTOY_JSON *json, const char *isodisk)
         {
             ventoy_plugin_parse_pwdstr(pNode->unData.pcStrVal, &g_boot_pwd);
         }
+        else if ((type = ventoy_plugin_get_pwd_type(pNode->pcName)) >= 0)
+        {
+            ventoy_plugin_parse_pwdstr(pNode->unData.pcStrVal, g_file_type_pwd + type);
+        }
         else if (pNode->pcName && grub_strcmp("menupwd", pNode->pcName) == 0)
         {
             for (pCNode = pNode->pstChild; pCNode; pCNode = pCNode->pstNext)
@@ -849,13 +1027,21 @@ static int ventoy_plugin_pwd_entry(VTOY_JSON *json, const char *isodisk)
                     continue;
                 }
 
+                type = vtoy_menu_pwd_file;
                 iso = vtoy_json_get_string_ex(pCNode->pstChild, "file");
+                if (!iso)
+                {
+                    type = vtoy_menu_pwd_parent;
+                    iso = vtoy_json_get_string_ex(pCNode->pstChild, "parent");                    
+                }                
+                
                 pwd = vtoy_json_get_string_ex(pCNode->pstChild, "pwd");
                 if (iso && pwd && iso[0] == '/')
                 {
                     node = grub_zalloc(sizeof(menu_password));
                     if (node)
                     {
+                        node->type = type;
                         node->pathlen = grub_snprintf(node->isopath, sizeof(node->isopath), "%s", iso);
 
                         if (ventoy_plugin_parse_pwdstr((char *)pwd, &(node->password)))
@@ -884,6 +1070,8 @@ static int ventoy_plugin_pwd_entry(VTOY_JSON *json, const char *isodisk)
 
 static int ventoy_plugin_pwd_check(VTOY_JSON *json, const char *isodisk)
 {
+    int type = -1;
+    char *pos = NULL;
     const char *iso = NULL;
     const char *pwd = NULL;
     VTOY_JSON *pNode = NULL;
@@ -908,6 +1096,17 @@ static int ventoy_plugin_pwd_check(VTOY_JSON *json, const char *isodisk)
                 grub_printf("Invalid bootpwd.\n");
             }
         }
+        else if ((type = ventoy_plugin_get_pwd_type(pNode->pcName)) >= 0)
+        {
+            if (0 == ventoy_plugin_parse_pwdstr(pNode->unData.pcStrVal, NULL))
+            {
+                grub_printf("%s:<%s>\n", pNode->pcName, pNode->unData.pcStrVal);
+            }
+            else
+            {
+                grub_printf("Invalid pwd <%s>\n", pNode->unData.pcStrVal);
+            }
+        }
         else if (pNode->pcName && grub_strcmp("menupwd", pNode->pcName) == 0)
         {
             grub_printf("\n");
@@ -919,16 +1118,36 @@ static int ventoy_plugin_pwd_check(VTOY_JSON *json, const char *isodisk)
                     continue;
                 }
 
-                iso = vtoy_json_get_string_ex(pCNode->pstChild, "file");
-                if (iso)
+                if ((iso = vtoy_json_get_string_ex(pCNode->pstChild, "file")) != NULL)
                 {
-                    if (0 == ventoy_plugin_check_path(isodisk, iso))
+                    pos = grub_strchr(iso, '*');
+                    if (pos || 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("file:<%s> [%s]\n", iso, (pos ? "*" : "OK"));
+                            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 if ((iso = vtoy_json_get_string_ex(pCNode->pstChild, "parent")) != NULL)
+                {
+                    if (ventoy_is_dir_exist("%s%s", isodisk, iso))
+                    {
+                        pwd = vtoy_json_get_string_ex(pCNode->pstChild, "pwd");
+                        if (0 == ventoy_plugin_parse_pwdstr((char *)pwd, NULL))
+                        {
+                            grub_printf("dir:<%s> [%s]\n", iso, (pos ? "*" : "OK"));
                             grub_printf("pwd:<%s>\n\n", pwd);
                         }
                         else
@@ -956,6 +1175,7 @@ static int ventoy_plugin_persistence_check(VTOY_JSON *json, const char *isodisk)
 {
     int autosel = 0;
     int pathnum = 0;
+    char *pos = NULL;
     const char *iso = NULL;
     VTOY_JSON *pNode = NULL;
 
@@ -975,9 +1195,10 @@ static int ventoy_plugin_persistence_check(VTOY_JSON *json, const char *isodisk)
         iso = vtoy_json_get_string_ex(pNode->pstChild, "image");
         if (iso)
         {
-            if (0 == ventoy_plugin_check_path(isodisk, iso))
+            pos = grub_strchr(iso, '*');
+            if (pos || 0 == ventoy_plugin_check_path(isodisk, iso))
             {
-                grub_printf("image: %s [OK]\n", iso);
+                grub_printf("image: %s [%s]\n", iso, (pos ? "*" : "OK"));
                 ventoy_plugin_check_fullpath(pNode->pstChild, isodisk, "backend", &pathnum);
 
                 if (JSON_SUCCESS == vtoy_json_get_int(pNode->pstChild, "autosel", &autosel))
@@ -1102,8 +1323,12 @@ static int ventoy_plugin_menualias_check(VTOY_JSON *json, const char *isodisk)
         if (path && path[0] == '/' && alias)
         {
             if (vtoy_alias_image_file == type)
-            {                
-                if (ventoy_is_file_exist("%s%s", isodisk, path))
+            {
+                if (grub_strchr(path, '*'))
+                {
+                    grub_printf("image: <%s> [ * ]\n", path);
+                }
+                else if (ventoy_is_file_exist("%s%s", isodisk, path))
                 {
                     grub_printf("image: <%s> [ OK ]\n", path);
                 }
@@ -1195,6 +1420,7 @@ static int ventoy_plugin_menualias_entry(VTOY_JSON *json, const char *isodisk)
 
 static int ventoy_plugin_injection_check(VTOY_JSON *json, const char *isodisk)
 {
+    int type = 0;
     const char *path = NULL;
     const char *archive = NULL;
     VTOY_JSON *pNode = NULL;
@@ -1209,11 +1435,17 @@ static int ventoy_plugin_injection_check(VTOY_JSON *json, const char *isodisk)
 
     for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
     {
+        type = injection_type_file;
         path = vtoy_json_get_string_ex(pNode->pstChild, "image");
         if (!path)
         {
-            grub_printf("image not found\n");
-            continue;
+            type = injection_type_parent;
+            path = vtoy_json_get_string_ex(pNode->pstChild, "parent");
+            if (!path)
+            {
+                grub_printf("image/parent not found\n");
+                continue;
+            }
         }
 
         archive = vtoy_json_get_string_ex(pNode->pstChild, "archive");
@@ -1223,7 +1455,23 @@ static int ventoy_plugin_injection_check(VTOY_JSON *json, const char *isodisk)
             continue;
         }
 
-        grub_printf("image: <%s> [%s]\n", path, ventoy_check_file_exist("%s%s", isodisk, path) ? "OK" : "NOT EXIST");
+        if (type == injection_type_file)
+        {
+            if (grub_strchr(path, '*'))
+            {
+                grub_printf("image: <%s> [*]\n", path);
+            }
+            else
+            {
+                grub_printf("image: <%s> [%s]\n", path, ventoy_check_file_exist("%s%s", isodisk, path) ? "OK" : "NOT EXIST");            
+            }
+        }
+        else
+        {
+            grub_printf("parent: <%s> [%s]\n", path, 
+                ventoy_is_dir_exist("%s%s", isodisk, path) ? "OK" : "NOT EXIST");
+        }
+
         grub_printf("archive: <%s> [%s]\n\n", archive, ventoy_check_file_exist("%s%s", isodisk, archive) ? "OK" : "NOT EXIST");
     }
 
@@ -1232,6 +1480,7 @@ static int ventoy_plugin_injection_check(VTOY_JSON *json, const char *isodisk)
 
 static int ventoy_plugin_injection_entry(VTOY_JSON *json, const char *isodisk)
 {
+    int type = 0;
     const char *path = NULL;
     const char *archive = NULL;
     VTOY_JSON *pNode = NULL;
@@ -1259,13 +1508,21 @@ static int ventoy_plugin_injection_entry(VTOY_JSON *json, const char *isodisk)
 
     for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
     {
+        type = injection_type_file;
         path = vtoy_json_get_string_ex(pNode->pstChild, "image");
+        if (!path)
+        {
+            type = injection_type_parent;
+            path = vtoy_json_get_string_ex(pNode->pstChild, "parent");
+        }
+        
         archive = vtoy_json_get_string_ex(pNode->pstChild, "archive");
         if (path && path[0] == '/' && archive && archive[0] == '/')
         {
             node = grub_zalloc(sizeof(injection_config));
             if (node)
             {
+                node->type = type;
                 node->pathlen = grub_snprintf(node->isopath, sizeof(node->isopath), "%s", path);
                 grub_snprintf(node->archive, sizeof(node->archive), "%s", archive);
 
@@ -1285,6 +1542,7 @@ static int ventoy_plugin_injection_entry(VTOY_JSON *json, const char *isodisk)
 static int ventoy_plugin_menuclass_entry(VTOY_JSON *json, const char *isodisk)
 {
     int type;
+    int parent = 0;
     const char *key = NULL;
     const char *class = NULL;
     VTOY_JSON *pNode = NULL;
@@ -1313,12 +1571,21 @@ static int ventoy_plugin_menuclass_entry(VTOY_JSON *json, const char *isodisk)
 
     for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
     {
+        parent = 0;
         type = vtoy_class_image_file;
         key = vtoy_json_get_string_ex(pNode->pstChild, "key");
         if (!key)
         {
-            key = vtoy_json_get_string_ex(pNode->pstChild, "dir");
-            type = vtoy_class_directory;
+            key = vtoy_json_get_string_ex(pNode->pstChild, "parent");
+            if (key)
+            {
+                parent = 1;
+            }
+            else
+            {
+                key = vtoy_json_get_string_ex(pNode->pstChild, "dir");
+                type = vtoy_class_directory;
+            }
         }
         
         class = vtoy_json_get_string_ex(pNode->pstChild, "class");
@@ -1328,6 +1595,7 @@ static int ventoy_plugin_menuclass_entry(VTOY_JSON *json, const char *isodisk)
             if (node)
             {
                 node->type = type;
+                node->parent = parent;
                 node->patlen = grub_snprintf(node->pattern, sizeof(node->pattern), "%s", key);
                 grub_snprintf(node->class, sizeof(node->class), "%s", class);
 
@@ -1349,7 +1617,7 @@ static int ventoy_plugin_menuclass_entry(VTOY_JSON *json, const char *isodisk)
 
 static int ventoy_plugin_menuclass_check(VTOY_JSON *json, const char *isodisk)
 {
-    int type;
+    const char *name = NULL;
     const char *key = NULL;
     const char *class = NULL;
     VTOY_JSON *pNode = NULL;
@@ -1364,18 +1632,23 @@ static int ventoy_plugin_menuclass_check(VTOY_JSON *json, const char *isodisk)
 
     for (pNode = json->pstChild; pNode; pNode = pNode->pstNext)
     {
-        type = vtoy_class_image_file;
+        name = "key";
         key = vtoy_json_get_string_ex(pNode->pstChild, "key");
         if (!key)
         {
-            key = vtoy_json_get_string_ex(pNode->pstChild, "dir"); 
-            type = vtoy_class_directory;
+            name = "parent";
+            key = vtoy_json_get_string_ex(pNode->pstChild, "parent");
+            if (!key)
+            {
+                name = "dir";       
+                key = vtoy_json_get_string_ex(pNode->pstChild, "dir"); 
+            }
         }
         
         class = vtoy_json_get_string_ex(pNode->pstChild, "class");
         if (key && class)
         {
-            grub_printf("%s: <%s>\n", (type == vtoy_class_directory) ? "dir" : "key",  key);
+            grub_printf("%s: <%s>\n", name,  key);
             grub_printf("class: <%s>\n\n", class);
         }
     }
@@ -1611,6 +1884,11 @@ static int ventoy_plugin_conf_replace_check(VTOY_JSON *json, const char *isodisk
                 
                 grub_script_execute_sourcecode("loopback -d vtisocheck");
             }
+            else if (grub_strchr(isof, '*'))
+            {
+                grub_printf("iso:<%s> [*]\n", isof);
+                grub_printf("org:<%s>\n", orgf);
+            }
             else
             {
                 grub_printf("iso:<%s> [NOT Exist]\n", isof);
@@ -1704,7 +1982,11 @@ static int ventoy_plugin_auto_memdisk_check(VTOY_JSON *json, const char *isodisk
         {
             grub_printf("<%s> ", pNode->unData.pcStrVal);
 
-            if (ventoy_check_file_exist("%s%s", isodisk, pNode->unData.pcStrVal))
+            if (grub_strchr(pNode->unData.pcStrVal, '*'))
+            {
+                grub_printf(" [*]\n");
+            }
+            else if (ventoy_check_file_exist("%s%s", isodisk, pNode->unData.pcStrVal))
             {
                 grub_printf(" [OK]\n");
             }
@@ -1794,7 +2076,11 @@ static int ventoy_plugin_image_list_check(VTOY_JSON *json, const char *isodisk)
         {
             grub_printf("<%s> ", pNode->unData.pcStrVal);
 
-            if (ventoy_check_file_exist("%s%s", isodisk, pNode->unData.pcStrVal))
+            if (grub_strchr(pNode->unData.pcStrVal, '*'))
+            {
+                grub_printf(" [*]\n");
+            }
+            else if (ventoy_check_file_exist("%s%s", isodisk, pNode->unData.pcStrVal))
             {
                 grub_printf(" [OK]\n");
             }
@@ -1928,7 +2214,7 @@ void ventoy_plugin_dump_injection(void)
 
     for (node = g_injection_head; node; node = node->next)
     {
-        grub_printf("\nIMAGE:<%s>\n", node->isopath);
+        grub_printf("\n%s:<%s>\n", (node->type == injection_type_file) ? "IMAGE" : "PARENT", node->isopath);
         grub_printf("ARCHIVE:<%s>\n", node->archive);
     }
 
@@ -1943,7 +2229,9 @@ void ventoy_plugin_dump_auto_install(void)
 
     for (node = g_install_template_head; node; node = node->next)
     {
-        grub_printf("\nIMAGE:<%s> <%d>\n", node->isopath, node->templatenum);
+        grub_printf("\n%s:<%s> <%d>\n", 
+            (node->type == auto_install_type_file) ? "IMAGE" : "PARENT",
+            node->isopath, node->templatenum);
         for (i = 0; i < node->templatenum; i++)
         {
             grub_printf("SCRIPT %d:<%s>\n", i, node->templatepath[i].path);            
@@ -1996,9 +2284,23 @@ install_template * ventoy_plugin_find_install_template(const char *isopath)
     len = (int)grub_strlen(isopath);
     for (node = g_install_template_head; node; node = node->next)
     {
-        if (node->pathlen == len && grub_strcmp(node->isopath, isopath) == 0)
+        if (node->type == auto_install_type_file)
         {
-            return node;
+            if (node->pathlen == len && ventoy_strcmp(node->isopath, isopath) == 0)
+            {
+                return node;
+            }
+        }
+    }
+    
+    for (node = g_install_template_head; node; node = node->next)
+    {
+        if (node->type == auto_install_type_parent)
+        {
+            if (node->pathlen < len && ventoy_plugin_is_parent(node->isopath, node->pathlen, isopath))
+            {
+                return node;
+            }
         }
     }
 
@@ -2036,7 +2338,7 @@ persistence_config * ventoy_plugin_find_persistent(const char *isopath)
     len = (int)grub_strlen(isopath);
     for (node = g_persistence_head; node; node = node->next)
     {
-        if ((len == node->pathlen) && (grub_strcmp(node->isopath, isopath) == 0))
+        if ((len == node->pathlen) && (ventoy_strcmp(node->isopath, isopath) == 0))
         {
             return node;
         }
@@ -2117,9 +2419,23 @@ const char * ventoy_plugin_get_injection(const char *isopath)
     len = (int)grub_strlen(isopath);
     for (node = g_injection_head; node; node = node->next)
     {
-        if (node->pathlen == len && grub_strcmp(node->isopath, isopath) == 0)
+        if (node->type == injection_type_file)
         {
-            return node->archive;
+            if (node->pathlen == len && ventoy_strcmp(node->isopath, isopath) == 0)
+            {
+                return node->archive;
+            }
+        }
+    }
+    
+    for (node = g_injection_head; node; node = node->next)
+    {
+        if (node->type == injection_type_parent)
+        {
+            if (node->pathlen < len && ventoy_plugin_is_parent(node->isopath, node->pathlen, isopath))
+            {
+                return node->archive;
+            }
         }
     }
 
@@ -2140,7 +2456,7 @@ const char * ventoy_plugin_get_menu_alias(int type, const char *isopath)
     for (node = g_menu_alias_head; node; node = node->next)
     {
         if (node->type == type && node->pathlen && 
-            node->pathlen == len && grub_strcmp(node->isopath, isopath) == 0)
+            node->pathlen == len && ventoy_strcmp(node->isopath, isopath) == 0)
         {
             return node->alias;
         }
@@ -2149,25 +2465,42 @@ const char * ventoy_plugin_get_menu_alias(int type, const char *isopath)
     return NULL;
 }
 
-const char * ventoy_plugin_get_menu_class(int type, const char *name)
+const char * ventoy_plugin_get_menu_class(int type, const char *name, const char *path)
 {
-    int len;
+    int namelen;
+    int pathlen;
     menu_class *node = NULL;
 
     if (!g_menu_class_head)
     {
         return NULL;
     }
-
-    len = (int)grub_strlen(name);
+    
+    namelen = (int)grub_strlen(name); 
+    pathlen = (int)grub_strlen(path); 
     
     if (vtoy_class_image_file == type)
     {
         for (node = g_menu_class_head; node; node = node->next)
         {
-            if (node->type == type && node->patlen <= len && grub_strstr(name, node->pattern))
+            if (node->type != type)
             {
-                return node->class;
+                continue;
+            }
+
+            if (node->parent)
+            {
+                if ((node->patlen < pathlen) && ventoy_plugin_is_parent(node->pattern, node->patlen, path))
+                {
+                    return node->class;
+                }
+            }
+            else
+            {
+                if ((node->patlen < namelen) && grub_strstr(name, node->pattern))
+                {
+                    return node->class;
+                }
             }
         }
     }
@@ -2175,7 +2508,7 @@ const char * ventoy_plugin_get_menu_class(int type, const char *name)
     {
         for (node = g_menu_class_head; node; node = node->next)
         {
-            if (node->type == type && node->patlen == len && grub_strncmp(name, node->pattern, len) == 0)
+            if (node->type == type && node->patlen == namelen && grub_strncmp(name, node->pattern, namelen) == 0)
             {
                 return node->class;
             }
@@ -2288,7 +2621,7 @@ int ventoy_plugin_check_memdisk(const char *isopath)
     len = (int)grub_strlen(isopath);    
     for (node = g_auto_memdisk_head; node; node = node->next)
     {
-        if (node->pathlen == len && grub_strncmp(isopath, node->isopath, len) == 0)
+        if (node->pathlen == len && ventoy_strncmp(node->isopath, isopath, len) == 0)
         {
             return 1;
         }
@@ -2314,14 +2647,14 @@ int ventoy_plugin_get_image_list_index(int type, const char *name)
     {
         if (vtoy_class_directory == type)
         {
-            if (len < node->pathlen && grub_strncmp(name, node->isopath, len) == 0)
+            if (len < node->pathlen && ventoy_strncmp(node->isopath, name, len) == 0)
             {
                 return index;
             }
         }
         else
         {
-            if (len == node->pathlen && grub_strncmp(name, node->isopath, len) == 0)
+            if (len == node->pathlen && ventoy_strncmp(node->isopath, name, len) == 0)
             {
                 return index;
             }
@@ -2345,7 +2678,7 @@ conf_replace * ventoy_plugin_find_conf_replace(const char *iso)
     
     for (node = g_conf_replace_head; node; node = node->next)
     {
-        if (node->pathlen == len && grub_strncmp(iso, node->isopath, len) == 0)
+        if (node->pathlen == len && ventoy_strncmp(node->isopath, iso, len) == 0)
         {
             return node;
         }
@@ -2367,7 +2700,7 @@ dud * ventoy_plugin_find_dud(const char *iso)
     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)
+        if (node->pathlen == len && ventoy_strncmp(node->isopath, iso, len) == 0)
         {
             return node;
         }
@@ -2409,20 +2742,59 @@ int ventoy_plugin_load_dud(dud *node, const char *isopart)
 
 static const vtoy_password * ventoy_plugin_get_password(const char *isopath)
 {
+    int i;
     int len;
+    const char *pos = NULL;
     menu_password *node = NULL;
 
-    if ((!g_pwd_head) || (!isopath))
+    if (!isopath)
     {
         return NULL;
     }
 
-    len = (int)grub_strlen(isopath);    
-    for (node = g_pwd_head; node; node = node->next)
+    if (g_pwd_head)
     {
-        if (node->pathlen == len && grub_strncmp(isopath, node->isopath, len) == 0)
+        len = (int)grub_strlen(isopath);    
+        for (node = g_pwd_head; node; node = node->next)
         {
-            return &(node->password);
+            if (node->type == vtoy_menu_pwd_file)
+            {
+                if (node->pathlen == len && ventoy_strncmp(node->isopath, isopath, len) == 0)
+                {
+                    return &(node->password);
+                }
+            }
+        }
+
+        for (node = g_pwd_head; node; node = node->next)
+        {   
+            if (node->type == vtoy_menu_pwd_parent)
+            {
+                if (node->pathlen < len && ventoy_plugin_is_parent(node->isopath, node->pathlen, isopath))
+                {
+                    return &(node->password);
+                }
+            }
+        }
+    }
+
+    while (*isopath)
+    {
+        if (*isopath == '.')
+        {
+            pos = isopath;
+        }
+        isopath++;
+    }
+
+    if (pos)
+    {
+        for (i = 0; i < (int)ARRAY_SIZE(g_menu_prefix); i++)
+        {
+            if (g_file_type_pwd[i].type && 0 == grub_strcasecmp(pos + 1, g_menu_prefix[i]))
+            {
+                return g_file_type_pwd + i;
+            }
         }
     }
 
@@ -2542,3 +2914,62 @@ end:
     return 0;
 }
 
+grub_err_t ventoy_cmd_set_theme(grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    grub_uint32_t i = 0;
+    grub_uint32_t mod = 0;
+    theme_list *node = g_theme_head;
+    struct grub_datetime datetime;
+    
+    (void)argc;
+    (void)args;
+    (void)ctxt;
+
+    if (g_theme_single_file[0])
+    {
+        debug("single theme %s\n", g_theme_single_file);
+        grub_env_set("theme", g_theme_single_file);
+        goto end;
+    }
+
+    debug("g_theme_num = %d\n", g_theme_num);
+    
+    if (g_theme_num == 0)
+    {
+        goto end;
+    }
+
+    grub_memset(&datetime, 0, sizeof(datetime));
+    grub_get_datetime(&datetime);
+
+    if (g_theme_random == vtoy_theme_random_boot_second)
+    {
+        grub_divmod32((grub_uint32_t)datetime.second, (grub_uint32_t)g_theme_num, &mod);
+    }
+    else if (g_theme_random == vtoy_theme_random_boot_day)
+    {
+        grub_divmod32((grub_uint32_t)datetime.day, (grub_uint32_t)g_theme_num, &mod);
+    }
+    else if (g_theme_random == vtoy_theme_random_boot_month)
+    {
+        grub_divmod32((grub_uint32_t)datetime.month, (grub_uint32_t)g_theme_num, &mod);
+    }
+
+    debug("%04d/%02d/%02d %02d:%02d:%02d radom:%d mod:%d\n",
+          datetime.year, datetime.month, datetime.day,
+          datetime.hour, datetime.minute, datetime.second,
+          g_theme_random, mod);
+
+    for (i = 0; i < mod && node; i++)
+    {
+        node = node->next;
+    }
+
+    debug("random theme %s\n", node->theme.path);
+    grub_env_set("theme", node->theme.path);
+
+end:
+    VENTOY_CMD_RETURN(GRUB_ERR_NONE);
+}
+
+

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

@@ -33,6 +33,8 @@
 #include <grub/i18n.h>
 #include <grub/net.h>
 #include <grub/time.h>
+#include <grub/elf.h>
+#include <grub/elfload.h>
 #include <grub/ventoy.h>
 #include "ventoy_def.h"
 
@@ -383,6 +385,174 @@ grub_err_t ventoy_cmd_unix_freebsd_ver(grub_extcmd_context_t ctxt, int argc, cha
     VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 }
 
+grub_err_t ventoy_cmd_unix_freebsd_ver_elf(grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    int j;
+    int k;
+    grub_elf_t elf = NULL;
+    grub_off_t offset = 0;
+    grub_uint32_t len = 0;
+    char *str = NULL;
+    char *data = NULL;
+    void *hdr = NULL;
+    char ver[64] = {0};
+    
+    (void)ctxt;
+    (void)argc;
+    (void)args;
+
+    if (argc != 3)
+    {
+        debug("Invalid argc %d\n", argc);
+        return 1;
+    }
+
+    data = grub_zalloc(8192);
+    if (!data)
+    {
+        goto out;
+    }
+
+    elf = grub_elf_open(args[0], GRUB_FILE_TYPE_LINUX_INITRD);
+    if (!elf)
+    {
+        debug("Failed to open file %s\n", args[0]);
+        goto out;
+    }
+
+    if (args[1][0] == '6')
+    {
+        Elf64_Ehdr *e = &(elf->ehdr.ehdr64);
+        Elf64_Shdr *h;
+        Elf64_Shdr *s;
+        Elf64_Shdr *t;
+        Elf64_Half i;
+        
+        h = hdr = grub_zalloc(e->e_shnum * e->e_shentsize);
+        if (!h)
+        {
+            goto out;
+        }
+
+        debug("read section header %u %u %u\n", e->e_shnum, e->e_shentsize, e->e_shstrndx);
+        grub_file_seek(elf->file, e->e_shoff);
+        grub_file_read(elf->file, h, e->e_shnum * e->e_shentsize);
+
+        s = (Elf64_Shdr *)((char *)h + e->e_shstrndx * e->e_shentsize);        
+        str = grub_malloc(s->sh_size + 1);
+        if (!str)
+        {
+            goto out;
+        }
+        str[s->sh_size] = 0;
+
+        debug("read string table %u %u\n", (grub_uint32_t)s->sh_offset, (grub_uint32_t)s->sh_size);
+        grub_file_seek(elf->file, s->sh_offset);
+        grub_file_read(elf->file, str, s->sh_size);
+
+        for (t = h, i = 0; i < e->e_shnum; i++)
+        {
+            if (grub_strcmp(str + t->sh_name, ".data") == 0)
+            {
+                offset = t->sh_offset;
+                len = t->sh_size;
+                debug("find .data section at %u %u\n", (grub_uint32_t)offset, len);
+                break;
+            }
+            t = (Elf64_Shdr *)((char *)t + e->e_shentsize);
+        }
+    }
+    else
+    {
+        Elf32_Ehdr *e = &(elf->ehdr.ehdr32);
+        Elf32_Shdr *h;
+        Elf32_Shdr *s;
+        Elf32_Shdr *t;
+        Elf32_Half i;
+        
+        h = hdr = grub_zalloc(e->e_shnum * e->e_shentsize);
+        if (!h)
+        {
+            goto out;
+        }
+
+        debug("read section header %u %u %u\n", e->e_shnum, e->e_shentsize, e->e_shstrndx);
+        grub_file_seek(elf->file, e->e_shoff);
+        grub_file_read(elf->file, h, e->e_shnum * e->e_shentsize);
+
+        s = (Elf32_Shdr *)((char *)h + e->e_shstrndx * e->e_shentsize);        
+        str = grub_malloc(s->sh_size + 1);
+        if (!str)
+        {
+            goto out;
+        }
+        str[s->sh_size] = 0;
+
+        debug("read string table %u %u\n", (grub_uint32_t)s->sh_offset, (grub_uint32_t)s->sh_size);
+        grub_file_seek(elf->file, s->sh_offset);
+        grub_file_read(elf->file, str, s->sh_size);
+
+        for (t = h, i = 0; i < e->e_shnum; i++)
+        {
+            if (grub_strcmp(str + t->sh_name, ".data") == 0)
+            {
+                offset = t->sh_offset;
+                len = t->sh_size;
+                debug("find .data section at %u %u\n", (grub_uint32_t)offset, len);
+                break;
+            }
+            t = (Elf32_Shdr *)((char *)t + e->e_shentsize);
+        }
+    }
+
+    if (offset == 0 || len == 0)
+    {
+        debug(".data section not found %s\n", args[0]);
+        goto out;
+    }
+
+    grub_file_seek(elf->file, offset + len - 8192);
+    grub_file_read(elf->file, data, 8192);
+
+    for (j = 0; j < 8192 - 12; j++)
+    {
+        if (grub_strncmp(data + j, "@(#)FreeBSD ", 12) == 0)
+        {
+            for (k = j + 12; k < 8192; k++)
+            {
+                if (0 == grub_isdigit(data[k]) && data[k] != '.')
+                {
+                    data[k] = 0;
+                    break;
+                }
+            }
+        
+            grub_snprintf(ver, sizeof(ver), "%s", data + j + 12);
+            break;
+        }
+    }
+
+    if (ver[0])
+    {
+        k = (int)grub_strtoul(ver, NULL, 10);
+        debug("freebsd version:<%s> <%d.x>\n", ver, k);
+        grub_snprintf(ver, sizeof(ver), "%d.x", k);
+        ventoy_set_env(args[2], ver);
+    }
+    else
+    {
+        debug("freebsd version:<%s>\n", "NOT FOUND");
+    }
+
+out:
+    grub_check_free(str);
+    grub_check_free(hdr);
+    grub_check_free(data);
+    check_free(elf, grub_elf_close);
+    
+    VENTOY_CMD_RETURN(GRUB_ERR_NONE);
+}
+
 grub_err_t ventoy_cmd_unix_replace_conf(grub_extcmd_context_t ctxt, int argc, char **args)
 {
     grub_uint32_t i;
@@ -550,7 +720,7 @@ grub_err_t ventoy_cmd_unix_fill_image_desc(grub_extcmd_context_t ctxt, int argc,
 
     desc = (ventoy_image_desc *)(byte + i);
     desc->disk_size = g_ventoy_disk_size;
-    desc->part1_size = ventoy_get_part1_size(g_ventoy_part_info);
+    desc->part1_size = g_ventoy_disk_part_size[0];
     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);
 

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

@@ -44,14 +44,12 @@
 
 GRUB_MOD_LICENSE ("GPLv3+");
 
-static int g_vhdboot_bcd_offset = 0;
-static int g_vhdboot_bcd_len = 0;
 static int g_vhdboot_isolen = 0;
 static char *g_vhdboot_totbuf = NULL;
 static char *g_vhdboot_isobuf = NULL;
 static grub_uint64_t g_img_trim_head_secnum = 0;
 
-static int ventoy_vhd_find_bcd(int *bcdoffset, int *bcdlen)
+static int ventoy_vhd_find_bcd(int *bcdoffset, int *bcdlen, const char *path)
 {
     grub_uint32_t offset;
     grub_file_t file;
@@ -61,10 +59,9 @@ static int ventoy_vhd_find_bcd(int *bcdoffset, int *bcdlen)
     
     grub_script_execute_sourcecode(cmdbuf);
 
-    file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", "(vhdiso)/boot/bcd");
+    file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "(vhdiso)%s", path);
     if (!file)
     {
-        grub_printf("Failed to open bcd file in the image file\n");
         return 1;
     }
 
@@ -83,13 +80,15 @@ static int ventoy_vhd_find_bcd(int *bcdoffset, int *bcdlen)
     return 0;
 }
 
-static int ventoy_vhd_patch_path(char *vhdpath, ventoy_patch_vhd *patch1, ventoy_patch_vhd *patch2)
+static int ventoy_vhd_patch_path(char *vhdpath, ventoy_patch_vhd *patch1, ventoy_patch_vhd *patch2, 
+    int bcdoffset, int bcdlen)
 {
     int i;
     int cnt = 0;
     char *pos;
     grub_size_t pathlen;
     const char *plat;
+    char *newpath = NULL;
     grub_uint16_t *unicode_path;
     const grub_uint8_t winloadexe[] = 
     {
@@ -97,6 +96,11 @@ static int ventoy_vhd_patch_path(char *vhdpath, ventoy_patch_vhd *patch1, ventoy
         0x65, 0x00, 0x78, 0x00, 0x65, 0x00 
     };
 
+    while ((*vhdpath) != '/')
+    {
+        vhdpath++;
+    }
+
     pathlen = sizeof(grub_uint16_t) * (grub_strlen(vhdpath) + 1);
     debug("unicode path for <%s> len:%d\n", vhdpath, (int)pathlen);
     
@@ -110,10 +114,10 @@ static int ventoy_vhd_patch_path(char *vhdpath, ventoy_patch_vhd *patch1, ventoy
 
     if (plat && (plat[0] == 'e')) /* UEFI */
     {
-        pos = g_vhdboot_isobuf + g_vhdboot_bcd_offset;
+        pos = g_vhdboot_isobuf + bcdoffset;
     
         /* winload.exe ==> winload.efi */
-        for (i = 0; i + (int)sizeof(winloadexe) < g_vhdboot_bcd_len; i++)
+        for (i = 0; i + (int)sizeof(winloadexe) < bcdlen; i++)
         {
             if (*((grub_uint32_t *)(pos + i)) == 0x00690077 && 
                 grub_memcmp(pos + i, winloadexe, sizeof(winloadexe)) == 0)
@@ -127,7 +131,8 @@ static int ventoy_vhd_patch_path(char *vhdpath, ventoy_patch_vhd *patch1, ventoy
         debug("winload patch %d times\n", cnt);
     }
 
-    for (pos = vhdpath; *pos; pos++)
+    newpath = grub_strdup(vhdpath);
+    for (pos = newpath; *pos; pos++)
     {
         if (*pos == '/')
         {
@@ -135,40 +140,159 @@ static int ventoy_vhd_patch_path(char *vhdpath, ventoy_patch_vhd *patch1, ventoy
         }
     }
     
-    grub_utf8_to_utf16(unicode_path, pathlen, (grub_uint8_t *)vhdpath, -1, NULL);
+    grub_utf8_to_utf16(unicode_path, pathlen, (grub_uint8_t *)newpath, -1, NULL);
     grub_memcpy(patch1->vhd_file_path, unicode_path, pathlen);
     grub_memcpy(patch2->vhd_file_path, unicode_path, pathlen);
 
+    grub_free(newpath);
     return 0;
 }
 
-static int ventoy_vhd_patch_disk(ventoy_patch_vhd *patch1, ventoy_patch_vhd *patch2)
+static int ventoy_vhd_read_parttbl(const char *filename, ventoy_gpt_info *gpt, int *index)
 {
+    int i;
+    int ret = 1;
+    grub_uint64_t start;
+    grub_file_t file = NULL;
+    grub_disk_t disk = NULL;
+    grub_uint8_t zeroguid[16] = {0};
+
+    file = grub_file_open(filename, VENTOY_FILE_TYPE);
+    if (!file)
+    {
+        goto end;
+    }
+
+    disk = grub_disk_open(file->device->disk->name);
+    if (!disk)
+    {
+        goto end;
+    }
+
+    grub_disk_read(disk, 0, 0, sizeof(ventoy_gpt_info), gpt);
+
+    start = file->device->disk->partition->start;
+
+    if (grub_memcmp(gpt->Head.Signature, "EFI PART", 8) == 0)
+    {
+        debug("GPT part start: %llu\n", (ulonglong)start);
+        for (i = 0; i < 128; i++)
+        {
+            if (grub_memcmp(gpt->PartTbl[i].PartGuid, zeroguid, 16))
+            {
+                if (start == gpt->PartTbl[i].StartLBA)
+                {
+                    *index = i;
+                    break;
+                }
+            }
+        }
+    }
+    else
+    {
+        debug("MBR part start: %llu\n", (ulonglong)start);
+        for (i = 0; i < 4; i++)
+        {
+            if ((grub_uint32_t)start == gpt->MBR.PartTbl[i].StartSectorId)
+            {
+                *index = i;
+                break;
+            }
+        }
+    }    
+
+    ret = 0;
+
+end:
+    check_free(file, grub_file_close);
+    check_free(disk, grub_disk_close);
+
+    return ret;
+}
+
+static int ventoy_vhd_patch_disk(const char *vhdpath, ventoy_patch_vhd *patch1, ventoy_patch_vhd *patch2)
+{
+    int partIndex = 0;
+    grub_uint64_t offset = 0;
     char efipart[16] = {0};
+    ventoy_gpt_info *gpt = NULL;
 
-    grub_memcpy(efipart, g_ventoy_part_info->Head.Signature, sizeof(g_ventoy_part_info->Head.Signature));
+    if (vhdpath[0] == '/')
+    {
+        gpt = g_ventoy_part_info;  
+        partIndex = 0;
+        debug("This is Ventoy ISO partIndex %d %s\n", partIndex, vhdpath);
+    }
+    else
+    {
+        gpt = grub_zalloc(sizeof(ventoy_gpt_info));
+        ventoy_vhd_read_parttbl(vhdpath, gpt, &partIndex);
+        debug("This is HDD partIndex %d %s\n", partIndex, vhdpath);
+    }
 
-    debug("part1 type: 0x%x <%s>\n", g_ventoy_part_info->MBR.PartTbl[0].FsFlag, efipart);
+    grub_memcpy(efipart, gpt->Head.Signature, sizeof(gpt->Head.Signature));
+
+    grub_memset(patch1, 0, OFFSET_OF(ventoy_patch_vhd, vhd_file_path));
+    grub_memset(patch2, 0, OFFSET_OF(ventoy_patch_vhd, vhd_file_path));
 
     if (grub_strncmp(efipart, "EFI PART", 8) == 0)
     {
-        ventoy_debug_dump_guid("GPT disk GUID: ", g_ventoy_part_info->Head.DiskGuid);
-        ventoy_debug_dump_guid("GPT part GUID: ", g_ventoy_part_info->PartTbl[0].PartGuid);
+        ventoy_debug_dump_guid("GPT disk GUID: ", gpt->Head.DiskGuid);
+        ventoy_debug_dump_guid("GPT partIndex GUID: ", gpt->PartTbl[partIndex].PartGuid);
         
-        grub_memcpy(patch1->disk_signature_or_guid, g_ventoy_part_info->Head.DiskGuid, 16);
-        grub_memcpy(patch1->part_offset_or_guid, g_ventoy_part_info->PartTbl[0].PartGuid, 16);
-        grub_memcpy(patch2->disk_signature_or_guid, g_ventoy_part_info->Head.DiskGuid, 16);
-        grub_memcpy(patch2->part_offset_or_guid, g_ventoy_part_info->PartTbl[0].PartGuid, 16);
+        grub_memcpy(patch1->disk_signature_or_guid, gpt->Head.DiskGuid, 16);
+        grub_memcpy(patch1->part_offset_or_guid, gpt->PartTbl[partIndex].PartGuid, 16);
+        grub_memcpy(patch2->disk_signature_or_guid, gpt->Head.DiskGuid, 16);
+        grub_memcpy(patch2->part_offset_or_guid, gpt->PartTbl[partIndex].PartGuid, 16);
 
         patch1->part_type = patch2->part_type = 0;
     }
     else
     {
-        debug("MBR disk signature: %02x%02x%02x%02x\n",
-            g_ventoy_part_info->MBR.BootCode[0x1b8 + 0], g_ventoy_part_info->MBR.BootCode[0x1b8 + 1],
-            g_ventoy_part_info->MBR.BootCode[0x1b8 + 2], g_ventoy_part_info->MBR.BootCode[0x1b8 + 3]);
-        grub_memcpy(patch1->disk_signature_or_guid, g_ventoy_part_info->MBR.BootCode + 0x1b8, 4);
-        grub_memcpy(patch2->disk_signature_or_guid, g_ventoy_part_info->MBR.BootCode + 0x1b8, 4);
+        offset = gpt->MBR.PartTbl[partIndex].StartSectorId;
+        offset *= 512;
+    
+        debug("MBR disk signature: %02x%02x%02x%02x Part(%d) offset:%llu\n",
+            gpt->MBR.BootCode[0x1b8 + 0], gpt->MBR.BootCode[0x1b8 + 1],
+            gpt->MBR.BootCode[0x1b8 + 2], gpt->MBR.BootCode[0x1b8 + 3],
+            partIndex + 1, offset);
+
+        grub_memcpy(patch1->part_offset_or_guid, &offset, 8);
+        grub_memcpy(patch2->part_offset_or_guid, &offset, 8);
+        
+        grub_memcpy(patch1->disk_signature_or_guid, gpt->MBR.BootCode + 0x1b8, 4);
+        grub_memcpy(patch2->disk_signature_or_guid, gpt->MBR.BootCode + 0x1b8, 4);
+
+        patch1->part_type = patch2->part_type = 1;
+    }
+
+    if (gpt != g_ventoy_part_info)
+    {
+        grub_free(gpt);
+    }
+
+    return 0;
+}
+
+static int ventoy_find_vhdpatch_offset(int bcdoffset, int bcdlen, int *offset)
+{
+    int i;
+    int cnt = 0;
+    grub_uint8_t *buf = (grub_uint8_t *)(g_vhdboot_isobuf + bcdoffset);
+    grub_uint8_t magic[16] = { 
+        0x5C, 0x00, 0x58, 0x00, 0x58, 0x00, 0x58, 0x00, 0x58, 0x00, 0x58, 0x00, 0x58, 0x00, 0x58, 0x00 
+    };
+
+    for (i = 0; i < bcdlen - 16 && cnt < 2; i++)
+    {
+        if (*(grub_uint32_t *)(buf + i) == 0x0058005C)
+        {
+            if (grub_memcmp(magic, buf + i, 16) == 0)
+            {
+                *offset++ = i - (int)OFFSET_OF(ventoy_patch_vhd, vhd_file_path); 
+                cnt++;
+            }
+        }
     }
 
     return 0;
@@ -177,6 +301,8 @@ static int ventoy_vhd_patch_disk(ventoy_patch_vhd *patch1, ventoy_patch_vhd *pat
 grub_err_t ventoy_cmd_patch_vhdboot(grub_extcmd_context_t ctxt, int argc, char **args)
 {
     int rc;
+    int bcdoffset, bcdlen;
+    int patchoffset[2];
     ventoy_patch_vhd *patch1;
     ventoy_patch_vhd *patch2;
     char envbuf[64];
@@ -194,18 +320,39 @@ grub_err_t ventoy_cmd_patch_vhdboot(grub_extcmd_context_t ctxt, int argc, char *
         return 0;
     }
 
-    rc = ventoy_vhd_find_bcd(&g_vhdboot_bcd_offset, &g_vhdboot_bcd_len);
+    rc = ventoy_vhd_find_bcd(&bcdoffset, &bcdlen, "/boot/bcd");
     if (rc)
     {
         debug("failed to get bcd location %d\n", rc);
-        return 0;
+    }
+    else
+    {
+        ventoy_find_vhdpatch_offset(bcdoffset, bcdlen, patchoffset);
+        patch1 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + bcdoffset + patchoffset[0]);
+        patch2 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + bcdoffset + patchoffset[1]);
+
+        debug("Find /boot/bcd (%d %d) now patch it (offset: 0x%x 0x%x) ...\n", 
+              bcdoffset, bcdlen, patchoffset[0], patchoffset[1]);
+        ventoy_vhd_patch_disk(args[0], patch1, patch2);
+        ventoy_vhd_patch_path(args[0], patch1, patch2, bcdoffset, bcdlen);
     }
 
-    patch1 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + g_vhdboot_bcd_offset + 0x495a);
-    patch2 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + g_vhdboot_bcd_offset + 0x50aa);
-
-    ventoy_vhd_patch_disk(patch1, patch2);
-    ventoy_vhd_patch_path(args[0], patch1, patch2);
+    rc = ventoy_vhd_find_bcd(&bcdoffset, &bcdlen, "/boot/BCD");
+    if (rc)
+    {
+        debug("No file /boot/BCD \n");
+    }
+    else
+    {
+        ventoy_find_vhdpatch_offset(bcdoffset, bcdlen, patchoffset);
+        patch1 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + bcdoffset + patchoffset[0]);
+        patch2 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + bcdoffset + patchoffset[1]);
+        
+        debug("Find /boot/BCD (%d %d) now patch it (offset: 0x%x 0x%x) ...\n", 
+              bcdoffset, bcdlen, patchoffset[0], patchoffset[1]);
+        ventoy_vhd_patch_disk(args[0], patch1, patch2);
+        ventoy_vhd_patch_path(args[0], patch1, patch2, bcdoffset, bcdlen);
+    }
 
     /* set buffer and size */
 #ifdef GRUB_MACHINE_EFI
@@ -220,7 +367,7 @@ grub_err_t ventoy_cmd_patch_vhdboot(grub_extcmd_context_t ctxt, int argc, char *
     grub_env_set("vtoy_vhd_buf_size", envbuf);
 #endif
 
-    return 0;
+    VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 }
 
 grub_err_t ventoy_cmd_load_vhdboot(grub_extcmd_context_t ctxt, int argc, char **args)
@@ -396,7 +543,7 @@ grub_err_t ventoy_cmd_get_vtoy_type(grub_extcmd_context_t ctxt, int argc, char *
     }
 
     grub_env_set(args[1], type);
-    debug("<%s> vtoy type: <%s> ", args[0], type);
+    debug("<%s> vtoy type: <%s> offset:%d\n", args[0], type, offset);
     
     if (offset >= 0)
     {
@@ -451,6 +598,14 @@ grub_err_t ventoy_cmd_get_vtoy_type(grub_extcmd_context_t ctxt, int argc, char *
                         altboot = 1;
                         grub_env_set(args[3], "1");                        
                     }
+                    else
+                    {
+                        debug("offset data=0x%x\n", data);
+                    }
+                }
+                else
+                {
+                    debug("BootCode: 0x%x\n", gpt->MBR.BootCode[92]);
                 }
             }
         }

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

@@ -314,6 +314,90 @@ static int ventoy_is_pe64(grub_uint8_t *buffer)
     return 0;
 }
 
+grub_err_t ventoy_cmd_is_pe64(grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    int ret = 1;
+    grub_file_t file;
+    grub_uint8_t buf[512];
+    
+    (void)ctxt;
+    (void)argc;
+
+    file = grub_file_open(args[0], VENTOY_FILE_TYPE);
+    if (!file)
+    {
+        return 1;
+    }
+
+    grub_memset(buf, 0, 512);
+    grub_file_read(file, buf, 512);
+    if (ventoy_is_pe64(buf))
+    {
+        debug("%s is PE64\n", args[0]);
+        ret = 0;
+    }
+    else
+    {
+        debug("%s is PE32\n", args[0]);
+    }
+    grub_file_close(file);
+
+    return ret;
+}
+
+grub_err_t ventoy_cmd_sel_wimboot(grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    int size;
+    char *buf = NULL;
+    char configfile[128];
+    
+    (void)ctxt;
+    (void)argc;
+    (void)args;
+
+    debug("select wimboot argc:%d\n", argc);
+
+    buf = (char *)grub_malloc(8192);
+    if (!buf)
+    {
+        return 0;
+    }
+
+    size = (int)grub_snprintf(buf, 8192, 
+        "menuentry \"Windows Setup (32-bit)\" {\n"
+        "    set vtoy_wimboot_sel=32\n"
+        "}\n"
+        "menuentry \"Windows Setup (64-bit)\" {\n"
+        "    set vtoy_wimboot_sel=64\n"
+        "}\n"
+        );
+    buf[size] = 0;
+
+    g_ventoy_menu_esc = 1;
+    g_ventoy_suppress_esc = 1;
+
+    grub_snprintf(configfile, sizeof(configfile), "configfile mem:0x%llx:size:%d", (ulonglong)(ulong)buf, size);
+    grub_script_execute_sourcecode(configfile);
+    
+    g_ventoy_menu_esc = 0;
+    g_ventoy_suppress_esc = 0;
+
+    grub_free(buf);
+
+    if (g_ventoy_last_entry == 0)
+    {
+        debug("last entry=%d %s=32\n", g_ventoy_last_entry, args[0]);
+        grub_env_set(args[0], "32");
+    }
+    else
+    {
+        debug("last entry=%d %s=64\n", g_ventoy_last_entry, args[0]);
+        grub_env_set(args[0], "64");
+    }
+
+    VENTOY_CMD_RETURN(GRUB_ERR_NONE);
+}
+
 grub_err_t ventoy_cmd_wimdows_reset(grub_extcmd_context_t ctxt, int argc, char **args)
 {
     wim_patch *next = NULL;
@@ -636,6 +720,21 @@ static wim_lookup_entry * ventoy_find_meta_entry(wim_header *header, wim_lookup_
     return NULL;
 }
 
+static grub_uint64_t ventoy_get_stream_len(wim_directory_entry *dir)
+{
+    grub_uint16_t i;
+    grub_uint64_t offset = 0;
+    wim_stream_entry *stream = (wim_stream_entry *)((char *)dir + dir->len);
+
+    for (i = 0; i < dir->streams; i++)
+    {
+        offset += stream->len;
+        stream = (wim_stream_entry *)((char *)stream + stream->len);
+    }
+
+    return offset;
+}
+
 static int ventoy_update_all_hash(wim_patch *patch, void *meta_data, wim_directory_entry *dir)
 {
     if ((meta_data == NULL) || (dir == NULL))
@@ -660,8 +759,15 @@ static int ventoy_update_all_hash(wim_patch *patch, void *meta_data, wim_directo
         {
             ventoy_update_all_hash(patch, meta_data, (wim_directory_entry *)((char *)meta_data + dir->subdir));
         }
-    
-        dir = (wim_directory_entry *)((char *)dir + dir->len);
+
+        if (dir->streams)
+        {
+            dir = (wim_directory_entry *)((char *)dir + dir->len + ventoy_get_stream_len(dir));
+        }
+        else
+        {
+            dir = (wim_directory_entry *)((char *)dir + dir->len);            
+        }
     } while (dir->len >= sizeof(wim_directory_entry));
 
     return 0;
@@ -860,7 +966,14 @@ static int ventoy_wimdows_locate_wim(const char *disk, wim_patch *patch)
     }
 
     security = (wim_security_header *)decompress_data;
-    rootdir = (wim_directory_entry *)(decompress_data + ((security->len + 7) & 0xFFFFFFF8U));
+    if (security->len > 0)
+    {
+        rootdir = (wim_directory_entry *)(decompress_data + ((security->len + 7) & 0xFFFFFFF8U));
+    }
+    else
+    {
+        rootdir = (wim_directory_entry *)(decompress_data + 8);
+    }
 
     /* search winpeshl.exe dirent entry */
     search = search_replace_wim_dirent(decompress_data, rootdir);
@@ -1301,6 +1414,54 @@ end:
     return rc;
 }
 
+grub_err_t ventoy_cmd_windows_wimboot_data(grub_extcmd_context_t ctxt, int argc, char **args)
+{
+    grub_uint32_t size = 0;
+    const char *addr = NULL;
+    ventoy_chain_head *chain = NULL;
+    ventoy_os_param *param = NULL;
+    char envbuf[64];
+
+    (void)ctxt;
+    (void)argc;
+    (void)args;
+
+    addr = grub_env_get("vtoy_chain_mem_addr");
+    if (!addr)
+    {
+        debug("Failed to find vtoy_chain_mem_addr\n");
+        return 1;
+    }
+
+    chain = (ventoy_chain_head *)(void *)grub_strtoul(addr, NULL, 16);
+
+    if (grub_memcmp(&g_ventoy_guid, &chain->os_param.guid, 16) != 0)
+    {
+        debug("os_param.guid not match\n");
+        return 1;
+    }
+
+    size = sizeof(ventoy_os_param) + sizeof(ventoy_windows_data);
+    param = (ventoy_os_param *)grub_zalloc(size);
+    if (!param)
+    {
+        return 1;
+    }
+
+    grub_memcpy(param, &chain->os_param, sizeof(ventoy_os_param));
+    ventoy_fill_windows_rtdata(param + 1, param->vtoy_img_path);
+
+    grub_snprintf(envbuf, sizeof(envbuf), "0x%lx", (unsigned long)param);
+    grub_env_set("vtoy_wimboot_mem_addr", envbuf);
+    debug("vtoy_wimboot_mem_addr: %s\n", envbuf);
+    
+    grub_snprintf(envbuf, sizeof(envbuf), "%u", size);
+    grub_env_set("vtoy_wimboot_mem_size", envbuf);
+    debug("vtoy_wimboot_mem_size: %s\n", envbuf);
+    
+    VENTOY_CMD_RETURN(GRUB_ERR_NONE);
+}
+
 grub_err_t ventoy_cmd_windows_chain_data(grub_extcmd_context_t ctxt, int argc, char **args)
 {
     int unknown_image = 0;
@@ -1733,3 +1894,29 @@ grub_err_t ventoy_cmd_wim_chain_data(grub_extcmd_context_t ctxt, int argc, char
     VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 }
 
+int ventoy_chain_file_size(const char *path)
+{
+    int size;
+    grub_file_t file;
+
+    file = grub_file_open(path, VENTOY_FILE_TYPE);
+    size = (int)(file->size);
+
+    grub_file_close(file);
+    
+    return size;
+}
+
+int ventoy_chain_file_read(const char *path, int offset, int len, void *buf)
+{
+    int size;
+    grub_file_t file;
+
+    file = grub_file_open(path, VENTOY_FILE_TYPE);
+    grub_file_seek(file, offset);
+    size = grub_file_read(file, buf, len);
+    grub_file_close(file);
+    
+    return size;
+}
+

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

@@ -87,6 +87,7 @@ EXPORT_FUNC (grub_efi_compare_device_paths) (const grub_efi_device_path_t *dp1,
 					     const grub_efi_device_path_t *dp2);
 
 void * EXPORT_FUNC (grub_efi_allocate_iso_buf) (grub_uint64_t size);
+void * EXPORT_FUNC (grub_efi_allocate_chain_buf) (grub_uint64_t size);
 
 
 extern void (*EXPORT_VAR(grub_efi_net_config)) (grub_efi_handle_t hnd, 

GRUB2/MOD_SRC/grub-2.04/install.sh

@@ -12,14 +12,14 @@ make install
 PATH=$PATH:$VT_DIR/GRUB2/INSTALL/bin/:$VT_DIR/GRUB2/INSTALL/sbin/
 
 net_modules_legacy="net tftp http"
-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"
+all_modules_legacy="file 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="setkey blocklist ventoy test true 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_uefi="file setkey blocklist ventoy test true 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 true 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"
+all_modules_arm64_uefi="file setkey blocklist ventoy test true 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"
 
-all_modules_mips64el_uefi="setkey blocklist ventoy test true 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"
+all_modules_mips64el_uefi="file setkey blocklist ventoy test true 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

GRUB2/MOD_SRC/grub-2.04/util/setup.c

@@ -0,0 +1,878 @@
+/* grub-setup.c - make GRUB usable */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+#include <grub/types.h>
+#include <grub/emu/misc.h>
+#include <grub/util/misc.h>
+#include <grub/device.h>
+#include <grub/disk.h>
+#include <grub/file.h>
+#include <grub/fs.h>
+#include <grub/partition.h>
+#include <grub/env.h>
+#include <grub/emu/hostdisk.h>
+#include <grub/term.h>
+#include <grub/i18n.h>
+
+#ifdef GRUB_SETUP_SPARC64
+#include <grub/util/ofpath.h>
+#include <grub/sparc64/ieee1275/boot.h>
+#include <grub/sparc64/ieee1275/kernel.h>
+#else
+#include <grub/i386/pc/boot.h>
+#include <grub/i386/pc/kernel.h>
+#endif
+
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <assert.h>
+#include <grub/emu/getroot.h>
+#include "progname.h"
+#include <grub/reed_solomon.h>
+#include <grub/msdos_partition.h>
+#include <grub/crypto.h>
+#include <grub/util/install.h>
+#include <grub/emu/hostfile.h>
+
+#include <errno.h>
+
+/* On SPARC this program fills in various fields inside of the 'boot' and 'core'
+ * image files.
+ *
+ * The 'boot' image needs to know the OBP path name of the root
+ * device.  It also needs to know the initial block number of
+ * 'core' (which is 'diskboot' concatenated with 'kernel' and
+ * all the modules, this is created by grub-mkimage).  This resulting
+ * 'boot' image is 512 bytes in size and is placed in the second block
+ * of a partition.
+ *
+ * The initial 'diskboot' block acts as a loader for the actual GRUB
+ * kernel.  It contains the loading code and then a block list.
+ *
+ * The block list of 'core' starts at the end of the 'diskboot' image
+ * and works it's way backwards towards the end of the code of 'diskboot'.
+ *
+ * We patch up the images with the necessary values and write out the
+ * result.
+ */
+
+#ifdef GRUB_SETUP_SPARC64
+#define grub_target_to_host16(x)	grub_be_to_cpu16(x)
+#define grub_target_to_host32(x)	grub_be_to_cpu32(x)
+#define grub_target_to_host64(x)	grub_be_to_cpu64(x)
+#define grub_host_to_target16(x)	grub_cpu_to_be16(x)
+#define grub_host_to_target32(x)	grub_cpu_to_be32(x)
+#define grub_host_to_target64(x)	grub_cpu_to_be64(x)
+#elif defined (GRUB_SETUP_BIOS)
+#define grub_target_to_host16(x)	grub_le_to_cpu16(x)
+#define grub_target_to_host32(x)	grub_le_to_cpu32(x)
+#define grub_target_to_host64(x)	grub_le_to_cpu64(x)
+#define grub_host_to_target16(x)	grub_cpu_to_le16(x)
+#define grub_host_to_target32(x)	grub_cpu_to_le32(x)
+#define grub_host_to_target64(x)	grub_cpu_to_le64(x)
+#else
+#error Complete this
+#endif
+
+static void
+write_rootdev (grub_device_t root_dev,
+	       char *boot_img, grub_uint64_t first_sector)
+{
+#ifdef GRUB_SETUP_BIOS
+  {
+    grub_uint8_t *boot_drive;
+    void *kernel_sector;
+    boot_drive = (grub_uint8_t *) (boot_img + GRUB_BOOT_MACHINE_BOOT_DRIVE);
+    kernel_sector = (boot_img + GRUB_BOOT_MACHINE_KERNEL_SECTOR);
+
+    /* FIXME: can this be skipped?  */
+    *boot_drive = 0xFF;
+
+    grub_set_unaligned64 (kernel_sector, grub_cpu_to_le64 (first_sector));
+  }
+#endif
+#ifdef GRUB_SETUP_SPARC64
+  {
+    void *kernel_byte;
+    kernel_byte = (boot_img + GRUB_BOOT_AOUT_HEADER_SIZE
+		   + GRUB_BOOT_MACHINE_KERNEL_BYTE);
+    grub_set_unaligned64 (kernel_byte,
+			  grub_cpu_to_be64 (first_sector << GRUB_DISK_SECTOR_BITS));
+  }
+#endif
+}
+
+#ifdef GRUB_SETUP_SPARC64
+#define BOOT_SECTOR 1
+#else
+#define BOOT_SECTOR 0
+#endif
+
+/* Helper for setup.  */
+
+struct blocklists
+{
+  struct grub_boot_blocklist *first_block, *block;
+#ifdef GRUB_SETUP_BIOS
+  grub_uint16_t current_segment;
+#endif
+#ifdef GRUB_SETUP_SPARC64
+  grub_uint64_t gpt_offset;
+#endif
+  grub_uint16_t last_length;
+  grub_disk_addr_t first_sector;
+};
+
+/* Helper for setup.  */
+static void
+save_blocklists (grub_disk_addr_t sector, unsigned offset, unsigned length,
+		 void *data)
+{
+  struct blocklists *bl = data;
+  struct grub_boot_blocklist *prev = bl->block + 1;
+  grub_uint64_t seclen;
+
+#ifdef GRUB_SETUP_SPARC64
+  sector -= bl->gpt_offset;
+#endif
+
+  grub_util_info ("saving <%"  GRUB_HOST_PRIuLONG_LONG ",%u,%u>",
+		  (unsigned long long) sector, offset, length);
+
+  if (bl->first_sector == (grub_disk_addr_t) -1)
+    {
+      if (offset != 0 || length < GRUB_DISK_SECTOR_SIZE)
+	grub_util_error ("%s", _("the first sector of the core file is not sector-aligned"));
+
+      bl->first_sector = sector;
+      sector++;
+      length -= GRUB_DISK_SECTOR_SIZE;
+      if (!length)
+	return;
+    }
+
+  if (offset != 0 || bl->last_length != 0)
+    grub_util_error ("%s", _("non-sector-aligned data is found in the core file"));
+
+  seclen = (length + GRUB_DISK_SECTOR_SIZE - 1) >> GRUB_DISK_SECTOR_BITS;
+
+  if (bl->block != bl->first_block
+      && (grub_target_to_host64 (prev->start)
+	  + grub_target_to_host16 (prev->len)) == sector)
+    {
+      grub_uint16_t t = grub_target_to_host16 (prev->len);
+      t += seclen;
+      prev->len = grub_host_to_target16 (t);
+    }
+  else
+    {
+      bl->block->start = grub_host_to_target64 (sector);
+      bl->block->len = grub_host_to_target16 (seclen);
+#ifdef GRUB_SETUP_BIOS
+      bl->block->segment = grub_host_to_target16 (bl->current_segment);
+#endif
+
+      bl->block--;
+      if (bl->block->len)
+	grub_util_error ("%s", _("the sectors of the core file are too fragmented"));
+    }
+
+  bl->last_length = length & (GRUB_DISK_SECTOR_SIZE - 1);
+#ifdef GRUB_SETUP_BIOS
+  bl->current_segment += seclen << (GRUB_DISK_SECTOR_BITS - 4);
+#endif
+}
+
+/* Context for setup/identify_partmap.  */
+struct identify_partmap_ctx
+{
+  grub_partition_map_t dest_partmap;
+  grub_partition_t container;
+  int multiple_partmaps;
+};
+
+/* Helper for setup.
+   Unlike root_dev, with dest_dev we're interested in the partition map even
+   if dest_dev itself is a whole disk.  */
+static int
+identify_partmap (grub_disk_t disk __attribute__ ((unused)),
+		  const grub_partition_t p, void *data)
+{
+  struct identify_partmap_ctx *ctx = data;
+
+  if (p->parent != ctx->container)
+    return 0;
+  /* NetBSD and OpenBSD subpartitions have metadata inside a partition,
+     so they are safe to ignore.
+   */
+  if (grub_strcmp (p->partmap->name, "netbsd") == 0
+      || grub_strcmp (p->partmap->name, "openbsd") == 0)
+    return 0;
+  if (ctx->dest_partmap == NULL)
+    {
+      ctx->dest_partmap = p->partmap;
+      return 0;
+    }
+  if (ctx->dest_partmap == p->partmap)
+    return 0;
+  ctx->multiple_partmaps = 1;
+  return 1;
+}
+
+#ifdef GRUB_SETUP_BIOS
+#define SETUP grub_util_bios_setup
+#elif GRUB_SETUP_SPARC64
+#define SETUP grub_util_sparc_setup
+#else
+#error "Shouldn't happen"
+#endif
+
+void
+SETUP (const char *dir,
+       const char *boot_file, const char *core_file,
+       const char *dest, int force,
+       int fs_probe, int allow_floppy,
+       int add_rs_codes __attribute__ ((unused))) /* unused on sparc64 */
+{
+  char *core_path;
+  char *boot_img, *core_img, *boot_path;
+  char *root = 0;
+  size_t boot_size, core_size;
+  grub_uint16_t core_sectors;
+  grub_device_t root_dev = 0, dest_dev, core_dev;
+  grub_util_fd_t fp;
+  struct blocklists bl;
+
+  bl.first_sector = (grub_disk_addr_t) -1;
+
+#ifdef GRUB_SETUP_BIOS
+  bl.current_segment =
+    GRUB_BOOT_I386_PC_KERNEL_SEG + (GRUB_DISK_SECTOR_SIZE >> 4);
+#endif
+  bl.last_length = 0;
+
+  /* Read the boot image by the OS service.  */
+  boot_path = grub_util_get_path (dir, boot_file);
+  boot_size = grub_util_get_image_size (boot_path);
+  if (boot_size != GRUB_DISK_SECTOR_SIZE)
+    grub_util_error (_("the size of `%s' is not %u"),
+		     boot_path, GRUB_DISK_SECTOR_SIZE);
+  boot_img = grub_util_read_image (boot_path);
+  free (boot_path);
+
+  core_path = grub_util_get_path (dir, core_file);
+  core_size = grub_util_get_image_size (core_path);
+  core_sectors = ((core_size + GRUB_DISK_SECTOR_SIZE - 1)
+		  >> GRUB_DISK_SECTOR_BITS);
+  if (core_size < GRUB_DISK_SECTOR_SIZE)
+    grub_util_error (_("the size of `%s' is too small"), core_path);
+#ifdef GRUB_SETUP_BIOS
+  if (core_size > 0xFFFF * GRUB_DISK_SECTOR_SIZE)
+    grub_util_error (_("the size of `%s' is too large"), core_path);
+#endif
+
+  core_img = grub_util_read_image (core_path);
+
+  /* Have FIRST_BLOCK to point to the first blocklist.  */
+  bl.first_block = (struct grub_boot_blocklist *) (core_img
+						   + GRUB_DISK_SECTOR_SIZE
+						   - sizeof (*bl.block));
+
+  grub_util_info ("Opening dest `%s'", dest);
+  dest_dev = grub_device_open (dest);
+  if (! dest_dev)
+    grub_util_error ("%s", grub_errmsg);
+
+  core_dev = dest_dev;
+
+  {
+    char **root_devices = grub_guess_root_devices (dir);
+    char **cur;
+    int found = 0;
+
+    if (!root_devices)
+      grub_util_error (_("cannot find a device for %s (is /dev mounted?)"), dir);
+
+    for (cur = root_devices; *cur; cur++)
+      {
+	char *drive;
+	grub_device_t try_dev;
+
+	drive = grub_util_get_grub_dev (*cur);
+	if (!drive)
+	  continue;
+	try_dev = grub_device_open (drive);
+	if (! try_dev)
+	  {
+	    free (drive);
+	    continue;
+	  }
+	if (!found && try_dev->disk->id == dest_dev->disk->id
+	    && try_dev->disk->dev->id == dest_dev->disk->dev->id)
+	  {
+	    if (root_dev)
+	      grub_device_close (root_dev);
+	    free (root);
+	    root_dev = try_dev;
+	    root = drive;
+	    found = 1;
+	    continue;
+	  }
+	if (!root_dev)
+	  {
+	    root_dev = try_dev;
+	    root = drive;
+	    continue;
+	  }
+	grub_device_close (try_dev);	
+	free (drive);
+      }
+    if (!root_dev)
+      {
+        root = grub_util_get_grub_dev ("/dev/sda");
+        root_dev = grub_device_open (root);
+        if (root_dev)
+	        grub_util_info ("guessing the root device failed, because of `%s'", grub_errmsg);
+	    else
+    	    grub_util_error ("guessing the root device failed, because of `%s'", grub_errmsg);
+      }
+    grub_util_info ("guessed root_dev `%s' from "
+		    "dir `%s'", root_dev->disk->name, dir);
+
+    for (cur = root_devices; *cur; cur++)
+      free (*cur);
+    free (root_devices);
+  }
+
+  grub_util_info ("setting the root device to `%s'", root);
+  if (grub_env_set ("root", root) != GRUB_ERR_NONE)
+    grub_util_error ("%s", grub_errmsg);
+
+  {
+#ifdef GRUB_SETUP_BIOS
+    char *tmp_img;
+    grub_uint8_t *boot_drive_check;
+
+    /* Read the original sector from the disk.  */
+    tmp_img = xmalloc (GRUB_DISK_SECTOR_SIZE);
+    if (grub_disk_read (dest_dev->disk, 0, 0, GRUB_DISK_SECTOR_SIZE, tmp_img))
+      grub_util_error ("%s", grub_errmsg);
+    
+    boot_drive_check = (grub_uint8_t *) (boot_img
+					  + GRUB_BOOT_MACHINE_DRIVE_CHECK);
+    /* Copy the possible DOS BPB.  */
+    memcpy (boot_img + GRUB_BOOT_MACHINE_BPB_START,
+	    tmp_img + GRUB_BOOT_MACHINE_BPB_START,
+	    GRUB_BOOT_MACHINE_BPB_END - GRUB_BOOT_MACHINE_BPB_START);
+
+    /* If DEST_DRIVE is a hard disk, enable the workaround, which is
+       for buggy BIOSes which don't pass boot drive correctly. Instead,
+       they pass 0x00 or 0x01 even when booted from 0x80.  */
+    if (!allow_floppy && !grub_util_biosdisk_is_floppy (dest_dev->disk))
+      {
+	/* Replace the jmp (2 bytes) with double nop's.  */
+	boot_drive_check[0] = 0x90;
+	boot_drive_check[1] = 0x90;
+      }
+#endif
+
+    struct identify_partmap_ctx ctx = {
+      .dest_partmap = NULL,
+      .container = dest_dev->disk->partition,
+      .multiple_partmaps = 0
+    };
+    int is_ldm;
+    grub_err_t err;
+    grub_disk_addr_t *sectors;
+    int i;
+    grub_fs_t fs;
+    unsigned int nsec, maxsec;
+
+    grub_partition_iterate (dest_dev->disk, identify_partmap, &ctx);
+
+#ifdef GRUB_SETUP_BIOS
+    /* Copy the partition table.  */
+    if (ctx.dest_partmap ||
+        (!allow_floppy && !grub_util_biosdisk_is_floppy (dest_dev->disk)))
+      memcpy (boot_img + GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC,
+	      tmp_img + GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC,
+	      GRUB_BOOT_MACHINE_PART_END - GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC);
+
+    free (tmp_img);
+#endif
+
+    if (ctx.container
+	&& grub_strcmp (ctx.container->partmap->name, "msdos") == 0
+	&& ctx.dest_partmap
+	&& (ctx.container->msdostype == GRUB_PC_PARTITION_TYPE_NETBSD
+	    || ctx.container->msdostype == GRUB_PC_PARTITION_TYPE_OPENBSD))
+      {
+	grub_util_warn ("%s", _("Attempting to install GRUB to a disk with multiple partition labels or both partition label and filesystem.  This is not supported yet."));
+	goto unable_to_embed;
+      }
+
+    fs = grub_fs_probe (dest_dev);
+    if (!fs)
+      grub_errno = GRUB_ERR_NONE;
+
+    is_ldm = grub_util_is_ldm (dest_dev->disk);
+
+    if (fs_probe)
+      {
+	if (!fs && !ctx.dest_partmap)
+	  grub_util_error (_("unable to identify a filesystem in %s; safety check can't be performed"),
+			   dest_dev->disk->name);
+	if (fs && !fs->reserved_first_sector)
+	  /* TRANSLATORS: Filesystem may reserve the space just GRUB isn't sure about it.  */
+	  grub_util_error (_("%s appears to contain a %s filesystem which isn't known to "
+			     "reserve space for DOS-style boot.  Installing GRUB there could "
+			     "result in FILESYSTEM DESTRUCTION if valuable data is overwritten "
+			     "by grub-setup (--skip-fs-probe disables this "
+			     "check, use at your own risk)"), dest_dev->disk->name, fs->name);
+
+	if (ctx.dest_partmap && strcmp (ctx.dest_partmap->name, "msdos") != 0
+	    && strcmp (ctx.dest_partmap->name, "gpt") != 0
+	    && strcmp (ctx.dest_partmap->name, "bsd") != 0
+	    && strcmp (ctx.dest_partmap->name, "netbsd") != 0
+	    && strcmp (ctx.dest_partmap->name, "openbsd") != 0
+	    && strcmp (ctx.dest_partmap->name, "sunpc") != 0)
+	  /* TRANSLATORS: Partition map may reserve the space just GRUB isn't sure about it.  */
+	  grub_util_error (_("%s appears to contain a %s partition map which isn't known to "
+			     "reserve space for DOS-style boot.  Installing GRUB there could "
+			     "result in FILESYSTEM DESTRUCTION if valuable data is overwritten "
+			     "by grub-setup (--skip-fs-probe disables this "
+			     "check, use at your own risk)"), dest_dev->disk->name, ctx.dest_partmap->name);
+	if (is_ldm && ctx.dest_partmap && strcmp (ctx.dest_partmap->name, "msdos") != 0
+	    && strcmp (ctx.dest_partmap->name, "gpt") != 0)
+	  grub_util_error (_("%s appears to contain a %s partition map and "
+			     "LDM which isn't known to be a safe combination."
+			     "  Installing GRUB there could "
+			     "result in FILESYSTEM DESTRUCTION if valuable data"
+			     " is overwritten "
+			     "by grub-setup (--skip-fs-probe disables this "
+			     "check, use at your own risk)"),
+			   dest_dev->disk->name, ctx.dest_partmap->name);
+
+      }
+
+    if (! ctx.dest_partmap && ! fs && !is_ldm)
+      {
+	grub_util_warn ("%s", _("Attempting to install GRUB to a partitionless disk or to a partition.  This is a BAD idea."));
+	goto unable_to_embed;
+      }
+    if (ctx.multiple_partmaps || (ctx.dest_partmap && fs) || (is_ldm && fs))
+      {
+	grub_util_warn ("%s", _("Attempting to install GRUB to a disk with multiple partition labels.  This is not supported yet."));
+	goto unable_to_embed;
+      }
+
+    if (ctx.dest_partmap && !ctx.dest_partmap->embed)
+      {
+	grub_util_warn (_("Partition style `%s' doesn't support embedding"),
+			ctx.dest_partmap->name);
+	goto unable_to_embed;
+      }
+
+    if (fs && !fs->fs_embed)
+      {
+	grub_util_warn (_("File system `%s' doesn't support embedding"),
+			fs->name);
+	goto unable_to_embed;
+      }
+
+    nsec = core_sectors;
+
+    if (add_rs_codes)
+      maxsec = 2 * core_sectors;
+    else
+      maxsec = core_sectors;
+
+#ifdef GRUB_SETUP_BIOS
+    if (maxsec > ((0x78000 - GRUB_KERNEL_I386_PC_LINK_ADDR)
+		>> GRUB_DISK_SECTOR_BITS))
+      maxsec = ((0x78000 - GRUB_KERNEL_I386_PC_LINK_ADDR)
+		>> GRUB_DISK_SECTOR_BITS);
+#endif
+
+#ifdef GRUB_SETUP_SPARC64
+    /*
+     * On SPARC we need two extra. One is because we are combining the
+     * core.img with the boot.img. The other is because the boot sector
+     * starts at 1.
+     */
+    nsec += 2;
+    maxsec += 2;
+#endif
+
+    if (is_ldm)
+      err = grub_util_ldm_embed (dest_dev->disk, &nsec, maxsec,
+				 GRUB_EMBED_PCBIOS, &sectors);
+    else if (ctx.dest_partmap)
+      err = ctx.dest_partmap->embed (dest_dev->disk, &nsec, maxsec,
+				     GRUB_EMBED_PCBIOS, &sectors);
+    else
+      err = fs->fs_embed (dest_dev, &nsec, maxsec,
+			  GRUB_EMBED_PCBIOS, &sectors);
+    if (!err && nsec < core_sectors)
+      {
+	err = grub_error (GRUB_ERR_OUT_OF_RANGE,
+			  N_("Your embedding area is unusually small.  "
+			     "core.img won't fit in it."));
+      }
+    
+    if (err)
+      {
+	grub_util_warn ("%s", grub_errmsg);
+	grub_errno = GRUB_ERR_NONE;
+	goto unable_to_embed;
+      }
+
+    assert (nsec <= maxsec);
+
+    /* Clean out the blocklists.  */
+    bl.block = bl.first_block;
+    while (bl.block->len)
+      {
+	grub_memset (bl.block, 0, sizeof (*bl.block));
+      
+	bl.block--;
+
+	if ((char *) bl.block <= core_img)
+	  grub_util_error ("%s", _("no terminator in the core image"));
+      }
+
+    bl.block = bl.first_block;
+    for (i = 0; i < nsec; i++)
+      save_blocklists (sectors[i] + grub_partition_get_start (ctx.container),
+		       0, GRUB_DISK_SECTOR_SIZE, &bl);
+
+    /* Make sure that the last blocklist is a terminator.  */
+    if (bl.block == bl.first_block)
+      bl.block--;
+    bl.block->start = 0;
+    bl.block->len = 0;
+#ifdef GRUB_SETUP_BIOS
+    bl.block->segment = 0;
+#endif
+
+#ifdef GRUB_SETUP_SPARC64
+    {
+      /*
+       * On SPARC, the block-list entries need to be based off the beginning
+       * of the parition, not the beginning of the disk.
+       */
+      struct grub_boot_blocklist *block;
+      block = bl.first_block;
+
+      while (block->len)
+        {
+          block->start -= bl.first_sector;
+          block--;
+        }
+    }
+
+    /*
+     * Reserve space for the boot block since it can not be in the
+     * Parition table on SPARC.
+     */
+    assert (bl.first_block->len > 2);
+    bl.first_block->start += 2;
+    bl.first_block->len -= 2;
+    write_rootdev (root_dev, boot_img, sectors[BOOT_SECTOR + 1] - bl.first_sector);
+#endif
+
+#ifdef GRUB_SETUP_BIOS
+    write_rootdev (root_dev, boot_img, bl.first_sector);
+#endif
+
+    /* Round up to the nearest sector boundary, and zero the extra memory */
+    core_img = xrealloc (core_img, nsec * GRUB_DISK_SECTOR_SIZE);
+    assert (core_img && (nsec * GRUB_DISK_SECTOR_SIZE >= core_size));
+    memset (core_img + core_size, 0, nsec * GRUB_DISK_SECTOR_SIZE - core_size);
+
+    bl.first_block = (struct grub_boot_blocklist *) (core_img
+						     + GRUB_DISK_SECTOR_SIZE
+						     - sizeof (*bl.block));
+#if GRUB_SETUP_BIOS
+    grub_size_t no_rs_length;
+    no_rs_length = grub_target_to_host16 
+      (grub_get_unaligned16 (core_img
+			     + GRUB_DISK_SECTOR_SIZE
+			     + GRUB_KERNEL_I386_PC_NO_REED_SOLOMON_LENGTH));
+
+    if (no_rs_length == 0xffff)
+      grub_util_error ("%s", _("core.img version mismatch"));
+
+    if (add_rs_codes)
+      {
+	grub_set_unaligned32 ((core_img + GRUB_DISK_SECTOR_SIZE
+			       + GRUB_KERNEL_I386_PC_REED_SOLOMON_REDUNDANCY),
+			      grub_host_to_target32 (nsec * GRUB_DISK_SECTOR_SIZE - core_size));
+
+	void *tmp = xmalloc (core_size);
+	grub_memcpy (tmp, core_img, core_size);
+	grub_reed_solomon_add_redundancy (core_img + no_rs_length + GRUB_DISK_SECTOR_SIZE,
+					  core_size - no_rs_length - GRUB_DISK_SECTOR_SIZE,
+					  nsec * GRUB_DISK_SECTOR_SIZE
+					  - core_size);
+	assert (grub_memcmp (tmp, core_img, core_size) == 0);
+	free (tmp);
+      }
+
+    /* Write the core image onto the disk.  */
+    for (i = 0; i < nsec; i++)
+      grub_disk_write (dest_dev->disk, sectors[i], 0,
+		       GRUB_DISK_SECTOR_SIZE,
+		       core_img + i * GRUB_DISK_SECTOR_SIZE);
+#endif
+
+#ifdef GRUB_SETUP_SPARC64
+    {
+      int isec = BOOT_SECTOR;
+
+      /* Write the boot image onto the disk. */
+      if (grub_disk_write (dest_dev->disk, sectors[isec++], 0,
+                           GRUB_DISK_SECTOR_SIZE, boot_img))
+        grub_util_error ("%s", grub_errmsg);
+
+      /* Write the core image onto the disk. */
+      for (i = 0 ; isec < nsec; i++, isec++)
+        {
+          if (grub_disk_write (dest_dev->disk, sectors[isec], 0,
+                               GRUB_DISK_SECTOR_SIZE,
+                               core_img  + i * GRUB_DISK_SECTOR_SIZE))
+            grub_util_error ("%s", grub_errmsg);
+        }
+    }
+
+#endif
+    grub_free (sectors);
+
+    goto finish;
+  }
+
+unable_to_embed:
+
+  if (dest_dev->disk->dev->id != root_dev->disk->dev->id)
+    grub_util_error ("%s", _("embedding is not possible, but this is required for "
+			     "RAID and LVM install"));
+
+  {
+    grub_fs_t fs;
+    fs = grub_fs_probe (root_dev);
+    if (!fs)
+      grub_util_error (_("can't determine filesystem on %s"), root);
+
+    if (!fs->blocklist_install)
+      grub_util_error (_("filesystem `%s' doesn't support blocklists"),
+		       fs->name);
+  }
+
+#ifdef GRUB_SETUP_BIOS
+  if (dest_dev->disk->id != root_dev->disk->id
+      || dest_dev->disk->dev->id != root_dev->disk->dev->id)
+    /* TRANSLATORS: cross-disk refers to /boot being on one disk
+       but MBR on another.  */
+    grub_util_error ("%s", _("embedding is not possible, but this is required for "
+			     "cross-disk install"));
+#else
+  core_dev = root_dev;
+#endif
+
+  grub_util_warn ("%s", _("Embedding is not possible.  GRUB can only be installed in this "
+			  "setup by using blocklists.  However, blocklists are UNRELIABLE and "
+			  "their use is discouraged."));
+  if (! force)
+    /* TRANSLATORS: Here GRUB refuses to continue with blocklist install.  */
+    grub_util_error ("%s", _("will not proceed with blocklists"));
+
+  /* The core image must be put on a filesystem unfortunately.  */
+  grub_util_info ("will leave the core image on the filesystem");
+
+  grub_util_biosdisk_flush (root_dev->disk);
+
+  /* Clean out the blocklists.  */
+  bl.block = bl.first_block;
+  while (bl.block->len)
+    {
+      bl.block->start = 0;
+      bl.block->len = 0;
+#ifdef GRUB_SETUP_BIOS
+      bl.block->segment = 0;
+#endif
+
+      bl.block--;
+
+      if ((char *) bl.block <= core_img)
+	grub_util_error ("%s", _("no terminator in the core image"));
+    }
+
+  bl.block = bl.first_block;
+
+#ifdef GRUB_SETUP_SPARC64
+  {
+    grub_partition_t container = root_dev->disk->partition;
+    bl.gpt_offset = 0;
+
+    if (grub_strstr (container->partmap->name, "gpt"))
+      bl.gpt_offset = grub_partition_get_start (container);
+  }
+#endif
+
+  grub_install_get_blocklist (root_dev, core_path, core_img, core_size,
+			      save_blocklists, &bl);
+
+  if (bl.first_sector == (grub_disk_addr_t)-1)
+    grub_util_error ("%s", _("can't retrieve blocklists"));
+
+#ifdef GRUB_SETUP_SPARC64
+  {
+    char *boot_devpath;
+    boot_devpath = (char *) (boot_img
+			     + GRUB_BOOT_AOUT_HEADER_SIZE
+			     + GRUB_BOOT_MACHINE_BOOT_DEVPATH);
+    if (dest_dev->disk->id != root_dev->disk->id
+	|| dest_dev->disk->dev->id != root_dev->disk->dev->id)
+      {
+	char *dest_ofpath;
+	dest_ofpath
+	  = grub_util_devname_to_ofpath (grub_util_biosdisk_get_osdev (root_dev->disk));
+	/* FIXME handle NULL result */
+	grub_util_info ("dest_ofpath is `%s'", dest_ofpath);
+	strncpy (boot_devpath, dest_ofpath,
+		 GRUB_BOOT_MACHINE_BOOT_DEVPATH_END
+		 - GRUB_BOOT_MACHINE_BOOT_DEVPATH - 1);
+	boot_devpath[GRUB_BOOT_MACHINE_BOOT_DEVPATH_END
+		   - GRUB_BOOT_MACHINE_BOOT_DEVPATH - 1] = 0;
+	free (dest_ofpath);
+      }
+    else
+      {
+	grub_util_info ("non cross-disk install");
+	memset (boot_devpath, 0, GRUB_BOOT_MACHINE_BOOT_DEVPATH_END
+		- GRUB_BOOT_MACHINE_BOOT_DEVPATH);
+      }
+    grub_util_info ("boot device path %s", boot_devpath);
+  }
+#endif
+
+  write_rootdev (root_dev, boot_img, bl.first_sector);
+
+  /* Write the first two sectors of the core image onto the disk.  */
+  grub_util_info ("opening the core image `%s'", core_path);
+  fp = grub_util_fd_open (core_path, GRUB_UTIL_FD_O_WRONLY);
+  if (! GRUB_UTIL_FD_IS_VALID (fp))
+    grub_util_error (_("cannot open `%s': %s"), core_path,
+		     grub_util_fd_strerror ());
+
+  if (grub_util_fd_write (fp, core_img, GRUB_DISK_SECTOR_SIZE * 2)
+      != GRUB_DISK_SECTOR_SIZE * 2)
+    grub_util_error (_("cannot write to `%s': %s"),
+		     core_path, strerror (errno));
+  if (grub_util_fd_sync (fp) < 0)
+    grub_util_error (_("cannot sync `%s': %s"), core_path, strerror (errno));
+  if (grub_util_fd_close (fp) < 0)
+    grub_util_error (_("cannot close `%s': %s"), core_path, strerror (errno));
+  grub_util_biosdisk_flush (root_dev->disk);
+
+  grub_disk_cache_invalidate_all ();
+
+  {
+    char *buf, *ptr = core_img;
+    size_t len = core_size;
+    grub_uint64_t blk, offset = 0;
+    grub_partition_t container = core_dev->disk->partition;
+    grub_err_t err;
+
+    core_dev->disk->partition = 0;
+#ifdef GRUB_SETUP_SPARC64
+    offset = bl.gpt_offset;
+#endif
+
+    buf = xmalloc (core_size);
+    blk = bl.first_sector;
+    err = grub_disk_read (core_dev->disk, blk + offset, 0, GRUB_DISK_SECTOR_SIZE, buf);
+    if (err)
+      grub_util_error (_("cannot read `%s': %s"), core_dev->disk->name,
+		       grub_errmsg);
+    if (grub_memcmp (buf, ptr, GRUB_DISK_SECTOR_SIZE) != 0)
+      grub_util_error ("%s", _("blocklists are invalid"));
+
+    ptr += GRUB_DISK_SECTOR_SIZE;
+    len -= GRUB_DISK_SECTOR_SIZE;
+
+    bl.block = bl.first_block;
+    while (bl.block->len)
+      {
+	size_t cur = grub_target_to_host16 (bl.block->len) << GRUB_DISK_SECTOR_BITS;
+	blk = grub_target_to_host64 (bl.block->start);
+
+	if (cur > len)
+	  cur = len;
+
+	err = grub_disk_read (core_dev->disk, blk + offset, 0, cur, buf);
+	if (err)
+	  grub_util_error (_("cannot read `%s': %s"), core_dev->disk->name,
+			   grub_errmsg);
+
+	if (grub_memcmp (buf, ptr, cur) != 0)
+	  grub_util_error ("%s", _("blocklists are invalid"));
+
+	ptr += cur;
+	len -= cur;
+	bl.block--;
+	
+	if ((char *) bl.block <= core_img)
+	  grub_util_error ("%s", _("no terminator in the core image"));
+      }
+    if (len)
+      grub_util_error ("%s", _("blocklists are incomplete"));
+    core_dev->disk->partition = container;
+    free (buf);
+  }
+
+#ifdef GRUB_SETUP_BIOS
+ finish:
+#endif
+
+  /* Write the boot image onto the disk.  */
+  if (grub_disk_write (dest_dev->disk, BOOT_SECTOR,
+		       0, GRUB_DISK_SECTOR_SIZE, boot_img))
+    grub_util_error ("%s", grub_errmsg);
+
+#ifdef GRUB_SETUP_SPARC64
+ finish:
+#endif
+
+  grub_util_biosdisk_flush (root_dev->disk);
+  grub_util_biosdisk_flush (dest_dev->disk);
+
+  free (core_path);
+  free (core_img);
+  free (boot_img);
+  grub_device_close (dest_dev);
+  grub_device_close (root_dev);
+}
+

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

@@ -61,3 +61,7 @@ else
 
     ventoy_add_udev_rule "$VTOY_PATH/hook/default/udev_disk_hook.sh %k"
 fi
+
+if [ -f $VTOY_PATH/ventoy_persistent_map ]; then
+    $SED "1 aexport cow_label=vtoycow" -i /init 
+fi

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

@@ -0,0 +1,79 @@
+#!/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
+
+if is_ventoy_hook_finished; then
+    exit 0
+fi
+
+vtlog "####### $0 $* ########"
+
+VTPATH_OLD=$PATH; PATH=$BUSYBOX_PATH:$VTOY_PATH/tool:$PATH
+
+
+ventoy_os_install_dmsetup_by_ko() {
+    vtlog "ventoy_os_install_dmsetup_by_ko $1"
+    
+    vtVer=$(uname -r)
+    if uname -m | $GREP -q 64; then
+        vtBit=64
+    else
+        vtBit=32
+    fi
+    
+    ventoy_extract_vtloopex $1  kerio
+    vtLoopExDir=$VTOY_PATH/vtloopex/kerio/vtloopex
+    
+    if [ -e $vtLoopExDir/dm-mod/$vtVer/$vtBit/dm-mod.ko.xz ]; then
+        $BUSYBOX_PATH/xz -d $vtLoopExDir/dm-mod/$vtVer/$vtBit/dm-mod.ko.xz
+        insmod $vtLoopExDir/dm-mod/$vtVer/$vtBit/dm-mod.ko
+    fi
+}
+
+
+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 echo $vtdiskname | $EGREP -q "nvme|mmc|nbd"; then
+    ventoy_os_install_dmsetup_by_ko "${vtdiskname}p2"
+else
+    ventoy_os_install_dmsetup_by_ko "${vtdiskname}2"
+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})
+
+vtlog "/dev/$vtDM"
+mount -t iso9660 /dev/$vtDM /cdrom
+modprobe squashfs
+echo "/dev/$vtDM" > /ventoy/vtDM
+
+PATH=$VTPATH_OLD
+
+set_ventoy_hook_finish

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

@@ -0,0 +1,20 @@
+#!/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/>.
+# 
+#************************************************************************************
+
+$SED "/for drive in/i\ $BUSYBOX_PATH/sh $VTOY_PATH/hook/debian/kerio-disk.sh >/dev/null 2>&1; cat /ventoy/vtDM; exit 0"  -i /installer/install_init

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

@@ -37,9 +37,17 @@ ventoy_os_install_dmsetup_by_fuse() {
 
     mount -t iso9660  $VTOY_PATH/mnt/fuse/ventoy.iso    $VTOY_PATH/mnt/iso
     
-    sfsfile=$(ls $VTOY_PATH/mnt/iso/adrv_veket*.sfs)
-    
-    mount -t squashfs $sfsfile  $VTOY_PATH/mnt/squashfs
+    for sfsfile in $(ls $VTOY_PATH/mnt/iso/*drv_veket*.sfs); do
+        mount -t squashfs $sfsfile  $VTOY_PATH/mnt/squashfs        
+        if [ -d $VTOY_PATH/mnt/squashfs/lib/modules ]; then
+            KoName=$(ls $VTOY_PATH/mnt/squashfs/lib/modules/$2/kernel/drivers/md/dm-mod.ko*)
+            if [ -n "$KoName" -a -f $KoName ]; then
+                break
+            fi
+        fi
+        
+        umount $VTOY_PATH/mnt/squashfs
+    done
 
     KoName=$(ls $VTOY_PATH/mnt/squashfs/lib/modules/$2/kernel/drivers/dax/dax.ko*)
     vtlog "insmod $KoName"

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

@@ -86,6 +86,9 @@ ventoy_get_debian_distro() {
         fi
     fi
     
+    if [ -e /opt/kerio ]; then
+        echo 'kerio'; return
+    fi
     
     
     echo 'default'

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

@@ -49,7 +49,12 @@ done
 
 if [ -n "$1" ]; then
     vtlog "ln -s /dev/$vtDM $1"
-    ln -s /dev/$vtDM "$1"
+    
+    if [ -e "$1" ]; then
+        vtlog "$1 already exist"
+    else
+        ln -s /dev/$vtDM "$1"
+    fi
 else
     vtLABEL=$($BUSYBOX_PATH/blkid /dev/$vtDM | $SED 's/.*LABEL="\([^"]*\)".*/\1/')
     vtlog "vtLABEL is $vtLABEL"

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

@@ -19,9 +19,6 @@
 
 . $VTOY_PATH/hook/ventoy-os-lib.sh
 
-#ventoy_systemd_udevd_work_around
-#ventoy_add_udev_rule "$VTOY_PATH/hook/default/udev_disk_hook.sh %k noreplace"
-
 if [ -f $VTOY_PATH/autoinstall ]; then
     VTKS="inst.ks=file:$VTOY_PATH/autoinstall"
 else
@@ -40,7 +37,25 @@ else
     done
 fi
 
-echo "VTKS=$VTKS" >> $VTLOG
+if [ -f $VTOY_PATH/ventoy_persistent_map ]; then
+    VTOVERLAY="rd.live.overlay=/dev/dm-1:/vtoyoverlayfs/overlayfs"
+    
+    if [ -e /sbin/dmsquash-live-root ]; then
+        echo "patch /sbin/dmsquash-live-root for persistent ..." >> $VTLOG
+        $SED "/mount.*devspec.*\/run\/initramfs\/overlayfs/a . /ventoy/hook/openEuler/ventoy-overlay.sh" -i /sbin/dmsquash-live-root
+    fi
+    
+    #close selinux
+    $BUSYBOX_PATH/mkdir -p $VTOY_PATH/selinuxfs
+    if $BUSYBOX_PATH/mount -t selinuxfs selinuxfs $VTOY_PATH/selinuxfs; then
+        echo 1 > $VTOY_PATH/selinuxfs/disable
+        $BUSYBOX_PATH/umount $VTOY_PATH/selinuxfs
+    fi    
+    $BUSYBOX_PATH/rm -rf $VTOY_PATH/selinuxfs
+fi
+
+
+echo "VTKS=$VTKS  VTOVERLAY=$VTOVERLAY" >> $VTLOG
 
 if ls $VTOY_PATH | $GREP -q 'ventoy_dud[0-9]'; then
     for vtDud in $(ls $VTOY_PATH/ventoy_dud*); do
@@ -49,11 +64,7 @@ if ls $VTOY_PATH | $GREP -q 'ventoy_dud[0-9]'; then
 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 $vtInstDD#" -i /lib/dracut-lib.sh
-else
-    $SED "s#printf\(.*\)\$CMDLINE#printf\1\$CMDLINE inst.stage2=hd:/dev/dm-0 $VTKS $vtInstDD#" -i /lib/dracut-lib.sh
-fi
+$SED "s#printf\(.*\)\$CMDLINE#printf\1\$CMDLINE inst.stage2=hd:/dev/dm-0 $VTKS $vtInstDD#" -i /lib/dracut-lib.sh
 
 ventoy_set_inotify_script  openEuler/ventoy-inotifyd-hook.sh
 
@@ -66,14 +77,15 @@ fi
 
 $BUSYBOX_PATH/cp -a $VTOY_PATH/hook/openEuler/ventoy-inotifyd-start.sh /lib/dracut/hooks/pre-udev/${vtPriority}-ventoy-inotifyd-start.sh
 $BUSYBOX_PATH/cp -a $VTOY_PATH/hook/openEuler/ventoy-timeout.sh /lib/dracut/hooks/initqueue/timeout/${vtPriority}-ventoy-timeout.sh
+$BUSYBOX_PATH/cp -a $VTOY_PATH/hook/openEuler/ventoy-repo.sh /lib/dracut/hooks/pre-pivot/99-ventoy-repo.sh
 
-if [ -e /sbin/dmsquash-live-root ]; then
+if [ -f /sbin/dmsquash-live-root ]; then
     echo "patch /sbin/dmsquash-live-root ..." >> $VTLOG
     $SED "1 a $BUSYBOX_PATH/sh $VTOY_PATH/hook/openEuler/ventoy-make-link.sh" -i /sbin/dmsquash-live-root
 fi
 
 # suppress write protected mount warning
-if [ -e /usr/sbin/anaconda-diskroot ]; then
+if [ -f /usr/sbin/anaconda-diskroot ]; then
     $SED  's/^mount $dev $repodir/mount -oro $dev $repodir/' -i /usr/sbin/anaconda-diskroot
 fi
 

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

@@ -29,20 +29,11 @@ if is_inotify_ventoy_part $3; then
 
     vtlog "##### INOTIFYD: $2/$3 is created (YES) ..."
 
-    vtGenRulFile='/etc/udev/rules.d/99-live-squash.rules'
-    if [ -e $vtGenRulFile ] && $GREP -q dmsquash $vtGenRulFile; then
-        vtScript=$($GREP -m1 'RUN.=' $vtGenRulFile | $AWK -F'RUN.=' '{print $2}' | $SED 's/"\(.*\)".*/\1/')
-        vtlog "vtScript=$vtScript"
-        $vtScript
-    else
-        vtlog "$vtGenRulFile not exist..."
-    fi
-
     vtlog "find ventoy partition ..."
     
-    vtReplaceOpt=noreplace
+    #vtReplaceOpt=noreplace
     
-    $BUSYBOX_PATH/sh $VTOY_PATH/hook/default/udev_disk_hook.sh $3 $vtReplaceOpt
+    $BUSYBOX_PATH/sh $VTOY_PATH/hook/default/udev_disk_hook.sh $3 
     
     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/openEuler/ventoy-overlay.sh

@@ -0,0 +1,21 @@
+#!/bin/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/>.
+# 
+#************************************************************************************
+
+[ -d /run/initramfs/overlayfs$pathspec ] || mkdir -p /run/initramfs/overlayfs$pathspec
+[ -d /run/initramfs/overlayfs$pathspec/../ovlwork ] || mkdir -p /run/initramfs/overlayfs$pathspec/../ovlwork

IMG/cpio/ventoy/hook/openEuler/ventoy-repo.sh

@@ -0,0 +1,29 @@
+#!/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
+
+vtlog "##### $0 $* ..."
+
+VTPATH_OLD=$PATH; PATH=$BUSYBOX_PATH:$VTOY_PATH/tool:$PATH
+
+repodev=$(ls $VTOY_PATH/dev_backup*)
+echo "inst.repo=hd:/dev/${repodev#*dev_backup_}" >> /sysroot/etc/cmdline
+
+PATH=$VTPATH_OLD

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

@@ -26,3 +26,13 @@ ventoy_add_udev_rule "$VTOY_PATH/hook/rhel6/udev_disk_hook.sh %k"
 
 #loop7 was used by loader
 ventoy_add_kernel_udev_rule "loop6" "$VTOY_PATH/hook/rhel6/udev_disk_hook.sh %k"
+
+if [ -f $VTOY_PATH/autoinstall ]; then
+    $BUSYBOX_PATH/mv /sbin/loader /sbin/loader_bk
+    $BUSYBOX_PATH/mv $VTOY_PATH/tool/loader /sbin/loader
+    
+    RawCmdLine=$($BUSYBOX_PATH/cat /proc/cmdline)
+    echo -n "/sbin/loader_bk" > "/ventoy/loader_exec_file"
+    echo -n "--cmdline=$RawCmdLine ks=file:$VTOY_PATH/autoinstall" > "/ventoy/loader_exec_cmdline"
+    #echo 111 > "/ventoy/loader_debug"
+fi

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

@@ -40,7 +40,26 @@ else
     done
 fi
 
-echo "VTKS=$VTKS" >> $VTLOG
+if [ -f $VTOY_PATH/ventoy_persistent_map ]; then
+    VTOVERLAY="rd.live.overlay=/dev/dm-1:/vtoyoverlayfs/overlayfs"
+    
+    if [ -e /sbin/dmsquash-live-root ]; then
+        echo "patch /sbin/dmsquash-live-root for persistent ..." >> $VTLOG
+        $SED "/mount.*devspec.*\/run\/initramfs\/overlayfs/a . /ventoy/hook/rhel7/ventoy-overlay.sh" -i /sbin/dmsquash-live-root        
+        $SED "s/osmin.img/osmin.imgxxxx/g" -i /sbin/dmsquash-live-root
+    fi
+    
+    #close selinux
+    $BUSYBOX_PATH/mkdir -p $VTOY_PATH/selinuxfs
+    if $BUSYBOX_PATH/mount -t selinuxfs selinuxfs $VTOY_PATH/selinuxfs; then
+        echo 1 > $VTOY_PATH/selinuxfs/disable
+        $BUSYBOX_PATH/umount $VTOY_PATH/selinuxfs
+    fi    
+    $BUSYBOX_PATH/rm -rf $VTOY_PATH/selinuxfs
+fi
+
+
+echo "VTKS=$VTKS  VTOVERLAY=$VTOVERLAY" >> $VTLOG
 
 if ls $VTOY_PATH | $GREP -q 'ventoy_dud[0-9]'; then
     for vtDud in $(ls $VTOY_PATH/ventoy_dud*); do
@@ -50,9 +69,9 @@ 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 $vtInstDD#" -i /lib/dracut-lib.sh
+    $SED "s#printf\(.*\)\$CMDLINE#printf\1\$CMDLINE root=live:/dev/dm-0 $VTKS $VTOVERLAY $vtInstDD#" -i /lib/dracut-lib.sh
 else
-    $SED "s#printf\(.*\)\$CMDLINE#printf\1\$CMDLINE inst.stage2=hd:/dev/dm-0 $VTKS $vtInstDD#" -i /lib/dracut-lib.sh
+    $SED "s#printf\(.*\)\$CMDLINE#printf\1\$CMDLINE inst.stage2=hd:/dev/dm-0 $VTKS $VTOVERLAY $vtInstDD#" -i /lib/dracut-lib.sh
 fi
 
 ventoy_set_inotify_script  rhel7/ventoy-inotifyd-hook.sh
@@ -67,6 +86,26 @@ fi
 $BUSYBOX_PATH/cp -a $VTOY_PATH/hook/rhel7/ventoy-inotifyd-start.sh /lib/dracut/hooks/pre-udev/${vtPriority}-ventoy-inotifyd-start.sh
 $BUSYBOX_PATH/cp -a $VTOY_PATH/hook/rhel7/ventoy-timeout.sh /lib/dracut/hooks/initqueue/timeout/${vtPriority}-ventoy-timeout.sh
 
+vtNeedRepo=
+if [ -f /etc/system-release ]; then
+    if $GREP -q 'RED OS' /etc/system-release; then
+        vtNeedRepo="yes"
+    fi
+fi
+if $GREP -q el8 /proc/version; then
+    vtNeedRepo="yes"
+fi
+
+if $GREP -i -q Fedora /proc/version; then
+    if $GREP -q 'Server Edition' /etc/os-release; then
+        vtNeedRepo="yes"
+    fi
+fi
+
+if [ "$vtNeedRepo" = "yes" ]; then
+    $BUSYBOX_PATH/cp -a $VTOY_PATH/hook/rhel7/ventoy-repo.sh /lib/dracut/hooks/pre-pivot/99-ventoy-repo.sh
+fi
+
 if [ -e /sbin/dmsquash-live-root ]; then
     echo "patch /sbin/dmsquash-live-root ..." >> $VTLOG
     $SED "1 a $BUSYBOX_PATH/sh $VTOY_PATH/hook/rhel7/ventoy-make-link.sh" -i /sbin/dmsquash-live-root

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

@@ -41,12 +41,8 @@ if is_inotify_ventoy_part $3; then
     vtlog "find ventoy partition ..."
     
     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
+    if [ -f /lib/dracut/hooks/pre-pivot/99-ventoy-repo.sh ]; then
+        vtReplaceOpt=""
     fi
     
     $BUSYBOX_PATH/sh $VTOY_PATH/hook/default/udev_disk_hook.sh $3 $vtReplaceOpt

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

@@ -0,0 +1,21 @@
+#!/bin/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/>.
+# 
+#************************************************************************************
+
+[ -d /run/initramfs/overlayfs$pathspec ] || mkdir -p /run/initramfs/overlayfs$pathspec
+[ -d /run/initramfs/overlayfs$pathspec/../ovlwork ] || mkdir -p /run/initramfs/overlayfs$pathspec/../ovlwork

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

@@ -0,0 +1,29 @@
+#!/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
+
+vtlog "##### $0 $* ..."
+
+VTPATH_OLD=$PATH; PATH=$BUSYBOX_PATH:$VTOY_PATH/tool:$PATH
+
+repodev=$(ls $VTOY_PATH/dev_backup*)
+echo "inst.repo=hd:/dev/${repodev#*dev_backup_}" >> /sysroot/etc/cmdline
+
+PATH=$VTPATH_OLD

IMG/cpio/ventoy/loop/openwrt/ventoy-disk.sh

@@ -45,6 +45,9 @@ echo -n $vtDM > /ventoy/vtDM
 ventoy_create_dev_ventoy_part
 mdev -s
 
+mkdir /ventoy_rdroot
+mount /dev/ventoy2 /ventoy_rdroot
+
 PATH=$VTPATH_OLD
 
 set_ventoy_hook_finish

IMG/cpio/ventoy/loop/openwrt/ventoy-hook.sh

@@ -19,12 +19,39 @@
 
 . $VTOY_PATH/hook/ventoy-os-lib.sh
 
-$BUSYBOX_PATH/mkdir /sys
-$BUSYBOX_PATH/mount -t proc proc /proc
-$BUSYBOX_PATH/mount -t sysfs sys /sys
+VTPATH_OLD=$PATH; PATH=$BUSYBOX_PATH:$VTOY_PATH/tool:$PATH
 
-$BUSYBOX_PATH/mdev -s
+wrt_insmod() {
+    kbit=$1
+    kv=$(uname -r)
+    
+    echo "insmod $kv $kbit" >> $VTOY_PATH/log
+    
+    [ -f /ventoy_openwrt/$kv/$kbit/dax.ko ] && insmod /ventoy_openwrt/$kv/$kbit/dax.ko > /dev/null 2>&1
+    [ -f /ventoy_openwrt/$kv/$kbit/dm-mod.ko ] && insmod /ventoy_openwrt/$kv/$kbit/dm-mod.ko > /dev/null 2>&1
+}
 
-#$BUSYBOX_PATH/sh $VTOY_PATH/loop/openwrt/ventoy-disk.sh
 
-exec $BUSYBOX_PATH/sh
+mkdir /sys
+mount -t sysfs sys /sys
+mdev -s
+
+
+if [ -f /ventoy_openwrt.xz ]; then
+    tar xf /ventoy_openwrt.xz -C /
+    rm -f  /ventoy_openwrt.xz
+fi
+
+
+if uname -m | egrep -q "amd64|x86_64"; then
+    wrt_insmod 64
+else
+    wrt_insmod generic    
+    if lsmod | grep -q 'dm-mod'; then
+        echo "insmod generic failed" >> $VTOY_PATH/log
+    else
+        wrt_insmod legacy
+    fi
+fi
+
+sh $VTOY_PATH/loop/openwrt/ventoy-disk.sh

IMG/cpio/ventoy/ventoy_chain.sh

@@ -153,6 +153,8 @@ ventoy_get_os_type() {
             echo 'rhel7'; return
         elif $GREP -q 'openEuler' /etc/os-release; then
             echo 'openEuler'; return
+        elif $GREP -q 'fuyu' /etc/os-release; then
+            echo 'openEuler'; return	
         fi
     fi
     

IMG/cpio/ventoy/ventoy_loop.sh

@@ -198,6 +198,8 @@ ventoy_get_os_type() {
             echo 'rhel7'; return
         elif $GREP -q 'openEuler' /etc/os-release; then
             echo 'openEuler'; return
+        elif $GREP -q 'fuyu' /etc/os-release; then
+            echo 'openEuler'; return
         fi
     fi
     

INSTALL/CreatePersistentImg.sh

@@ -4,6 +4,7 @@ size=1024
 fstype=ext4
 label=casper-rw
 config=''
+outputfile=persistence.dat
 
 print_usage() {
     echo 'Usage:  CreatePersistentImg.sh [ -s size ] [ -t fstype ] [ -l LABEL ] [ -c CFG ]'
@@ -12,6 +13,7 @@ print_usage() {
     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 '   -o outputfile name, default is persistence.dat'
     echo ''
 }
 
@@ -28,6 +30,9 @@ while [ -n "$1" ]; do
     elif [ "$1" = "-c" ]; then
         shift
         config=$1
+    elif [ "$1" = "-o" ]; then
+        shift
+        outputfile=$1
     elif [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
         print_usage
         exit 0
@@ -69,13 +74,17 @@ else
     exit 1
 fi
 
+if [ "$outputdir" != "persistence.dat" ]; then
+    mkdir -p "$(dirname "$outputfile")"
+fi
+
 # 00->ff avoid sparse file
-dd if=/dev/zero  bs=1M count=$size | tr '\000' '\377' > persistence.dat
+dd if=/dev/zero  bs=1M count=$size | tr '\000' '\377' > "$outputfile"
 sync
 
 freeloop=$(losetup -f)
 
-losetup $freeloop persistence.dat
+losetup $freeloop "$outputfile"
 
 mkfs -t $fstype $fsopt -L $label $freeloop 
 

INSTALL/ExtendPersistentImg.sh

@@ -0,0 +1,97 @@
+#!/bin/sh
+
+print_usage() {
+    echo 'Usage:  ExtendPersistentImg.sh file size'
+    echo '   file   persistent dat file'
+    echo '   size   extend size in MB'
+    echo 'Example:'
+    echo '   sh ExtendPersistentImg.sh ubuntu.dat 2048'
+    echo ''
+}
+
+if [ -z "$1" -o "$1" = "-h" ]; then
+    print_usage
+    exit 1
+fi
+
+if [ -z "$2" ]; then
+    print_usage
+    exit 1
+fi
+
+file=$1
+size=$2
+
+if [ ! -f "$file" ]; then
+    echo "$file not exist."
+    exit 1
+fi
+
+if echo $size | grep -q "[^0-9]"; then
+    print_usage
+    exit 1
+fi
+
+fsize=$(stat -c '%s' $file)
+
+fsmod=$(expr $fsize % 1024)
+if [ $fsmod -ne 0 ]; then
+    echo "File size of $file is not aligned by 1MB, please check."
+    exit 1
+fi
+
+
+fsMB=$(expr $fsize / 1024 / 1024)
+total=$(expr $fsMB + $size)
+
+magic=$(hexdump -n3 -e  '3/1 "%02X"' $file)
+if [ "$magic" = "584653" ]; then
+    if which xfs_growfs >/dev/null 2>&1; then
+        cmd=xfs_growfs
+    else
+        echo 'xfs_growfs not found, please install xfsprogs first'
+        exit 1
+    fi
+else
+    if which resize2fs >/dev/null 2>&1; then
+        cmd=resize2fs
+    else
+        echo 'resize2fs not found, please install e2fsprogs first'
+        exit 1
+    fi
+fi
+
+
+echo "Extend dat file... (current is ${fsMB}MB, append ${size}MB, total ${total}MB)"
+dd if=/dev/zero bs=1M count=$size status=none >> "$file"
+sync
+
+freeloop=$(losetup -f)
+losetup $freeloop "$file"
+
+if [ "$cmd" = "resize2fs" ]; then    
+    echo "Extend ext filesystem by resize2fs ..."
+    echo "resize2fs $freeloop ${total}M"
+    e2fsck -f $freeloop
+    resize2fs $freeloop ${total}M
+    ret=$?
+else
+    echo "Extend xfs filesystem by xfs_growfs ..."
+
+    tmpdir=$(mktemp -d)
+    mount $freeloop $tmpdir
+    xfs_growfs $freeloop
+    ret=$?
+    umount $tmpdir && rm -rf $tmpdir
+fi
+
+losetup -d $freeloop
+
+echo ""
+if [ $ret -eq 0 ]; then
+    echo "======= SUCCESS ========="
+else
+    echo "======= FAILED ========="
+fi
+echo ""
+

INSTALL/README

@@ -38,5 +38,12 @@ Please refer https://www.ventoy.net/en/plugin_persistence.html for details.
 
 
 
+========== ExtendPersistentImg.sh ===============
+sudo sh ExtendPersistentImg.sh  file size   
+For example:
+sh ExtendPersistentImg.sh persistence.dat 2048  ---->  Extend persistence.dat by 2048MB
+That is to say, persistence.dat file will grow to 3GB size (assume that it is 1GB size before extend)
+
+Please refer https://www.ventoy.net/en/plugin_persistence.html for details.
 
 

INSTALL/all_in_one.sh

@@ -2,25 +2,29 @@
 
 VTOY_PATH=$PWD/..
 
+cilog() {
+    datestr=$(date +"%Y/%m/%d %H:%M:%S")
+    echo "$datestr $*"
+}
+
 LOG=$VTOY_PATH/DOC/build.log
 [ -f $LOG ] && rm -f $LOG
 
 cd $VTOY_PATH/DOC
-echo "prepare_env ..."
+cilog "prepare_env ..."
 sh prepare_env.sh
 
 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:/opt/mips-loongson-gcc7.3-linux-gnu/2019.06-29/bin/:/opt/mips64el-linux-musl-gcc730/bin/
 
-
-echo "build grub2 ..."
+cilog "build grub2 ..."
 cd $VTOY_PATH/GRUB2
 sh buildgrub.sh >> $LOG 2>&1 || exit 1
 
-echo "build ipxe ..."
+cilog "build ipxe ..."
 cd $VTOY_PATH/IPXE
 sh buildipxe.sh >> $LOG 2>&1 || exit 1
 
-echo "build edk2 ..."
+cilog "build edk2 ..."
 cd $VTOY_PATH/EDK2
 sh buildedk.sh >> $LOG 2>&1 || exit 1
 
@@ -74,7 +78,7 @@ if [ "$1" = "CI" ]; then
     sed "s/VENTOY_VERSION=.*/VENTOY_VERSION=\"$Ver\"/"  -i ./grub/grub.cfg
 fi
 
-echo "packing ventoy-$Ver ..."
+cilog "packing ventoy-$Ver ..."
 sh ventoy_pack.sh $1 >> $LOG 2>&1 || exit 1
 
 echo -e '\n============== SUCCESS ==================\n'

INSTALL/docker_ci_build.sh

@@ -2,12 +2,18 @@
 
 VTOY_PATH=$PWD/..
 
-wget -q -P $VTOY_PATH/DOC/ https://www.fefe.de/dietlibc/dietlibc-0.34.tar.xz
-wget -q -P $VTOY_PATH/DOC/ https://musl.libc.org/releases/musl-1.2.1.tar.gz
-wget -q -P $VTOY_PATH/GRUB2/ https://ftp.gnu.org/gnu/grub/grub-2.04.tar.xz
+date +"%Y/%m/%d %H:%M:%S"
+echo downloading envrionment ...
+
+wget -q -P $VTOY_PATH/DOC/ https://github.com/ventoy/vtoytoolchain/releases/download/1.0/dietlibc-0.34.tar.xz
+wget -q -P $VTOY_PATH/DOC/ https://github.com/ventoy/vtoytoolchain/releases/download/1.0/musl-1.2.1.tar.gz
+wget -q -P $VTOY_PATH/GRUB2/ https://github.com/ventoy/vtoytoolchain/releases/download/1.0/grub-2.04.tar.xz
 wget -q -O $VTOY_PATH/EDK2/edk2-edk2-stable201911.zip https://codeload.github.com/tianocore/edk2/zip/edk2-stable201911
-wget -q -P /opt/ 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
-wget -q -P /opt/ https://toolchains.bootlin.com/downloads/releases/toolchains/aarch64/tarballs/aarch64--uclibc--stable-2020.08-1.tar.bz2
-wget -q -P /opt/ http://ftp.loongnix.org/toolchain/gcc/release/mips-loongson-gcc7.3-2019.06-29-linux-gnu.tar.gz
+wget -q -P /opt/ https://github.com/ventoy/vtoytoolchain/releases/download/1.0/gcc-linaro-7.4.1-2019.02-x86_64_aarch64-linux-gnu.tar.xz
+wget -q -P /opt/ https://github.com/ventoy/vtoytoolchain/releases/download/1.0/aarch64--uclibc--stable-2020.08-1.tar.bz2
+wget -q -P /opt/ https://github.com/ventoy/vtoytoolchain/releases/download/1.0/mips-loongson-gcc7.3-2019.06-29-linux-gnu.tar.gz
+
+date +"%Y/%m/%d %H:%M:%S"
+echo downloading envrionment finish...
 
 sh all_in_one.sh CI

INSTALL/grub/arm64-efi/command.lst

@@ -32,6 +32,7 @@
 *save_env: loadenv
 *search: search
 *serial: serial
+*set_keyboard_layout: setkey
 *setkey: setkey
 *sha1sum: hashsum
 *sha256sum: hashsum

INSTALL/grub/arm64-efi/moddep.lst

@@ -1,7 +1,7 @@
 videotest: font video gfxmenu
-setkey: extcmd
 odc: archelp
 loopback: extcmd
+setkey: extcmd
 macho:
 gcry_des: crypto
 memrw: extcmd
@@ -23,7 +23,7 @@ sfs: fshelp
 reiserfs: fshelp
 part_sunpc:
 zstd:
-gfxmenu: video_colors trig bitmap_scale gfxterm font normal bitmap video
+gfxmenu: trig video_colors bitmap_scale gfxterm font normal bitmap video
 jfs:
 help: extcmd normal
 configfile: normal
@@ -68,7 +68,7 @@ gfxterm_background: video_colors bitmap_scale gfxterm extcmd video bitmap
 search_fs_uuid:
 gcry_dsa: pgp mpi
 keystatus: extcmd
-linux: verifiers boot fdt
+linux: ventoy verifiers boot fdt
 geli: cryptodisk crypto gcry_sha512 pbkdf2 gcry_sha256
 cmdline_cat_test: font functional_test normal procfs video_fb
 part_sun:
@@ -93,7 +93,7 @@ terminal:
 div:
 crypto:
 part_bsd: part_msdos
-ventoy: ext2 fshelp btrfs font crypto gcry_md5 exfat udf extcmd normal video gcry_sha1 iso9660
+ventoy: elf fshelp ext2 btrfs font crypto gcry_md5 exfat udf extcmd datetime div normal video gcry_sha1 iso9660
 gcry_sha512: crypto
 password: crypto normal
 fshelp:

INSTALL/grub/debug.cfg

@@ -1,7 +1,7 @@
 
-source $prefix/keyboard.cfg.gz
+source $prefix/keyboard.cfg
 
-submenu "Resolution Configuration" --class=debug_resolution {
+submenu "Resolution Configuration" --class=debug_resolution --class=F5tool {
     menuentry 'Return to previous menu [Esc]' --class=vtoyret VTOY_RET {
         echo 'Return ...'
     }
@@ -16,7 +16,7 @@ submenu "Resolution Configuration" --class=debug_resolution {
             set vtActive="[*]"
         fi
         
-        menuentry "$vtCurMode $vtActive" --class=debug_videomode VTOY_RUN_RET {
+        menuentry "$vtCurMode $vtActive" --class=debug_videomode --class=debug_resolution --class=F5tool VTOY_RUN_RET {
             terminal_output console
             set gfxmode=$1
             terminal_output gfxterm
@@ -26,11 +26,11 @@ submenu "Resolution Configuration" --class=debug_resolution {
     done
 }
 
-submenu "Screen Display Mode" --class=debug_screen_mode {
-    menuentry 'Force Text Mode' --class=debug_text_mode {
+submenu "Screen Display Mode" --class=debug_screen_mode --class=F5tool {
+    menuentry 'Force Text Mode' --class=debug_text_mode --class=debug_screen_mode --class=F5tool {
         terminal_output console
     }
-    menuentry 'Force Graphics Mode' --class=debug_gui_mode {
+    menuentry 'Force Graphics Mode' --class=debug_gui_mode --class=debug_screen_mode --class=F5tool {
         terminal_output gfxterm
     }
     menuentry 'Return to previous menu [Esc]' --class=vtoyret VTOY_RET {
@@ -39,8 +39,8 @@ submenu "Screen Display Mode" --class=debug_screen_mode {
 }
 
 if [ "$grub_platform" != "pc" ]; then
-    submenu 'Ventoy UEFI Utilities' --class=debug_util {
-        menuentry 'Fixup Windows BlinitializeLibrary Failure' --class=debug_util_blinit {
+    submenu 'Ventoy UEFI Utilities' --class=debug_util --class=F5tool {
+        menuentry 'Fixup Windows BlinitializeLibrary Failure' --class=debug_util_blinit --class=debug_util --class=F5tool {
             chainloader ${vtoy_path}/vtoyutil_${VTOY_EFI_ARCH}.efi env_param=${env_param} ${vtdebug_flag} feature=fix_windows_mmap
             boot
             echo -e "\npress ENTER to exit ..."
@@ -54,8 +54,8 @@ if [ "$grub_platform" != "pc" ]; then
 fi
 
 
-submenu 'Check plugin json configuration (ventoy.json)' --class=debug_json {
-    menuentry 'Check global control plugin configuration' --class=debug_control {
+submenu 'Check plugin json configuration (ventoy.json)' --class=debug_json --class=F5tool {
+    menuentry 'Check global control plugin configuration' --class=debug_control --class=debug_json --class=F5tool {
         set pager=1
         vt_check_plugin_json $vt_plugin_path control $vtoy_iso_part
         
@@ -64,7 +64,7 @@ submenu 'Check plugin json configuration (ventoy.json)' --class=debug_json {
         unset pager
     }
     
-    menuentry 'Check theme plugin configuration' --class=debug_theme {
+    menuentry 'Check theme plugin configuration' --class=debug_theme --class=debug_json --class=F5tool {
         set pager=1
         vt_check_plugin_json $vt_plugin_path theme $vtoy_iso_part
         
@@ -73,7 +73,7 @@ submenu 'Check plugin json configuration (ventoy.json)' --class=debug_json {
         unset pager
     }
     
-    menuentry 'Check auto install plugin configuration' --class=debug_autoinstall {
+    menuentry 'Check auto install plugin configuration' --class=debug_autoinstall --class=debug_json --class=F5tool {
         set pager=1
         vt_check_plugin_json $vt_plugin_path auto_install $vtoy_iso_part
         
@@ -82,7 +82,7 @@ submenu 'Check plugin json configuration (ventoy.json)' --class=debug_json {
         unset pager
     }
     
-    menuentry 'Check persistence plugin configuration' --class=debug_persistence {
+    menuentry 'Check persistence plugin configuration' --class=debug_persistence --class=debug_json --class=F5tool {
         set pager=1
         vt_check_plugin_json $vt_plugin_path persistence $vtoy_iso_part
         
@@ -94,7 +94,7 @@ submenu 'Check plugin json configuration (ventoy.json)' --class=debug_json {
         unset pager
     }
     
-    menuentry 'Check menu alias plugin configuration' --class=debug_menualias {
+    menuentry 'Check menu alias plugin configuration' --class=debug_menualias --class=debug_json --class=F5tool {
         set pager=1
         vt_check_plugin_json $vt_plugin_path menu_alias $vtoy_iso_part
         
@@ -103,7 +103,7 @@ submenu 'Check plugin json configuration (ventoy.json)' --class=debug_json {
         unset pager
     }
     
-    menuentry 'Check menu class plugin configuration' --class=debug_menuclass {
+    menuentry 'Check menu class plugin configuration' --class=debug_menuclass --class=debug_json --class=F5tool {
         set pager=1
         vt_check_plugin_json $vt_plugin_path menu_class $vtoy_iso_part
         
@@ -112,7 +112,7 @@ submenu 'Check plugin json configuration (ventoy.json)' --class=debug_json {
         unset pager
     }  
 
-    menuentry 'Check injection plugin configuration' --class=debug_injection {
+    menuentry 'Check injection plugin configuration' --class=debug_injection --class=debug_json --class=F5tool {
         set pager=1
         vt_check_plugin_json $vt_plugin_path injection $vtoy_iso_part
         
@@ -121,7 +121,7 @@ submenu 'Check plugin json configuration (ventoy.json)' --class=debug_json {
         unset pager
     } 
 
-    menuentry 'Check auto memdisk plugin configuration' --class=debug_automemdisk {
+    menuentry 'Check auto memdisk plugin configuration' --class=debug_automemdisk --class=debug_json --class=F5tool {
         set pager=1
         vt_check_plugin_json $vt_plugin_path auto_memdisk $vtoy_iso_part
         
@@ -130,7 +130,7 @@ submenu 'Check plugin json configuration (ventoy.json)' --class=debug_json {
         unset pager
     }  
 
-    menuentry 'Check image list plugin configuration' --class=debug_imagelist {
+    menuentry 'Check image list plugin configuration' --class=debug_imagelist --class=debug_json --class=F5tool {
         set pager=1
         vt_check_plugin_json $vt_plugin_path image_list $vtoy_iso_part
         
@@ -139,7 +139,7 @@ submenu 'Check plugin json configuration (ventoy.json)' --class=debug_json {
         unset pager
     }
     
-    menuentry 'Check image blacklist plugin configuration' --class=debug_imageblacklist {
+    menuentry 'Check image blacklist plugin configuration' --class=debug_imageblacklist --class=debug_json --class=F5tool {
         set pager=1
         vt_check_plugin_json $vt_plugin_path image_blacklist $vtoy_iso_part
         
@@ -148,7 +148,7 @@ submenu 'Check plugin json configuration (ventoy.json)' --class=debug_json {
         unset pager
     }
     
-    menuentry 'Check boot conf replace plugin configuration' --class=debug_bootconf_replace {
+    menuentry 'Check boot conf replace plugin configuration' --class=debug_bootconf_replace --class=debug_json --class=F5tool {
         set pager=1
         vt_check_plugin_json $vt_plugin_path conf_replace $vtoy_iso_part
         
@@ -157,7 +157,7 @@ submenu 'Check plugin json configuration (ventoy.json)' --class=debug_json {
         unset pager
     }
     
-    menuentry 'Check dud plugin configuration' --class=debug_dud {
+    menuentry 'Check dud plugin configuration' --class=debug_dud --class=debug_json --class=F5tool {
         set pager=1
         vt_check_plugin_json $vt_plugin_path dud $vtoy_iso_part
         
@@ -166,7 +166,7 @@ submenu 'Check plugin json configuration (ventoy.json)' --class=debug_json {
         unset pager
     }
     
-    menuentry 'Check password plugin configuration' --class=debug_pwd {
+    menuentry 'Check password plugin configuration' --class=debug_pwd --class=debug_json --class=F5tool {
         set pager=1
         vt_check_plugin_json $vt_plugin_path password $vtoy_iso_part
         
@@ -175,7 +175,7 @@ submenu 'Check plugin json configuration (ventoy.json)' --class=debug_json {
         unset pager
     }
     
-    menuentry 'Check custom boot plugin configuration' --class=debug_custom_boot {
+    menuentry 'Check custom boot plugin configuration' --class=debug_custom_boot --class=debug_json --class=F5tool {
         set pager=1
         vt_check_plugin_json $vt_plugin_path custom_boot $vtoy_iso_part
         

INSTALL/grub/grub.cfg

@@ -131,7 +131,7 @@ function get_os_type {
 function vt_check_compatible_pe {
     #Check for PE without external tools
     if [ -f "$1/HBCD_PE.ini" ]; then
-        set ventoy_compatible=YES        
+        set ventoy_compatible=YES
     fi
 }
 
@@ -311,18 +311,15 @@ function distro_specify_initrd_file_phase2 {
         vt_linux_specify_initrd_file /antiX/initrd.gz
     elif [ -f (loop)/360Disk/initrd.gz ]; then
         vt_linux_specify_initrd_file /360Disk/initrd.gz
+    elif [ -f (loop)/porteus/initrd.xz ]; then
+        vt_linux_specify_initrd_file /porteus/initrd.xz
     
     fi
 }
 
 function ventoy_get_ghostbsd_ver {
-
-    # vt_parse_iso_create_date "$1/${chosen_path}" vt_create_date    
-    # if regexp "^202005" "$vt_create_date"; then
-        # set vt_freebsd_ver=12.x
-    # fi
-    
-    set vt_freebsd_ver=12.x
+    # fallback to parse version from elf /boot/kernel/kernel
+    set vt_freebsd_ver=xx
 }
 
 function ventoy_get_furybsd_ver {
@@ -364,11 +361,18 @@ function ventoy_get_truenas_ver {
 }
 
 function ventoy_get_midnightbsd_ver {   
-    set vt_freebsd_ver=11.x
+    if vt_str_begin "$vt_volume_id" "1_"; then
+        set vt_freebsd_ver=11.x
+    elif vt_str_begin "$vt_volume_id" "2_"; then
+        set vt_freebsd_ver=2.x
+    elif vt_str_begin "$vt_volume_id" "3_"; then
+        set vt_freebsd_ver=3.x
+    fi
 }
 
 function ventoy_freebsd_proc {
     set vtFreeBsdDistro=FreeBSD
+    set vt_freebsd_ver=xx
 
     if vt_strstr "$vt_volume_id" "GHOSTBSD"; then
         ventoy_get_ghostbsd_ver "$1" "${chosen_path}"
@@ -419,8 +423,11 @@ function ventoy_freebsd_proc {
         fi
     elif vt_strstr "${chosen_path}" "MidnightBSD"; then
         set vt_freebsd_ver=9.x
-    else
-        set vt_freebsd_ver=12.x
+    fi
+    
+    
+    if [ -e (loop)/usr/freebsd-dist/cloninst.sh ]; then
+        set vtFreeBsdDistro=ClonOS
     fi
     
     set vt_freebsd_bit=64
@@ -431,10 +438,20 @@ function ventoy_freebsd_proc {
             fi
             break
         fi
-    done    
+    done
+
+    if [ "$vt_freebsd_ver" = "xx" ]; then
+        if [ -e (loop)/boot/kernel/kernel ]; then
+            vt_unix_parse_freebsd_ver_elf (loop)/boot/kernel/kernel $vt_freebsd_bit vt_freebsd_ver
+        fi
+        
+        if [ "$vt_freebsd_ver" = "xx" ]; then
+            set vt_freebsd_ver=13.x        
+        fi
+    fi
 
     if [ -n "${vtdebug_flag}" ]; then
-        echo "This is FreeBSD $vt_freebsd_ver ${vt_freebsd_bit}bit"
+        echo "This is $vtFreeBsdDistro $vt_freebsd_ver ${vt_freebsd_bit}bit"
     fi
     
     unset vt_unix_mod_path
@@ -445,10 +462,6 @@ function ventoy_freebsd_proc {
         fi
     done
     
-    if [ -e (loop)/usr/freebsd-dist/cloninst.sh ]; then
-        set vtFreeBsdDistro=ClonOS
-    fi
-    
     vt_unix_replace_ko $vt_unix_mod_path (vtunix)/ventoy_unix/$vtFreeBsdDistro/geom_ventoy_ko/$vt_freebsd_ver/$vt_freebsd_bit/geom_ventoy.ko.xz
     vt_unix_replace_conf FreeBSD "${1}${chosen_path}"
 }
@@ -522,6 +535,10 @@ function uefi_windows_menu_func {
     vt_windows_chain_data "${1}${chosen_path}"
     ventoy_debug_pause
     
+    if vt_check_mode 4; then
+        vtoy_windows_wimboot_func
+    fi
+    
     if [ -n "$vtoy_chain_mem_addr" ]; then
         ventoy_acpi_param ${vtoy_chain_mem_addr} 2048
         ventoy_cli_console
@@ -646,10 +663,14 @@ function uefi_linux_menu_func {
     if [ -n "$vtoy_chain_mem_addr" ]; then
         ventoy_acpi_param ${vtoy_chain_mem_addr} 2048
         ventoy_cli_console     
-        
-        if [ "$VTOY_EFI_ARCH" != "mips" ]; then
-            chainloader ${vtoy_path}/ventoy_${VTOY_EFI_ARCH}.efi fallback env_param=${env_param} isoefi=${LoadIsoEfiDriver} FirstTry=${FirstTryBootFile} ${vtdebug_flag} mem:${vtoy_chain_mem_addr}:size:${vtoy_chain_mem_size}
-            boot
+
+        if vt_check_mode 3; then
+            ventoy_debug_pause
+        else
+            if [ "$VTOY_EFI_ARCH" != "mips" ]; then
+                chainloader ${vtoy_path}/ventoy_${VTOY_EFI_ARCH}.efi fallback env_param=${env_param} isoefi=${LoadIsoEfiDriver} FirstTry=${FirstTryBootFile} ${vtdebug_flag} mem:${vtoy_chain_mem_addr}:size:${vtoy_chain_mem_size}
+                boot
+            fi
         fi
 
         # fallback
@@ -788,6 +809,86 @@ function uefi_iso_memdisk {
 }
 
 
+function vtoy_windows_wimboot_func {
+    if [ -f (loop)/x86/sources/boot.wim -a -f (loop)/x64/sources/boot.wim ]; then
+        vt_sel_wimboot vtoy_wimboot_bit
+        if [ "$vtoy_wimboot_bit" = "32" ]; then
+            set vtoy_wimboot_prefix=(loop)/x86
+        else
+            set vtoy_wimboot_prefix=(loop)/x64
+        fi
+    else
+        set vtoy_wimboot_prefix=(loop)
+        if vt_is_pe64 $vtoy_wimboot_prefix/setup.exe; then
+            set vtoy_wimboot_bit=64
+        else
+            set vtoy_wimboot_bit=32
+        fi
+    fi
+
+    if [ -n "${vtdebug_flag}" ]; then
+        echo vtoy_wimboot_prefix=$vtoy_wimboot_prefix vtoy_wimboot_bit=$vtoy_wimboot_bit
+    fi
+
+    for wmfile in sources/boot.wim boot/bcd boot/boot.sdi; do
+        if [ ! -f $vtoy_wimboot_prefix/$wmfile ]; then
+            return
+        fi
+    done
+
+    if [ -f $vtoy_wimboot_prefix/sources/install.wim -o -f $vtoy_wimboot_prefix/sources/install.esd ]; then
+        vt_windows_wimboot_data
+    else
+        return
+    fi
+    
+    if [ "$grub_platform" = "pc" ]; then
+        set vt_wimkernel=wimboot.x86_64.xz
+        
+        linux16  "$vtoy_path/$vt_wimkernel"  quiet
+        ventoy_debug_pause
+
+        vt_set_wim_load_prompt 1 "Loading files......"
+        initrd16 newc:vtoyjump.exe:$vtoy_path/vtoyjump${vtoy_wimboot_bit}.exe \
+             newc:wimboot.data:mem:${vtoy_wimboot_mem_addr}:size:${vtoy_wimboot_mem_size} \
+             newc:winpeshl.ini:mem:${vtoy_winpeshl_ini_addr}:size:${vtoy_winpeshl_ini_size} \
+             newc:bcd:$vtoy_wimboot_prefix/boot/bcd \
+             newc:boot.sdi:$vtoy_wimboot_prefix/boot/boot.sdi \
+             newc:boot.wim:$vtoy_wimboot_prefix/sources/boot.wim
+        vt_set_wim_load_prompt 0
+        boot
+    else
+        if [ "$grub_cpu" = "i386" ]; then
+            set vt_wimkernel=wimboot.i386.efi.xz
+        else
+            set vt_wimkernel=wimboot.x86_64.xz
+        fi
+
+        vt_set_wim_load_prompt 1 "Loading files......"
+        vt_load_file_to_mem "nodecompress" $vtoy_wimboot_prefix/sources/boot.wim vtoy_wimfile_mem
+        vt_set_wim_load_prompt 0
+
+        if [ $? -eq 0 ]; then
+            set vtoy_wimfile_path=mem:${vtoy_wimfile_mem_addr}:size:${vtoy_wimfile_mem_size}
+        else
+            set vtoy_wimfile_path=$vtoy_wimboot_prefix/sources/boot.wim
+        fi
+
+        ventoy_cli_console
+        chainloader "$vtoy_path/$vt_wimkernel" quiet \
+            "vf=wimboot.data:mem:${vtoy_wimboot_mem_addr}:size:${vtoy_wimboot_mem_size}" \
+            "vf=winpeshl.ini:mem:${vtoy_winpeshl_ini_addr}:size:${vtoy_winpeshl_ini_size}" \
+            "vf=vtoyjump.exe:$vtoy_path/vtoyjump${vtoy_wimboot_bit}.exe" \
+            "vf=bcd:$vtoy_wimboot_prefix/boot/bcd" \
+            "vf=boot.sdi:$vtoy_wimboot_prefix/boot/boot.sdi" \
+            "vf=boot.wim:$vtoy_wimfile_path" \
+            pfsize=$vtoy_chain_file_size  \
+            pfread=$vtoy_chain_file_read
+        boot
+        ventoy_gui_console
+    fi
+}
+
 function legacy_windows_menu_func {
     vt_windows_reset
     
@@ -816,7 +917,11 @@ function legacy_windows_menu_func {
 
     vt_windows_chain_data "${1}${chosen_path}"
     ventoy_debug_pause    
-    
+
+    if vt_check_mode 4; then
+        vtoy_windows_wimboot_func
+    fi
+
     if [ -n "$vtoy_chain_mem_addr" ]; then
         ventoy_acpi_param ${vtoy_chain_mem_addr} 2048
         linux16   $vtoy_path/ipxe.krn ${vtdebug_flag} ibft mem:${vtoy_chain_mem_addr}:size:${vtoy_chain_mem_size}        
@@ -885,9 +990,39 @@ function legacy_linux_menu_func {
     ventoy_debug_pause
     
     if [ -n "$vtoy_chain_mem_addr" ]; then
-        ventoy_acpi_param ${vtoy_chain_mem_addr} 2048
-        linux16   $vtoy_path/ipxe.krn ${vtdebug_flag}  mem:${vtoy_chain_mem_addr}:size:${vtoy_chain_mem_size}
-        boot
+        if vt_check_mode 3; then
+            ventoy_acpi_param ${vtoy_chain_mem_addr} 2048
+            ventoy_cli_console
+        
+            # fallback
+            set vtback_root=$root        
+            vt_push_last_entry
+            set vtback_theme=$theme
+            unset theme
+            
+            vt_trailer_cpio "$vtoy_iso_part" "$vt_chosen_path" noinit
+            vt_set_boot_opt rdinit=/vtoy/vtoy
+
+            set root=(loop)
+            set vtback_cfg_find=0
+            for cfg in "/boot/grub/grub.cfg" "/EFI/BOOT/grub.cfg" "/EFI/debian/grub.cfg" "EFI/boot/grub.cfg" "efi/boot/grub.cfg" "/grub/grub.cfg" "EFI/BOOT/BOOTX64.conf"; do
+                if [ -e "$cfg" ]; then
+                    set vtback_cfg_find=1
+                    configfile "$cfg"
+                    break
+                fi
+            done
+
+            vt_unset_boot_opt
+            set root=$vtback_root        
+            set theme=$vtback_theme
+            vt_pop_last_entry
+            ventoy_gui_console
+        else
+            ventoy_acpi_param ${vtoy_chain_mem_addr} 2048
+            linux16   $vtoy_path/ipxe.krn ${vtdebug_flag}  mem:${vtoy_chain_mem_addr}:size:${vtoy_chain_mem_size}
+            boot
+        fi
     else
         echo "chain empty failed"
         ventoy_pause
@@ -1030,7 +1165,7 @@ function iso_common_menuentry {
     vt_parse_iso_volume "${vtoy_iso_part}${vt_chosen_path}" vt_system_id vt_volume_id vt_volume_space
     if [ $vt_volume_space -ne $vt_chosen_size ]; then        
         vt_mod $vt_chosen_size 2048 vt_chosen_size_mod
-        if [ $vt_volume_space -gt $vt_chosen_size -o $vt_chosen_size_mod -ne 0 ]; then
+        if [ $vt_chosen_size_mod -ne 0 ]; then
             echo -e "\n $vt_volume_space $vt_chosen_size $vt_chosen_size_mod\n"
             echo -e "\n The size of the iso file \"$vt_chosen_size\" is invalid. File corrupted ?\n"
             echo -e " 此ISO文件的大小 \"$vt_chosen_size\" 有问题，请确认文件是否损坏。\n"
@@ -1183,6 +1318,30 @@ function efi_unsupport_menuentry {
     common_unsupport_menuentry
 }
 
+function vhdboot_common_func {
+    vt_patch_vhdboot "$1"
+    
+    ventoy_debug_pause    
+    
+    if [ -n "$vtoy_vhd_buf_addr" ]; then
+        if [ "$grub_platform" = "pc" ]; then
+            ventoy_cli_console
+            linux16   $vtoy_path/memdisk iso raw    
+            initrd16  mem:${vtoy_vhd_buf_addr}:size:${vtoy_vhd_buf_size}            
+            boot
+            ventoy_gui_console
+        else
+            ventoy_cli_console
+            chainloader ${vtoy_path}/ventoy_${VTOY_EFI_ARCH}.efi memdisk env_param=${env_param} isoefi=${LoadIsoEfiDriver} ${vtdebug_flag} mem:${vtoy_vhd_buf_addr}:size:${vtoy_vhd_buf_size}
+            boot
+            ventoy_gui_console
+        fi
+    else
+        echo "Please put the right ventoy_vhdboot.img file to the 1st partition"
+        ventoy_pause
+    fi
+}
+
 function vhd_common_menuentry {
 
     if [ "$VTOY_VHD_NO_WARNING" != "1" ]; then
@@ -1205,25 +1364,7 @@ function vhd_common_menuentry {
         return
     fi
     
-    vt_patch_vhdboot "$vt_chosen_path"
-    
-    ventoy_debug_pause    
-    
-    if [ -n "$vtoy_vhd_buf_addr" ]; then
-        if [ "$grub_platform" = "pc" ]; then
-            linux16   $vtoy_path/memdisk iso raw    
-            initrd16  mem:${vtoy_vhd_buf_addr}:size:${vtoy_vhd_buf_size}            
-            boot
-        else
-            ventoy_cli_console
-            chainloader ${vtoy_path}/ventoy_${VTOY_EFI_ARCH}.efi memdisk env_param=${env_param} isoefi=${LoadIsoEfiDriver} ${vtdebug_flag} mem:${vtoy_vhd_buf_addr}:size:${vtoy_vhd_buf_size}
-            boot
-            ventoy_gui_console
-        fi        
-    else
-        echo "Please put the right ventoy_vhdboot.img file to the 1st partition"
-        ventoy_pause
-    fi
+    vhdboot_common_func "${vt_chosen_path}"
 }
 
 function vhd_unsupport_menuentry {
@@ -1480,6 +1621,51 @@ function ventoy_img_batocera {
     vt_unset_boot_opt
 }
 
+function ventoy_img_openwrt {
+    if [ -e (vtimghd,2)/lib64 ]; then
+        set ventoy_busybox_ver=64
+    fi
+
+    if [ ! -f ${vtoy_iso_part}/ventoy/ventoy_openwrt.xz ]; then
+        ventoy_gui_console
+        echo -e "\n ventoy_openwrt.xz not found. Please refer https://www.ventoy.net/en/doc_openwrt.html.\n"
+        echo -e " 未找到 ventoy_openwrt.xz 文件。请参考 https://www.ventoy.net/cn/doc_openwrt.html\n"
+        echo -e "\n press ENTER to exit (请按 回车 键返回) ..."
+        read vtInputKey
+        ventoy_cli_console
+        return
+    fi
+
+    if vt_img_check_range "${vtoy_iso_part}${vt_chosen_path}"; then
+        ventoy_debug_pause
+    else
+        ventoy_gui_console
+        echo -e "\n IMG file need processed. Please refer https://www.ventoy.net/en/doc_openwrt.html.\n"
+        echo -e " 此 IMG 文件必须处理之后才能支持。请参考 https://www.ventoy.net/cn/doc_openwrt.html\n"
+        echo -e "\n press ENTER to exit (请按 回车 键返回) ..."
+        read vtInputKey
+        ventoy_cli_console
+        return
+    fi
+    
+
+    vt_load_cpio  $vtoy_path  "${vt_chosen_path}" ${vtoy_iso_part} "busybox=$ventoy_busybox_ver"
+    vt_trailer_cpio ${vtoy_iso_part} "${vt_chosen_path}" noinit
+
+    vt_img_extra_initrd_append  ${vtoy_iso_part}/ventoy/ventoy_openwrt.xz
+    
+
+    #boot image file
+    vt_set_boot_opt rdinit=/vtoy/vtoy ventoyos=openwrt
+    vt_img_hook_root
+    
+    set root=(vtimghd,1)
+    configfile (vtimghd,1)/boot/grub/grub.cfg
+
+    vt_img_unhook_root
+    vt_unset_boot_opt
+}
+
 function ventoy_img_tails {
     vt_load_cpio  $vtoy_path  "${vt_chosen_path}" ${vtoy_iso_part} "busybox=$ventoy_busybox_ver"
     vt_trailer_cpio ${vtoy_iso_part} "${vt_chosen_path}" noinit
@@ -1540,8 +1726,9 @@ function img_common_menuentry {
 
     vt_img_extra_initrd_reset
 
+
     vt_get_fs_label (vtimghd,1) vtImgHd1Label
-    if [ -d (vtimghd,2)/lib ]; then
+    if [ -d (vtimghd,2)/lib ]; then        
         vt_get_fs_label (vtimghd,2) vtImgHd2Label
     fi
     
@@ -1549,6 +1736,7 @@ function img_common_menuentry {
         vt_1st_line (vtimghd,1)/etc/hostname vtImgHostname
     fi
     
+    
     if [ -e (vtimghd,1)/easy.sfs ]; then
         ventoy_img_easyos
     elif [ -e (vtimghd,1)/volumio.initrd ]; then
@@ -1569,6 +1757,8 @@ function img_common_menuentry {
         ventoy_img_recalbox
     elif [ -f (vtimghd,2)/loader/entries/ubos.conf ]; then
         ventoy_img_ubos
+    elif [ -f (vtimghd,2)/etc/openwrt_version ]; then
+        ventoy_img_openwrt
     elif [ -f (vtimghd,1)/efi/boot/mt86.png ]; then 
         if [ "$grub_platform" = "pc" ]; then
             img_unsupport_tip
@@ -1606,7 +1796,7 @@ function img_unsupport_menuentry {
 #############################################################
 #############################################################
 
-set VENTOY_VERSION="1.0.38"
+set VENTOY_VERSION="1.0.45"
 
 #ACPI not compatible with Window7/8, so disable by default
 set VTOY_PARAM_NO_ACPI=1
@@ -1618,6 +1808,8 @@ set VTOY_DEFAULT_MENU_MODE=0
 
 set VTOY_MEM_DISK_STR="[Memdisk]"
 set VTOY_ISO_RAW_STR="Compatible Mode"
+set VTOY_GRUB2_MODE_STR="GRUB2 Mode"
+set VTOY_WIMBOOT_MODE_STR="WIMBOOT Mode"
 set VTOY_ISO_UEFI_DRV_STR="UEFI FS"
 
 set VTOY_F2_CMD="ventoy_power"
@@ -1740,13 +1932,16 @@ elif [ "$vtoy_display_mode" = "serial_console" ]; then
     terminal_output  serial console    
 else    
     if [ -n "$vtoy_theme" ]; then
-        set theme=$vtoy_theme
+        vt_set_theme
     else
         set theme=$prefix/themes/ventoy/theme.txt
     fi
     terminal_output  gfxterm
 fi
 
+if [ -n "$VTOY_DEFAULT_KBD_LAYOUT" ]; then
+    set_keyboard_layout "$VTOY_DEFAULT_KBD_LAYOUT"
+fi
 
 if [ -n "$VTOY_PLUGIN_SYNTAX_ERROR" ]; then
     clear
@@ -1766,6 +1961,8 @@ for vtTFile in ventoy.json ventoy_grub.cfg; do
     fi
 done
 
+#clear all input key before show main menu
+vt_clear_key
 
 #export necessary variable
 export theme
@@ -1774,6 +1971,7 @@ export gfxpayload
 export vtoydev
 export vtoy_path
 export vtdebug_flag
+export vtoy_iso_fs
 export vtoy_iso_part
 export vtoy_efi_part
 export VENTOY_VERSION

INSTALL/grub/i386-efi/command.lst

@@ -43,6 +43,7 @@
 *save_env: loadenv
 *search: search
 *serial: serial
+*set_keyboard_layout: setkey
 *setkey: setkey
 *setpci: setpci
 *sha1sum: hashsum

INSTALL/grub/i386-efi/moddep.lst

@@ -1,7 +1,7 @@
 videotest: font video gfxmenu
-setkey: extcmd
 odc: archelp
 loopback: extcmd
+setkey: extcmd
 macho:
 gcry_des: crypto
 memrw: extcmd
@@ -26,7 +26,7 @@ sfs: fshelp
 reiserfs: fshelp
 part_sunpc:
 zstd:
-gfxmenu: video_colors trig bitmap_scale gfxterm font normal bitmap video
+gfxmenu: trig video_colors bitmap_scale gfxterm font normal bitmap video
 backtrace:
 jfs:
 help: extcmd normal
@@ -82,7 +82,7 @@ gfxterm_background: video_colors bitmap_scale gfxterm extcmd video bitmap
 search_fs_uuid:
 gcry_dsa: pgp mpi
 keystatus: extcmd
-linux: verifiers video boot relocator mmap
+linux: ventoy verifiers video boot relocator mmap
 geli: cryptodisk crypto gcry_sha512 pbkdf2 gcry_sha256
 cmdline_cat_test: font functional_test normal procfs video_fb
 rdmsr: extcmd
@@ -120,7 +120,7 @@ ehci: cs5536 usb boot
 crypto:
 part_bsd: part_msdos
 cs5536:
-ventoy: ext2 fshelp btrfs font crypto gcry_md5 exfat udf extcmd normal video gcry_sha1 iso9660
+ventoy: elf fshelp ext2 btrfs font crypto gcry_md5 exfat udf extcmd datetime div normal video gcry_sha1 iso9660
 gcry_sha512: crypto
 password: crypto normal
 fshelp:

INSTALL/grub/i386-pc/command.lst

@@ -47,6 +47,7 @@
 *search: search
 *sendkey: sendkey
 *serial: serial
+*set_keyboard_layout: setkey
 *setkey: setkey
 *setpci: setpci
 *sha1sum: hashsum

INSTALL/grub/i386-pc/moddep.lst

@@ -1,7 +1,7 @@
 videotest: font video gfxmenu
-setkey: extcmd
 odc: archelp
 loopback: extcmd
+setkey: extcmd
 macho:
 gcry_des: crypto
 memrw: extcmd
@@ -26,7 +26,7 @@ sfs: fshelp
 reiserfs: fshelp
 part_sunpc:
 zstd:
-gfxmenu: video_colors trig bitmap_scale gfxterm font normal bitmap video
+gfxmenu: trig video_colors bitmap_scale gfxterm font normal bitmap video
 backtrace:
 jfs:
 help: extcmd normal
@@ -82,7 +82,7 @@ gfxterm_background: video_colors bitmap_scale gfxterm extcmd video bitmap
 search_fs_uuid:
 gcry_dsa: pgp mpi
 keystatus: extcmd
-linux: verifiers normal vbe video boot relocator mmap
+linux: ventoy verifiers normal vbe video boot relocator mmap
 geli: cryptodisk crypto gcry_sha512 pbkdf2 gcry_sha256
 cmdline_cat_test: font functional_test normal procfs video_fb
 rdmsr: extcmd
@@ -123,7 +123,7 @@ crypto:
 part_bsd: part_msdos
 cs5536: pci
 biosdisk:
-ventoy: ext2 fshelp btrfs font crypto gcry_md5 exfat udf extcmd normal video gcry_sha1 iso9660 acpi
+ventoy: elf fshelp ext2 btrfs font crypto gcry_md5 exfat udf datetime div extcmd normal video gcry_sha1 iso9660 acpi
 lsapm:
 gcry_sha512: crypto
 password: crypto normal

INSTALL/grub/keyboard.cfg

@@ -0,0 +1,62 @@
+submenu "Keyboard Layouts" --class=debug_krdlayout --class=F5tool {
+    menuentry QWERTY_USA --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout QWERTY_USA
+    }
+    menuentry AZERTY --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout AZERTY
+    }
+    menuentry CZECH_QWERTY --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout CZECH_QWERTY
+    }
+    menuentry CZECH_QWERTZ --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout CZECH_QWERTZ
+    }
+    menuentry DANISH --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout DANISH
+    }
+    menuentry DVORAK_USA --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout DVORAK_USA
+    }
+    menuentry FRENCH --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout FRENCH
+    }
+    menuentry GERMAN --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout GERMAN
+    }
+    menuentry ITALIANO --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout ITALIANO
+    }
+    menuentry JAPAN_106 --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout JAPAN_106
+    }
+    menuentry LATIN_USA --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout LATIN_USA
+    }
+    menuentry PORTU_BRAZIL --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout PORTU_BRAZIL
+    }
+    menuentry QWERTY_UK --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout QWERTY_UK
+    }
+    menuentry QWERTZ --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout QWERTZ
+    }
+    menuentry QWERTZ_HUN --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout QWERTZ_HUN
+    }
+    menuentry QWERTZ_SLOV_CROAT --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout QWERTZ_SLOV_CROAT
+    }
+    menuentry SPANISH --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout SPANISH
+    }
+    menuentry SWEDISH --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout SWEDISH
+    }
+    menuentry TURKISH_Q --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout TURKISH_Q
+    }
+    menuentry VIETNAMESE --class=debug_kbd --class=debug_krdlayout --class=F5tool {
+        set_keyboard_layout VIETNAMESE
+    }
+}

INSTALL/grub/localboot.cfg

@@ -1,6 +1,6 @@
 
 if [ "$grub_platform" = "pc" ]; then
-    menuentry 'Search and boot Windows' --class=boot_windows {
+    menuentry 'Search and boot Windows' --class=boot_windows --class=F4boot {
     
         set partid=3
         while [ $partid -le 128 ]; do
@@ -38,7 +38,7 @@ if [ "$grub_platform" = "pc" ]; then
         fi        
     }
     
-    menuentry 'Search and boot Grub4dos' --class=boot_g4d {
+    menuentry 'Search and boot Grub4dos' --class=boot_g4d --class=F4boot {
         if search -n -s -f /grldr; then
             ntldr /grldr
         else
@@ -46,19 +46,19 @@ if [ "$grub_platform" = "pc" ]; then
         fi        
     }
     
-    menuentry 'Boot the 1st local disk' --class=boot_disk {
+    menuentry 'Boot the 1st local disk' --class=boot_disk --class=F4boot {
         set root=(hd0,1)
         chainloader +1
         boot
     }
     
-    menuentry 'Boot the 2nd local disk' --class=boot_disk {
+    menuentry 'Boot the 2nd local disk' --class=boot_disk --class=F4boot {
         set root=(hd1,1)
         chainloader +1
         boot
     }
     
-    menuentry 'Boot the 3rd local disk' --class=boot_disk {
+    menuentry 'Boot the 3rd local disk' --class=boot_disk --class=F4boot {
         set root=(hd2,1)
         chainloader +1
         boot
@@ -66,7 +66,7 @@ if [ "$grub_platform" = "pc" ]; then
     
 else
 
-    menuentry 'Search and boot Windows' --class=boot_windows {    
+    menuentry 'Search and boot Windows' --class=boot_windows --class=F4boot {    
         
         set partid=3
         while [ $partid -le 128 ]; do
@@ -93,7 +93,7 @@ else
     }
     
     if [ "$grub_cpu" = "i386" ]; then
-        menuentry 'Search and boot BOOTIA32.EFI' --class=boot_uefi {
+        menuentry 'Search and boot BOOTIA32.EFI' --class=boot_uefi --class=F4boot {
             set VTOY_SEARCH_NO_VTOYEFI=1
             if search -n -s -f /efi/boot/bootia32.efi; then
                 unset VTOY_SEARCH_NO_VTOYEFI
@@ -106,7 +106,7 @@ else
             fi        
         }
     elif [ "$grub_cpu" = "arm64" ]; then
-        menuentry 'Search and boot BOOTAA64.EFI' --class=boot_uefi {
+        menuentry 'Search and boot BOOTAA64.EFI' --class=boot_uefi --class=F4boot {
             set VTOY_SEARCH_NO_VTOYEFI=1
             if search -n -s -f /efi/boot/bootaa64.efi; then
                 unset VTOY_SEARCH_NO_VTOYEFI
@@ -119,7 +119,7 @@ else
             fi        
         }
     else
-        menuentry 'Search and boot BOOTX64.EFI' --class=boot_uefi {
+        menuentry 'Search and boot BOOTX64.EFI' --class=boot_uefi --class=F4boot {
             set VTOY_SEARCH_NO_VTOYEFI=1
             if search -n -s -f /efi/boot/bootx64.efi; then
                 unset VTOY_SEARCH_NO_VTOYEFI

INSTALL/grub/themes/ventoy/theme.txt

@@ -70,6 +70,22 @@ terminal-box: "terminal_box_*.png"
 }
 
 
++ hbox{ 
+    left = 30%+200
+    top = 95%-50
+    width = 10%
+    height = 25
+    + label {text = "@VTOY_GRUB2_MODE@" color = "red" align = "left"} 
+}
+
++ hbox{ 
+    left = 30%+200
+    top = 95%-25
+    width = 10%
+    height = 25
+    + label {text = "@VTOY_WIMBOOT_MODE@" color = "red" align = "left"} 
+}
+
 + hbox{ 
     left = 90%
     top = 55 

INSTALL/grub/x86_64-efi/command.lst

@@ -43,6 +43,7 @@
 *save_env: loadenv
 *search: search
 *serial: serial
+*set_keyboard_layout: setkey
 *setkey: setkey
 *setpci: setpci
 *sha1sum: hashsum

INSTALL/grub/x86_64-efi/moddep.lst

@@ -1,7 +1,7 @@
 videotest: font video gfxmenu
-setkey: extcmd
 odc: archelp
 loopback: extcmd
+setkey: extcmd
 macho:
 gcry_des: crypto
 memrw: extcmd
@@ -26,7 +26,7 @@ sfs: fshelp
 reiserfs: fshelp
 part_sunpc:
 zstd:
-gfxmenu: video_colors trig bitmap_scale gfxterm font normal bitmap video
+gfxmenu: trig video_colors bitmap_scale gfxterm font normal bitmap video
 backtrace:
 jfs:
 help: extcmd normal
@@ -81,7 +81,7 @@ gfxterm_background: video_colors bitmap_scale gfxterm extcmd video bitmap
 search_fs_uuid:
 gcry_dsa: pgp mpi
 keystatus: extcmd
-linux: verifiers video boot relocator mmap
+linux: ventoy verifiers video boot relocator mmap
 geli: cryptodisk crypto gcry_sha512 pbkdf2 gcry_sha256
 cmdline_cat_test: font functional_test normal procfs video_fb
 rdmsr: extcmd
@@ -120,7 +120,7 @@ ehci: cs5536 usb boot
 crypto:
 part_bsd: part_msdos
 cs5536:
-ventoy: ext2 fshelp btrfs font crypto gcry_md5 exfat udf extcmd normal video gcry_sha1 iso9660
+ventoy: elf fshelp ext2 btrfs font crypto gcry_md5 exfat udf extcmd datetime div normal video gcry_sha1 iso9660
 gcry_sha512: crypto
 password: crypto normal
 fshelp:

INSTALL/plugin/ventoy/theme/theme.txt

@@ -70,6 +70,22 @@ terminal-box: "terminal_box_*.png"
 }
 
 
++ hbox{ 
+    left = 30%+200
+    top = 95%-50
+    width = 10%
+    height = 25
+    + label {text = "@VTOY_GRUB2_MODE@" color = "red" align = "left"} 
+}
+
++ hbox{ 
+    left = 30%+200
+    top = 95%-25
+    width = 10%
+    height = 25
+    + label {text = "@VTOY_WIMBOOT_MODE@" color = "red" align = "left"} 
+}
+
 + hbox{ 
     left = 90%
     top = 55 

INSTALL/tool/VentoyWorker.sh

@@ -365,11 +365,15 @@ else
     
     oldver=$(get_disk_ventoy_version $DISK)
     if [ $? -ne 0 ]; then
-        vtwarn "$DISK does not contain Ventoy or data corrupted"
-        echo ""
-        vtwarn "Please use -i option if you want to install ventoy to $DISK"
-        echo ""
-        exit 1
+        if is_disk_contains_ventoy $DISK; then
+            oldver="Unknown"
+        else
+            vtwarn "$DISK does not contain Ventoy or data corrupted"
+            echo ""
+            vtwarn "Please use -i option if you want to install ventoy to $DISK"
+            echo ""
+            exit 1
+        fi
     fi
 
     #reserve secure boot option

INSTALL/ventoy_pack.sh

@@ -27,6 +27,10 @@ sh mkcpio.sh
 sh mkloopex.sh
 cd -
 
+cd ../Unix
+sh pack_unix.sh
+cd -
+
 cd ../LinuxGUI
 sh language.sh || exit 1
 sh build.sh
@@ -78,6 +82,7 @@ cp $OPT ./tool/i386/mount.exfat-fuse     $tmpmnt/tool/mount.exfat-fuse_i386
 cp $OPT ./tool/x86_64/mount.exfat-fuse   $tmpmnt/tool/mount.exfat-fuse_x86_64
 cp $OPT ./tool/aarch64/mount.exfat-fuse  $tmpmnt/tool/mount.exfat-fuse_aarch64
 
+
 rm -f $tmpmnt/grub/i386-pc/*.img
 
 
@@ -101,11 +106,13 @@ cp $OPT VentoyWebDeepin.sh $tmpdir/
 cp $OPT README $tmpdir/
 cp $OPT plugin $tmpdir/
 cp $OPT CreatePersistentImg.sh $tmpdir/
+cp $OPT ExtendPersistentImg.sh $tmpdir/
 dos2unix -q $tmpdir/Ventoy2Disk.sh
 dos2unix -q $tmpdir/VentoyWeb.sh
 dos2unix -q $tmpdir/VentoyWebDeepin.sh
 #dos2unix -q $tmpdir/Ventoy.desktop
 dos2unix -q $tmpdir/CreatePersistentImg.sh
+dos2unix -q $tmpdir/ExtendPersistentImg.sh
 
 cp $OPT ../LinuxGUI/WebUI $tmpdir/
 sed 's/.*SCRIPT_DEL_THIS \(.*\)/\1/g' -i $tmpdir/WebUI/index.html
@@ -146,7 +153,7 @@ tar -czvf ventoy-${curver}-linux.tar.gz $tmpdir
 
 rm -f ventoy-${curver}-windows.zip
 cp $OPT Ventoy2Disk*.exe $tmpdir/
-cp $OPT $LANG_DIR/languages.ini $tmpdir/ventoy/
+cp $OPT $LANG_DIR/languages.json $tmpdir/ventoy/
 rm -rf $tmpdir/tool
 rm -f $tmpdir/*.sh
 rm -rf $tmpdir/WebUI

IPXE/ipxe_mod_code/ipxe-3fe683e/src/arch/x86/core/ventoy_vdisk.c

@@ -386,6 +386,7 @@ int ventoy_vdisk_read(struct san_device *sandev, uint64_t lba, unsigned int coun
     uint32_t lbacount = 0;
     unsigned long lastbuffer;
     uint64_t readend;
+    uint64_t VirtSec;
     ventoy_virt_chunk *node;
     ventoy_sector_flag *cur_flag;
     ventoy_sector_flag *sector_flag = g_sector_flag;
@@ -401,6 +402,19 @@ int ventoy_vdisk_read(struct san_device *sandev, uint64_t lba, unsigned int coun
 
     if (g_hddmode)
     {
+        #if 0
+        /* need to check ?? */
+        lastlba = g_chain->virt_img_size_in_bytes / 512;
+        if (lba < lastlba)
+        {
+            if (lba + count > lastlba)
+            {
+                count = lastlba - lba;
+            }
+            ventoy_vdisk_read_real_hdd(lba, count, buffer);
+        }
+        #endif
+        
         ventoy_vdisk_read_real_hdd(lba, count, buffer);
         ix86->regs.dl = sandev->drive;
         return 0;
@@ -419,6 +433,33 @@ int ventoy_vdisk_read(struct san_device *sandev, uint64_t lba, unsigned int coun
         ix86->regs.dl = sandev->drive;
         return 0;
     }
+    else if ((lba * 2048) < g_chain->real_img_size_in_bytes)
+    {
+        /* fix for grub4dos Inconsistent data read from error */
+        memset((void *)(buffer + (count - 1) * 2048), 0, 2048);
+        
+        count = (g_chain->real_img_size_in_bytes / 2048) - lba;
+        ventoy_vdisk_read_real(lba, count, buffer);
+        ix86->regs.dl = sandev->drive;
+
+        lba += count;
+        buffer += count * 2048;
+        count = (readend - g_chain->real_img_size_in_bytes) / 2048;
+    }
+
+    VirtSec = g_chain->virt_img_size_in_bytes / 2048;    
+    if (lba >= VirtSec)
+    {
+        /* fix for grub4dos Inconsistent data read from error */
+        memset((void *)(buffer + (count - 1) * 2048), 0, 2048);
+        
+        ix86->regs.dl = sandev->drive;
+        return 0;
+    }
+    else if (lba + count > VirtSec)
+    {
+        count = VirtSec - lba;
+    }
 
     if (count > sizeof(g_sector_flag))
     {

KBD/keyboard_layout.c

@@ -0,0 +1,795 @@
+
+#define ventoy_keyboard_set_layout(name) if (grub_strcmp(layout, #name) == 0) return ventoy_keyboard_layout_##name()
+
+static void ventoy_keyboard_layout_QWERTY_USA(void) {
+    grub_keymap_reset();
+    grub_keymap_disable();
+}
+static void ventoy_keyboard_layout_AZERTY(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("a", "q"); 
+grub_keymap_add_by_string("A", "Q"); 
+grub_keymap_add_by_string("z", "w"); 
+grub_keymap_add_by_string("Z", "W"); 
+grub_keymap_add_by_string("q", "a"); 
+grub_keymap_add_by_string("Q", "A"); 
+grub_keymap_add_by_string("m", "semicolon"); 
+grub_keymap_add_by_string("M", "colon"); 
+grub_keymap_add_by_string("w", "z"); 
+grub_keymap_add_by_string("W", "Z"); 
+grub_keymap_add_by_string("comma", "m"); 
+grub_keymap_add_by_string("question", "M"); 
+grub_keymap_add_by_string("semicolon", "comma"); 
+grub_keymap_add_by_string("period", "less"); 
+grub_keymap_add_by_string("colon", "period"); 
+grub_keymap_add_by_string("slash", "greater"); 
+grub_keymap_add_by_string("exclam", "slash"); 
+grub_keymap_add_by_string("dollar", "bracketright"); 
+grub_keymap_add_by_string("asterisk", "backslash"); 
+grub_keymap_add_by_string("percent", "doublequote"); 
+grub_keymap_add_by_string("ampersand", "1"); 
+grub_keymap_add_by_string("1", "exclam"); 
+grub_keymap_add_by_string("tilde", "2"); 
+grub_keymap_add_by_string("2", "at"); 
+grub_keymap_add_by_string("doublequote", "3"); 
+grub_keymap_add_by_string("3", "numbersign"); 
+grub_keymap_add_by_string("quote", "4"); 
+grub_keymap_add_by_string("4", "dollar"); 
+grub_keymap_add_by_string("parenleft", "5"); 
+grub_keymap_add_by_string("5", "percent"); 
+grub_keymap_add_by_string("minus", "6"); 
+grub_keymap_add_by_string("6", "caret"); 
+grub_keymap_add_by_string("backquote", "7"); 
+grub_keymap_add_by_string("7", "ampersand"); 
+grub_keymap_add_by_string("underscore", "8"); 
+grub_keymap_add_by_string("8", "asterisk"); 
+grub_keymap_add_by_string("caret", "9"); 
+grub_keymap_add_by_string("9", "parenleft"); 
+grub_keymap_add_by_string("at", "0"); 
+grub_keymap_add_by_string("0", "parenright"); 
+grub_keymap_add_by_string("parenright", "minus"); 
+grub_keymap_add_by_string("less", "backquote"); 
+grub_keymap_add_by_string("greater", "tilde"); 
+grub_keymap_add_by_string("numbersign", "braceright"); 
+grub_keymap_add_by_string("backslash", "question"); 
+grub_keymap_add_by_string("bracketright", "braceleft"); 
+grub_keymap_add_by_string("braceleft", "quote"); 
+grub_keymap_add_by_string("braceright", "underscore"); 
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_CZECH_QWERTY(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("semicolon", "backquote");
+grub_keymap_add_by_string("plus", "1");
+grub_keymap_add_by_string("equal", "minus");
+grub_keymap_add_by_string("quote", "equal");
+grub_keymap_add_by_string("parenright", "bracketright");
+grub_keymap_add_by_string("doublequote", "backslash");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("1", "exclam");
+grub_keymap_add_by_string("2", "at");
+grub_keymap_add_by_string("3", "numbersign");
+grub_keymap_add_by_string("4", "dollar");
+grub_keymap_add_by_string("5", "percent");
+grub_keymap_add_by_string("6", "caret");
+grub_keymap_add_by_string("7", "ampersand");
+grub_keymap_add_by_string("8", "asterisk");
+grub_keymap_add_by_string("9", "parenleft");
+grub_keymap_add_by_string("0", "parenright");
+grub_keymap_add_by_string("percent", "underscore");
+grub_keymap_add_by_string("slash", "braceleft");
+grub_keymap_add_by_string("parenleft", "braceright");
+grub_keymap_add_by_string("doublequote", "colon");
+grub_keymap_add_by_string("exclam", "doublequote");
+grub_keymap_add_by_string("quote", "bar");
+grub_keymap_add_by_string("question", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("backquote", "Abackquote");
+grub_keymap_add_by_string("exclam", "A1");
+grub_keymap_add_by_string("at", "A2");
+grub_keymap_add_by_string("numbersign", "A3");
+grub_keymap_add_by_string("dollar", "A4");
+grub_keymap_add_by_string("percent", "A5");
+grub_keymap_add_by_string("caret", "A6");
+grub_keymap_add_by_string("ampersand", "A7");
+grub_keymap_add_by_string("asterisk", "A8");
+grub_keymap_add_by_string("parenleft", "A9");
+grub_keymap_add_by_string("parenright", "A0");
+grub_keymap_add_by_string("minus", "Aminus");
+grub_keymap_add_by_string("equal", "Aequal");
+grub_keymap_add_by_string("bracketleft", "Abracketleft");
+grub_keymap_add_by_string("bracketright", "Abracketright");
+grub_keymap_add_by_string("semicolon", "Asemicolon");
+grub_keymap_add_by_string("backslash", "Abackslash");
+grub_keymap_add_by_string("less", "Acomma");
+grub_keymap_add_by_string("greater", "Aperiod");
+grub_keymap_add_by_string("slash", "Aslash");
+grub_keymap_add_by_string("tilde", "Atilde");
+grub_keymap_add_by_string("underscore", "Aunderscore");
+grub_keymap_add_by_string("plus", "Aplus");
+grub_keymap_add_by_string("braceleft", "Abraceleft");
+grub_keymap_add_by_string("braceright", "Abraceright");
+grub_keymap_add_by_string("caret", "Adoublequote");
+grub_keymap_add_by_string("colon", "Acolon");
+grub_keymap_add_by_string("question", "Aquestion");
+grub_keymap_add_by_string("bar", "Abar");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_CZECH_QWERTZ(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("y", "z"); 
+grub_keymap_add_by_string("z", "y"); 
+grub_keymap_add_by_string("Y", "Z"); 
+grub_keymap_add_by_string("Z", "Y");
+grub_keymap_add_by_string("semicolon", "backquote");
+grub_keymap_add_by_string("plus", "1");
+grub_keymap_add_by_string("equal", "minus");
+grub_keymap_add_by_string("quote", "equal");
+grub_keymap_add_by_string("parenright", "bracketright");
+grub_keymap_add_by_string("doublequote", "backslash");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("1", "exclam");
+grub_keymap_add_by_string("2", "at");
+grub_keymap_add_by_string("3", "numbersign");
+grub_keymap_add_by_string("4", "dollar");
+grub_keymap_add_by_string("5", "percent");
+grub_keymap_add_by_string("6", "caret");
+grub_keymap_add_by_string("7", "ampersand");
+grub_keymap_add_by_string("8", "asterisk");
+grub_keymap_add_by_string("9", "parenleft");
+grub_keymap_add_by_string("0", "parenright");
+grub_keymap_add_by_string("percent", "underscore");
+grub_keymap_add_by_string("slash", "braceleft");
+grub_keymap_add_by_string("parenleft", "braceright");
+grub_keymap_add_by_string("doublequote", "colon");
+grub_keymap_add_by_string("exclam", "doublequote");
+grub_keymap_add_by_string("quote", "bar");
+grub_keymap_add_by_string("question", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("tilde", "A1");
+grub_keymap_add_by_string("caret", "A3");
+grub_keymap_add_by_string("backslash", "Aq");
+grub_keymap_add_by_string("bar", "Aw");
+grub_keymap_add_by_string("bracketleft", "Af");
+grub_keymap_add_by_string("bracketright", "Ag");
+grub_keymap_add_by_string("dollar", "Asemicolon");
+grub_keymap_add_by_string("numbersign", "Ax");
+grub_keymap_add_by_string("ampersand", "Ac");
+grub_keymap_add_by_string("at", "Av");
+grub_keymap_add_by_string("braceleft", "Ab");
+grub_keymap_add_by_string("braceright", "An");
+grub_keymap_add_by_string("less", "Acomma");
+grub_keymap_add_by_string("greater", "Aperiod");
+grub_keymap_add_by_string("asterisk", "Aslash");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_DANISH(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("plus", "minus");
+grub_keymap_add_by_string("quote", "equal");
+grub_keymap_add_by_string("doublequote", "bracketright");
+grub_keymap_add_by_string("quote", "backslash");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("caret", "braceright");
+grub_keymap_add_by_string("asterisk", "bar");
+grub_keymap_add_by_string("backquote", "plus");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("bar", "Atilde");
+grub_keymap_add_by_string("backslash", "Abackquote");
+grub_keymap_add_by_string("greater", "tilde");
+grub_keymap_add_by_string("at", "A2");
+grub_keymap_add_by_string("dollar", "A4");
+grub_keymap_add_by_string("braceleft", "A7");
+grub_keymap_add_by_string("bracketleft", "A8");
+grub_keymap_add_by_string("bracketright", "A9");
+grub_keymap_add_by_string("braceright", "A0");
+grub_keymap_add_by_string("backslash", "Aminus");
+grub_keymap_add_by_string("less", "quote");
+grub_keymap_add_by_string("greater", "doublequote");
+grub_keymap_add_by_string("tilde", "Abracketright");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_DVORAK_USA(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("[", "minus");
+grub_keymap_add_by_string("braceleft", "underscore");
+grub_keymap_add_by_string("quote", "q"); 
+grub_keymap_add_by_string("doublequote", "Q"); 
+grub_keymap_add_by_string("comma", "w"); 
+grub_keymap_add_by_string("less", "W"); 
+grub_keymap_add_by_string("s", "semicolon"); 
+grub_keymap_add_by_string("S", "colon"); 
+grub_keymap_add_by_string("semicolon", "z"); 
+grub_keymap_add_by_string("colon", "Z"); 
+grub_keymap_add_by_string("w", "comma"); 
+grub_keymap_add_by_string("W", "less"); 
+grub_keymap_add_by_string("v", "period"); 
+grub_keymap_add_by_string("z", "greater"); 
+grub_keymap_add_by_string("z", "slash"); 
+grub_keymap_add_by_string("equal", "bracketright"); 
+grub_keymap_add_by_string("backslash", "backslash"); 
+grub_keymap_add_by_string("underscore", "doublequote"); 
+grub_keymap_add_by_string("quote", "q");
+grub_keymap_add_by_string("doublequote", "Q");
+grub_keymap_add_by_string("comma", "w");
+grub_keymap_add_by_string("less", "W");
+grub_keymap_add_by_string("period", "e");
+grub_keymap_add_by_string("greater", "E");
+grub_keymap_add_by_string("p", "r");
+grub_keymap_add_by_string("P", "R");
+grub_keymap_add_by_string("y", "t");
+grub_keymap_add_by_string("Y", "T");
+grub_keymap_add_by_string("f", "y");
+grub_keymap_add_by_string("F", "Y");
+grub_keymap_add_by_string("g", "u");
+grub_keymap_add_by_string("G", "U");
+grub_keymap_add_by_string("c", "c");
+grub_keymap_add_by_string("C", "I");
+grub_keymap_add_by_string("r", "o");
+grub_keymap_add_by_string("R", "O");
+grub_keymap_add_by_string("l", "p");
+grub_keymap_add_by_string("L", "P");
+grub_keymap_add_by_string("bracketright", "equal");
+grub_keymap_add_by_string("braceright", "plus");
+grub_keymap_add_by_string("a", "a");
+grub_keymap_add_by_string("A", "A");
+grub_keymap_add_by_string("o", "s");
+grub_keymap_add_by_string("O", "S");
+grub_keymap_add_by_string("e", "d");
+grub_keymap_add_by_string("E", "D");
+grub_keymap_add_by_string("u", "f");
+grub_keymap_add_by_string("U", "F");
+grub_keymap_add_by_string("i", "g");
+grub_keymap_add_by_string("I", "G");
+grub_keymap_add_by_string("d", "h");
+grub_keymap_add_by_string("D", "H");
+grub_keymap_add_by_string("h", "j");
+grub_keymap_add_by_string("H", "J");
+grub_keymap_add_by_string("t", "k");
+grub_keymap_add_by_string("T", "K");
+grub_keymap_add_by_string("n", "l");
+grub_keymap_add_by_string("N", "L");
+grub_keymap_add_by_string("s", "semicolon");
+grub_keymap_add_by_string("S", "colon");
+grub_keymap_add_by_string("minus", "quote");
+grub_keymap_add_by_string("underscore", "doublequote");
+grub_keymap_add_by_string("semicolon", "z");
+grub_keymap_add_by_string("colon", "Z");
+grub_keymap_add_by_string("q", "x");
+grub_keymap_add_by_string("Q", "X");
+grub_keymap_add_by_string("j", "c");
+grub_keymap_add_by_string("J", "C");
+grub_keymap_add_by_string("k", "v");
+grub_keymap_add_by_string("K", "V");
+grub_keymap_add_by_string("x", "b");
+grub_keymap_add_by_string("X", "B");
+grub_keymap_add_by_string("b", "n");
+grub_keymap_add_by_string("B", "N");
+grub_keymap_add_by_string("w", "comma");
+grub_keymap_add_by_string("W", "less");
+grub_keymap_add_by_string("v", "period");
+grub_keymap_add_by_string("V", "greater");
+grub_keymap_add_by_string("z", "slash");
+grub_keymap_add_by_string("Z", "question");
+grub_keymap_add_by_string("slash", "bracketleft");
+grub_keymap_add_by_string("question", "braceleft");
+grub_keymap_add_by_string("equal", "bracketright");
+grub_keymap_add_by_string("plus", "braceright");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_FRENCH(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("less", "backquote");
+grub_keymap_add_by_string("greater", "tilde");
+grub_keymap_add_by_string("ampersand", "1");
+grub_keymap_add_by_string("1", "exclam");
+grub_keymap_add_by_string("tilde", "2");
+grub_keymap_add_by_string("2", "at");
+grub_keymap_add_by_string("doublequote", "3");
+grub_keymap_add_by_string("3", "numbersign");
+grub_keymap_add_by_string("quote", "4");
+grub_keymap_add_by_string("4", "dollar");
+grub_keymap_add_by_string("parenleft", "5");
+grub_keymap_add_by_string("5", "percent");
+grub_keymap_add_by_string("minus", "6");
+grub_keymap_add_by_string("6", "caret");
+grub_keymap_add_by_string("backquote", "7");
+grub_keymap_add_by_string("7", "ampersand");
+grub_keymap_add_by_string("underscore", "8");
+grub_keymap_add_by_string("8", "asterisk");
+grub_keymap_add_by_string("backslash", "9");
+grub_keymap_add_by_string("9", "parenleft");
+grub_keymap_add_by_string("at", "0");
+grub_keymap_add_by_string("0", "parenright");
+grub_keymap_add_by_string("parenright", "minus");
+grub_keymap_add_by_string("numbersign", "underscore");
+grub_keymap_add_by_string("a", "q");
+grub_keymap_add_by_string("A", "Q");
+grub_keymap_add_by_string("z", "w");
+grub_keymap_add_by_string("Z", "W");
+grub_keymap_add_by_string("caret", "bracketleft");
+grub_keymap_add_by_string("dollar", "bracketright");
+grub_keymap_add_by_string("q", "a");
+grub_keymap_add_by_string("Q", "A");
+grub_keymap_add_by_string("m", "semicolon");
+grub_keymap_add_by_string("M", "colon");
+grub_keymap_add_by_string("bracketleft", "quote");
+grub_keymap_add_by_string("percent", "doublequote");
+grub_keymap_add_by_string("asterisk", "backslash");
+grub_keymap_add_by_string("bracketright", "bar");
+grub_keymap_add_by_string("w", "z");
+grub_keymap_add_by_string("W", "Z");
+grub_keymap_add_by_string("comma", "m");
+grub_keymap_add_by_string("question", "M");
+grub_keymap_add_by_string("semicolon", "comma");
+grub_keymap_add_by_string("period", "less");
+grub_keymap_add_by_string("colon", "period");
+grub_keymap_add_by_string("slash", "greater");
+grub_keymap_add_by_string("exclam", "slash");
+grub_keymap_add_by_string("bar", "question");
+grub_keymap_add_by_string("tilde", "A2");
+grub_keymap_add_by_string("numbersign", "A3");
+grub_keymap_add_by_string("braceleft", "A4");
+grub_keymap_add_by_string("bracketleft", "A5");
+grub_keymap_add_by_string("bar", "A6");
+grub_keymap_add_by_string("quote", "A7");
+grub_keymap_add_by_string("backslash", "A8");
+grub_keymap_add_by_string("caret", "A9");
+grub_keymap_add_by_string("at", "A0");
+grub_keymap_add_by_string("bracketright", "Aminus");
+grub_keymap_add_by_string("braceright", "Aequal");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_GERMAN(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("backslash", "minus");
+grub_keymap_add_by_string("z", "y");
+grub_keymap_add_by_string("Z", "Y");
+grub_keymap_add_by_string("y", "z");
+grub_keymap_add_by_string("Y", "Z");
+grub_keymap_add_by_string("plus", "bracketright");
+grub_keymap_add_by_string("asterisk", "braceright");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("backslash", "Aminus");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("caret", "backquote");
+grub_keymap_add_by_string("quote", "equal");
+grub_keymap_add_by_string("backquote", "plus");
+grub_keymap_add_by_string("braceright", "doublequote");
+grub_keymap_add_by_string("bar", "bracketleft");
+grub_keymap_add_by_string("at", "braceleft");
+grub_keymap_add_by_string("numbersign", "backslash");
+grub_keymap_add_by_string("at", "Aq");
+grub_keymap_add_by_string("less", "backquote");
+grub_keymap_add_by_string("greater", "tilde");
+grub_keymap_add_by_string("braceleft", "A7");
+grub_keymap_add_by_string("bracketleft", "A8");
+grub_keymap_add_by_string("bracketright", "A9");
+grub_keymap_add_by_string("braceright", "A0");
+grub_keymap_add_by_string("tilde", "Abracketright");
+grub_keymap_add_by_string("backslash", "Aminus");
+grub_keymap_add_by_string("quote", "bar");
+grub_keymap_add_by_string("greater", "semicolon");
+grub_keymap_add_by_string("less", "colon");
+grub_keymap_add_by_string("bar", "quote");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_ITALIANO(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("backslash", "backquote");
+grub_keymap_add_by_string("bar", "tilde");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("tilde", "numbersign");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("quote", "minus");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("caret", "plus");
+grub_keymap_add_by_string("bracketleft", "bracketleft");
+grub_keymap_add_by_string("bracketright", "braceleft");
+grub_keymap_add_by_string("plus", "bracketright");
+grub_keymap_add_by_string("asterisk", "braceright");
+grub_keymap_add_by_string("at", "semicolon");
+grub_keymap_add_by_string("braceleft", "colon");
+grub_keymap_add_by_string("numbersign", "quote");
+grub_keymap_add_by_string("braceright", "doublequote");
+grub_keymap_add_by_string("less", "backslash");
+grub_keymap_add_by_string("greater", "bar");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("bracketleft", "Abracketleft");
+grub_keymap_add_by_string("bracketright", "Abracketright");
+grub_keymap_add_by_string("at", "Asemicolon");
+grub_keymap_add_by_string("numbersign", "Aquote");
+grub_keymap_add_by_string("braceright", "Abraceright");
+grub_keymap_add_by_string("braceleft", "Abraceleft");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_JAPAN_106(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("at", "bracketleft");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("quote", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("underscore", "parenright");
+grub_keymap_add_by_string("equal", "underscore");
+grub_keymap_add_by_string("plus", "colon");
+grub_keymap_add_by_string("colon", "quote");
+grub_keymap_add_by_string("asterisk", "doublequote");
+grub_keymap_add_by_string("bracketleft", "bracketright");
+grub_keymap_add_by_string("braceleft", "braceright");
+grub_keymap_add_by_string("bracketright", "backslash");
+grub_keymap_add_by_string("braceright", "bar");
+grub_keymap_add_by_string("backslash", "backquote");
+grub_keymap_add_by_string("tilde", "plus");
+grub_keymap_add_by_string("caret", "equal");
+grub_keymap_add_by_string("backquote", "braceleft");
+grub_keymap_add_by_string("bar", "tilde");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_LATIN_USA(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("bar", "backquote");
+grub_keymap_add_by_string("quote", "minus");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("backquote", "bracketleft");
+grub_keymap_add_by_string("plus", "bracketright");
+grub_keymap_add_by_string("braceleft", "quote");
+grub_keymap_add_by_string("braceright", "backslash");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("asterisk", "braceright");
+grub_keymap_add_by_string("bracketleft", "doublequote");
+grub_keymap_add_by_string("bracketright", "bar");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("caret", "Aquote");
+grub_keymap_add_by_string("doublequote", "braceleft");
+grub_keymap_add_by_string("at", "Aq");
+grub_keymap_add_by_string("backquote", "Abackslash");
+grub_keymap_add_by_string("backslash", "Aminus");
+grub_keymap_add_by_string("greater", "plus");
+grub_keymap_add_by_string("less", "equal");
+grub_keymap_add_by_string("backslash", "Aminus");
+grub_keymap_add_by_string("backquote", "Abackslash");
+grub_keymap_add_by_string("tilde", "Abracketright");
+grub_keymap_add_by_string("caret", "Aquote");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_PORTU_BRAZIL(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("quote", "backquote");
+grub_keymap_add_by_string("quote", "bracketleft");
+grub_keymap_add_by_string("bracketleft", "bracketright");
+grub_keymap_add_by_string("tilde", "quote");
+grub_keymap_add_by_string("bracketright", "backslash");
+grub_keymap_add_by_string("semicolon", "slash");
+grub_keymap_add_by_string("bar", "colon");
+grub_keymap_add_by_string("doublequote", "tilde");
+grub_keymap_add_by_string("backquote", "braceleft");
+grub_keymap_add_by_string("braceleft", "braceright");
+grub_keymap_add_by_string("caret", "doublequote");
+grub_keymap_add_by_string("braceright", "bar");
+grub_keymap_add_by_string("colon", "question");
+grub_keymap_add_by_string("backslash", "semicolon");
+grub_keymap_add_by_string("bar", "Atilde");
+grub_keymap_add_by_string("backslash", "Abackquote");
+grub_keymap_add_by_string("slash", "Aq");
+grub_keymap_add_by_string("question", "Aw");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_QWERTY_UK(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("at", "doublequote");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("tilde", "bar");
+grub_keymap_add_by_string("numbersign", "backslash");
+grub_keymap_add_by_string("backslash", "numbersign");
+grub_keymap_add_by_string("bar", "tilde");
+grub_keymap_add_by_string("backslash", "Atilde");
+grub_keymap_add_by_string("backslash", "Abackquote");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_QWERTZ(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("ampersand", "percent");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("backslash", "minus");
+grub_keymap_add_by_string("z", "y");
+grub_keymap_add_by_string("Z", "Y");
+grub_keymap_add_by_string("y", "z");
+grub_keymap_add_by_string("Y", "Z");
+grub_keymap_add_by_string("plus", "bracketright");
+grub_keymap_add_by_string("asterisk", "braceright");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("caret", "backquote");
+grub_keymap_add_by_string("backquote", "equal");
+grub_keymap_add_by_string("numbersign", "backslash");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("percent", "caret"); 
+grub_keymap_add_by_string("less", "numbersign"); 
+grub_keymap_add_by_string("greater", "bar"); 
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_QWERTZ_HUN(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("y", "z"); 
+grub_keymap_add_by_string("z", "y"); 
+grub_keymap_add_by_string("Y", "Z"); 
+grub_keymap_add_by_string("Z", "Y"); 
+grub_keymap_add_by_string("0", "backquote");
+grub_keymap_add_by_string("quote", "exclam");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("plus", "numbersign");
+grub_keymap_add_by_string("exclam", "dollar");
+grub_keymap_add_by_string("slash", "caret");
+grub_keymap_add_by_string("equal", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk"); 
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("backslash", "Aq");
+grub_keymap_add_by_string("bar", "Aw");
+grub_keymap_add_by_string("bracketleft", "Af"); 
+grub_keymap_add_by_string("bracketright", "Ag");
+grub_keymap_add_by_string("greater", "Az");
+grub_keymap_add_by_string("numbersign", "Ax");
+grub_keymap_add_by_string("ampersand", "Ac");
+grub_keymap_add_by_string("at", "Av");
+grub_keymap_add_by_string("braceleft", "Ab"); 
+grub_keymap_add_by_string("braceright", "An");
+grub_keymap_add_by_string("less", "Am");
+grub_keymap_add_by_string("dollar", "colon");
+grub_keymap_add_by_string("question", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("at", "doublequote");
+grub_keymap_add_by_string("tilde", "A1");
+grub_keymap_add_by_string("caret", "A3");
+grub_keymap_add_by_string("backquote", "A7");
+grub_keymap_add_by_string("asterisk", "0");
+grub_keymap_add_by_string("dollar", "Asemicolon");
+grub_keymap_add_by_string("semicolon", "Acomma");
+grub_keymap_add_by_string("greater", "Aperiod");
+grub_keymap_add_by_string("asterisk", "Aslash");
+grub_keymap_add_by_string("backquote", "A9");
+grub_keymap_add_by_string("doublequote", "A0");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_QWERTZ_SLOV_CROAT(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("quote", "minus");
+grub_keymap_add_by_string("plus", "equal");
+grub_keymap_add_by_string("y", "z");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("doublequote", "tilde");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("asterisk", "plus");
+grub_keymap_add_by_string("Y", "Z");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("tilde", "A1");
+grub_keymap_add_by_string("caret", "A3");
+grub_keymap_add_by_string("backquote", "A7");
+grub_keymap_add_by_string("backslash", "Aq");
+grub_keymap_add_by_string("bar", "Aw");
+grub_keymap_add_by_string("bracketleft", "Af");
+grub_keymap_add_by_string("bracketright", "Ag");
+grub_keymap_add_by_string("at", "Av");
+grub_keymap_add_by_string("braceleft", "Ab");
+grub_keymap_add_by_string("braceright", "An");
+grub_keymap_add_by_string("less", "Acomma");
+grub_keymap_add_by_string("greater", "Aperiod");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_SPANISH(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("caret", "braceleft");
+grub_keymap_add_by_string("asterisk", "braceright");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("quote", "minus");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("greater", "bar");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("backslash", "backquote");
+grub_keymap_add_by_string("less", "backslash");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("backquote", "bracketleft");
+grub_keymap_add_by_string("plus", "bracketright");
+grub_keymap_add_by_string("plus", "colon");
+grub_keymap_add_by_string("at", "semicolon");
+grub_keymap_add_by_string("bar", "A1");
+grub_keymap_add_by_string("at", "A2");
+grub_keymap_add_by_string("numbersign", "A3");
+grub_keymap_add_by_string("tilde", "A4");
+grub_keymap_add_by_string("bracketleft", "Abracketleft");
+grub_keymap_add_by_string("bracketright", "Abracketright");
+grub_keymap_add_by_string("braceleft", "Aquote");
+grub_keymap_add_by_string("braceright", "Abackslash");
+grub_keymap_add_by_string("greater", "bar");
+grub_keymap_add_by_string("less", "backslash");
+grub_keymap_add_by_string("backslash", "Abackquote");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_SWEDISH(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("plus", "minus");
+grub_keymap_add_by_string("quote", "equal");
+grub_keymap_add_by_string("doublequote", "bracketright");
+grub_keymap_add_by_string("quote", "backslash");
+grub_keymap_add_by_string("minus", "slash");
+grub_keymap_add_by_string("doublequote", "at");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("caret", "braceright");
+grub_keymap_add_by_string("asterisk", "bar");
+grub_keymap_add_by_string("backquote", "plus");
+grub_keymap_add_by_string("semicolon", "less");
+grub_keymap_add_by_string("colon", "greater");
+grub_keymap_add_by_string("underscore", "question");
+grub_keymap_add_by_string("bar", "Atilde");
+grub_keymap_add_by_string("backslash", "Abackquote");
+grub_keymap_add_by_string("greater", "tilde");
+grub_keymap_add_by_string("at", "A2");
+grub_keymap_add_by_string("dollar", "A4");
+grub_keymap_add_by_string("braceleft", "A7");
+grub_keymap_add_by_string("bracketleft", "A8");
+grub_keymap_add_by_string("bracketright", "A9");
+grub_keymap_add_by_string("braceright", "A0");
+grub_keymap_add_by_string("backslash", "Aminus");
+grub_keymap_add_by_string("less", "quote");
+grub_keymap_add_by_string("greater", "doublequote");
+grub_keymap_add_by_string("tilde", "Abracketright");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_TURKISH_Q(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("doublequote", "backquote");
+grub_keymap_add_by_string("asterisk", "minus");
+grub_keymap_add_by_string("minus", "equal");
+grub_keymap_add_by_string("comma", "backslash");
+grub_keymap_add_by_string("period", "slash");
+grub_keymap_add_by_string("quote", "at");
+grub_keymap_add_by_string("caret", "numbersign");
+grub_keymap_add_by_string("plus", "dollar");
+grub_keymap_add_by_string("ampersand", "caret");
+grub_keymap_add_by_string("slash", "ampersand");
+grub_keymap_add_by_string("parenleft", "asterisk");
+grub_keymap_add_by_string("parenright", "parenleft");
+grub_keymap_add_by_string("equal", "parenright");
+grub_keymap_add_by_string("question", "underscore");
+grub_keymap_add_by_string("underscore", "plus");
+grub_keymap_add_by_string("semicolon", "bar");
+grub_keymap_add_by_string("colon", "question");
+grub_keymap_add_by_string("less", "Abackquote");
+grub_keymap_add_by_string("greater", "A1");
+grub_keymap_add_by_string("numbersign", "A3");
+grub_keymap_add_by_string("dollar", "A4");
+grub_keymap_add_by_string("braceleft", "A7");
+grub_keymap_add_by_string("bracketleft", "A8");
+grub_keymap_add_by_string("bracketright", "A9");
+grub_keymap_add_by_string("braceright", "A0");
+grub_keymap_add_by_string("backslash", "Aminus");
+grub_keymap_add_by_string("bar", "Aequal");
+grub_keymap_add_by_string("at", "Aq");
+grub_keymap_add_by_string("doublequote", "Abracketleft");
+grub_keymap_add_by_string("tilde", "Abracketright");
+grub_keymap_enable();
+}
+static void ventoy_keyboard_layout_VIETNAMESE(void) {
+grub_keymap_reset();
+grub_keymap_add_by_string("exclam", "A1");
+grub_keymap_add_by_string("at", "A2");
+grub_keymap_add_by_string("numbersign", "A3");
+grub_keymap_add_by_string("dollar", "A4");
+grub_keymap_add_by_string("percent", "A5");
+grub_keymap_add_by_string("caret", "A6");
+grub_keymap_add_by_string("ampersand", "A7");
+grub_keymap_add_by_string("asterisk", "A8");
+grub_keymap_add_by_string("parenleft", "A9");
+grub_keymap_add_by_string("parenright", "A0");
+grub_keymap_add_by_string("plus", "Aplus");
+grub_keymap_add_by_string("equal", "Aequal");
+grub_keymap_add_by_string("braceleft", "Abraceleft");
+grub_keymap_add_by_string("braceright", "Abraceright");
+grub_keymap_add_by_string("colon", "Acolon");
+grub_keymap_add_by_string("semicolon", "Asemicolon");
+grub_keymap_add_by_string("quote", "Aquote");
+grub_keymap_add_by_string("backslash", "Abackslash");
+grub_keymap_add_by_string("less", "Aless");
+grub_keymap_add_by_string("greater", "Agreater");
+grub_keymap_add_by_string("comma", "Acomma");
+grub_keymap_add_by_string("period", "Aperiod");
+grub_keymap_add_by_string("question", "Aquestion");
+grub_keymap_add_by_string("slash", "Aslash");
+grub_keymap_add_by_string("tilde", "Atilde");
+grub_keymap_add_by_string("backquote", "Abackquote");
+grub_keymap_add_by_string("bracketright", "Abracketright");
+grub_keymap_add_by_string("bracketleft", "Abracketleft");
+grub_keymap_add_by_string("bar", "Abar");
+grub_keymap_add_by_string("doublequote", "Adoublequote");
+grub_keymap_add_by_string("colon", "Acolon");
+grub_keymap_add_by_string("minus", "Aminus");
+grub_keymap_add_by_string("underscore", "Aunderscore");
+grub_keymap_enable();
+}
+void ventoy_set_keyboard_layout(const char *layout);
+void ventoy_set_keyboard_layout(const char *layout) {
+ventoy_keyboard_set_layout(QWERTY_USA);
+ventoy_keyboard_set_layout(AZERTY);
+ventoy_keyboard_set_layout(CZECH_QWERTY);
+ventoy_keyboard_set_layout(CZECH_QWERTZ);
+ventoy_keyboard_set_layout(DANISH);
+ventoy_keyboard_set_layout(DVORAK_USA);
+ventoy_keyboard_set_layout(FRENCH);
+ventoy_keyboard_set_layout(GERMAN);
+ventoy_keyboard_set_layout(ITALIANO);
+ventoy_keyboard_set_layout(JAPAN_106);
+ventoy_keyboard_set_layout(LATIN_USA);
+ventoy_keyboard_set_layout(PORTU_BRAZIL);
+ventoy_keyboard_set_layout(QWERTY_UK);
+ventoy_keyboard_set_layout(QWERTZ);
+ventoy_keyboard_set_layout(QWERTZ_HUN);
+ventoy_keyboard_set_layout(QWERTZ_SLOV_CROAT);
+ventoy_keyboard_set_layout(SPANISH);
+ventoy_keyboard_set_layout(SWEDISH);
+ventoy_keyboard_set_layout(TURKISH_Q);
+ventoy_keyboard_set_layout(VIETNAMESE);
+}

KBD/mkconfig.sh

@@ -4,12 +4,13 @@
 # Configfiles are from grubfilemanager project
 #
 
-cfgfile=../INSTALL/grub/keyboard.cfg
-rm -f ${cfgfile}.gz
-
-echo "submenu \"Keyboard Layouts\" --class=debug_krdlayout {" >>$cfgfile
+cfgfile=keyboard_layout.c
+rm -f ${cfgfile}
 
 cat >>$cfgfile << EOF
+
+#define ventoy_keyboard_set_layout(name) if (grub_strcmp(layout, #name) == 0) return ventoy_keyboard_layout_##name()
+
 menuentry QWERTY_USA --class=debug_kbd {
     setkey -r
     setkey -d
@@ -25,6 +26,59 @@ ls -1 cfg | while read line; do
     echo "}" >> $cfgfile   
 done
 
+dos2unix $cfgfile
+sed 's/menuentry \([^ ]*\) .*/static void ventoy_keyboard_layout_\1(void) {/g' -i $cfgfile
+sed 's/setkey *-r/grub_keymap_reset();/g' -i $cfgfile
+sed 's/setkey *-d/grub_keymap_disable();/g' -i $cfgfile
+sed 's/setkey *-e/grub_keymap_enable();/g' -i $cfgfile
+sed 's/^setkey  *\([^ ]*\)  *\([^ ]*\)/grub_keymap_add_by_string("\1", "\2");/g' -i $cfgfile
+
+rm -f .tmpfunc
+echo "void ventoy_set_keyboard_layout(const char *layout);" >> .tmpfunc
+echo "void ventoy_set_keyboard_layout(const char *layout) {" >> .tmpfunc
+grep 'void *ventoy_keyboard_layout_' $cfgfile | while read line; do
+    name=$(echo $line | sed 's/.*ventoy_keyboard_layout_\(.*\)(.*/\1/g')
+    echo "ventoy_keyboard_set_layout($name);" >> .tmpfunc
+done
+
+echo "}" >> .tmpfunc
+
+cat .tmpfunc >> $cfgfile
+rm -f .tmpfunc
+
+rm -f ../GRUB2/SRC/grub-2.04/grub-core/term/$cfgfile
+cp -a $cfgfile ../GRUB2/SRC/grub-2.04/grub-core/term/$cfgfile
+
+
+
+
+
+############
+#
+# cfg
+#############
+
+cfgfile=../INSTALL/grub/keyboard.cfg
+rm -f ${cfgfile}
+
+echo "submenu \"Keyboard Layouts\" --class=debug_krdlayout {" >>$cfgfile
+
+cat >>$cfgfile << EOF
+    menuentry QWERTY_USA --class=debug_kbd {
+        set_keyboard_layout QWERTY_USA
+    }
+EOF
+
+ls -1 cfg | while read line; do
+    kbd=${line%.cfg}
+    name=${kbd#KBD_}
+    
+    echo "    menuentry $name --class=debug_kbd {" >> $cfgfile
+    echo "        set_keyboard_layout $name" >> $cfgfile
+    echo "    }" >> $cfgfile   
+done
+
 echo "}" >>$cfgfile
 
-gzip $cfgfile
+
+

LANGUAGES/README

@@ -0,0 +1,17 @@
+
+File encoding: UTF-8
+
+language name must in the format: "Language-XXX (YYY)"
+    1. Language- fixed 9 characters
+    2. XXX: name in English
+    3. a space (ASCII: 0x20)
+    4. a left brace (ASCII: 0x28)
+    5. YYY: name in the specified language
+    6. a right brace (ASCII: 0x29)
+
+string translation:
+      all the String Define
+      #@ will be replaced with \r\n
+
+All the languages will be sorted by the name
+

LANGUAGES/check.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+VTOY_PATH=$1
+
+if [ ! -f $VTOY_PATH/LANGUAGES/languages.json ]; then
+    exit 1
+fi
+
+gcc -DFOR_VTOY_JSON_CHECK $VTOY_PATH/Ventoy2Disk/Ventoy2Disk/VentoyJson.c -I $VTOY_PATH/Ventoy2Disk/Ventoy2Disk/ -o checkjson
+
+./checkjson $VTOY_PATH/LANGUAGES/languages.json
+ret=$?
+
+rm -f ./checkjson
+[ $ret -eq 0 ]
+
+

License/license-wimboot.txt

@@ -1,5 +1,4 @@
 wimboot follows GPLv2+ license (see gpl-2.0.txt)
 
-Ventoy use the lzx decompress file from wimboot. These code follow the same license as wimboot.
-
+Ventoy modified the code and follow the same license as wimboot.
 

LinuxGUI/Ventoy2Disk/Core/ventoy_disk.c

@@ -514,6 +514,8 @@ int ventoy_get_vtoy_data(ventoy_disk *info, int *ppartstyle)
     vdebug("ventoy partition layout check OK: [%llu %llu] [%llu %llu]\n", 
                part1_start_sector, part1_sector_count, part2_start_sector, part2_sector_count);
 
+    vtoy->ventoy_valid = 1;
+
     vdebug("now check secure boot for %s ...\n", info->disk_path);
 
     g_fatlib_media_fd = fd;
@@ -526,7 +528,6 @@ int ventoy_get_vtoy_data(ventoy_disk *info, int *ppartstyle)
         if (ret == 0 && vtoy->ventoy_ver[0])
         {
             vtoy->secure_boot_flag = fatlib_is_secure_boot_enable();            
-            vtoy->ventoy_valid = 1;
         }
         else
         {
@@ -542,6 +543,11 @@ int ventoy_get_vtoy_data(ventoy_disk *info, int *ppartstyle)
     g_fatlib_media_fd = -1;
     g_fatlib_media_offset = 0;
 
+    if (vtoy->ventoy_ver[0] == 0)
+    {
+        vtoy->ventoy_ver[0] = '?';
+    }
+
     if (0 == vtoy->ventoy_valid)
     {
         goto end;

LinuxGUI/language.sh

@@ -1,37 +1,19 @@
 #!/bin/bash
 
-echo "generating languages.js ..."
+VTOY_PATH=$PWD/../
 
-iconv -f utf-16 -t utf-8 ../LANGUAGES/languages.ini  | egrep -v '=STR|^;' | egrep  'Language-|STR_' > languages.js
+echo "checking languages.json ..."
+sh $VTOY_PATH/LANGUAGES/check.sh $VTOY_PATH || exit 1
+
+echo "generating languages.json ..."
+
+echo "var vtoy_language_data = " > languages.js
+cat $VTOY_PATH/LANGUAGES/languages.json  >> languages.js
+echo ";" >> languages.js
 
 dos2unix languages.js
 
-sed 's/\(STR_.*\)=/"\1":/g' -i languages.js
-
-sed "s/: *'/:\"/g" -i languages.js
-
-sed "s/'\s*$/\",/g" -i languages.js
-
-sed 's/\[Language-\(.*\)\].*/"STR_XXX":""},{"name":"\1",/g' -i languages.js
-
-sed "1s/.*\},/var vtoy_language_data = \[/" -i languages.js
-
-sed 's/\("STR_WEB_COMMUNICATION_ERR"[^,]*\)/\1,/g' -i languages.js
-sed 's/,,/,/g' -i languages.js
-
-CNT=$(grep -v -c ',$' languages.js)
-
-if [ $CNT -gt 0 ]; then
-    echo "====== FAILED ========="
-    grep -v -n ',$' languages.js
-    exit 1
-fi
-
-
-echo '"STR_XXX":""}' >> languages.js
-echo '];' >> languages.js
-
 rm -f WebUI/static/js/languages.js
 mv languages.js WebUI/static/js/
 
-echo "====== SUCCESS =========="
+echo "====== SUCCESS =========="

README.md

@@ -16,7 +16,7 @@ You can copy many image files at a time and ventoy will give you a boot menu to
 x86 Legacy BIOS, IA32 UEFI, x86_64 UEFI, ARM64 UEFI and MIPS64EL UEFI are supported in the same way.<br/>
 Both MBR and GPT partition style are supported in the same way.<br/>
 Most type of OS supported(Windows/WinPE/Linux/Unix/Vmware/Xen...) <br/>
-650+ ISO files are tested. 90%+ distros in distrowatch.com supported. <br/>
+700+ ISO files are tested. 90%+ distros in distrowatch.com supported. <br/>
 </h4>
 
 # Features
@@ -35,7 +35,7 @@ Most type of OS supported(Windows/WinPE/Linux/Unix/Vmware/Xen...) <br/>
 * FAT32/exFAT/NTFS/UDF/XFS/Ext2(3)(4) supported for main partition
 * ISO files larger than 4GB supported
 * Native boot menu style for Legacy & UEFI
-* Most type of OS supported, 650+ iso files tested
+* Most type of OS supported, 700+ iso files tested
 * Linux vDisk boot supported
 * Not only boot but also complete installation process
 * Menu dynamically switchable between List/TreeView mode

Ventoy2Disk/Ventoy2Disk/Language.h

@@ -101,13 +101,19 @@ typedef enum OPT_SUBMENU
 #define VTOY_MENU_LANGUAGE_BEGIN  0xB000
 
 
-#define VENTOY_LANGUAGE_INI  TEXT(".\\ventoy\\languages.ini")
+#define VENTOY_LANGUAGE_INI     TEXT(".\\ventoy\\languages.ini")
+#define VENTOY_LANGUAGE_JSON    TEXT(".\\ventoy\\languages.json")
+#define VENTOY_LANGUAGE_INI_A   ".\\ventoy\\languages.ini"
+#define VENTOY_LANGUAGE_JSON_A  ".\\ventoy\\languages.json"
+
 #define VENTOY_CFG_INI     TEXT(".\\Ventoy2Disk.ini")
 #define VENTOY_CFG_INI_A   ".\\Ventoy2Disk.ini"
 #define VENTOY_MAX_LANGUAGE	 200
 
 #define GET_INI_STRING(Section, Key, Buf) GetPrivateProfileString(Section, Key, TEXT("#"), Buf, sizeof(Buf), VENTOY_LANGUAGE_INI)
 
+
+
 typedef struct VENTOY_LANGUAGE
 {
 	WCHAR Name[128];

Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.c

@@ -283,6 +283,12 @@ static int FilterPhysicalDrive(PHY_DRIVE_INFO *pDriveList, DWORD DriveCount)
             CurDrive->PartStyle = (MBR.PartTbl[0].FsFlag == 0xEE) ? 1 : 0;
             GetVentoyVerInPhyDrive(CurDrive, Part2StartSector, CurDrive->VentoyVersion, sizeof(CurDrive->VentoyVersion), &(CurDrive->SecureBootSupport));
             Log("PhyDrive %d is Ventoy Disk ver:%s SecureBoot:%u", CurDrive->PhyDrive, CurDrive->VentoyVersion, CurDrive->SecureBootSupport);
+
+            if (CurDrive->VentoyVersion[0] == 0)
+            {
+                CurDrive->VentoyVersion[0] = '?';
+                Log("Unknown Ventoy Version");
+            }
         }
     }
 

Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.h

@@ -148,7 +148,7 @@ typedef struct PHY_DRIVE_INFO
     STORAGE_BUS_TYPE BusType;
 
     CHAR DriveLetters[64];
-
+   
     CHAR VentoyVersion[32];
 
     BOOL SecureBootSupport;

Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.vcxproj

@@ -110,6 +110,7 @@
     <ClCompile Include="process.c" />
     <ClCompile Include="Utility.c" />
     <ClCompile Include="Ventoy2Disk.c" />
+    <ClCompile Include="VentoyJson.c" />
     <ClCompile Include="WinDialog.c" />
     <ClCompile Include="xz-embedded-20130513\linux\lib\decompress_unxz.c" />
   </ItemGroup>
@@ -133,6 +134,7 @@
     <ClInclude Include="process.h" />
     <ClInclude Include="resource.h" />
     <ClInclude Include="Ventoy2Disk.h" />
+    <ClInclude Include="VentoyJson.h" />
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="Ventoy2Disk.rc" />

Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.vcxproj.filters

@@ -78,6 +78,9 @@
     <ClCompile Include="crc32.c">
       <Filter>源文件</Filter>
     </ClCompile>
+    <ClCompile Include="VentoyJson.c">
+      <Filter>源文件</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Ventoy2Disk.h">
@@ -137,6 +140,9 @@
     <ClInclude Include="process.h">
       <Filter>头文件</Filter>
     </ClInclude>
+    <ClInclude Include="VentoyJson.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="Ventoy2Disk.rc">

Ventoy2Disk/Ventoy2Disk/VentoyJson.c

@@ -0,0 +1,771 @@
+/******************************************************************************
+ * VentoyJson.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/>.
+ *
+ */
+
+#ifdef FOR_VTOY_JSON_CHECK
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#else
+#include <Windows.h>
+#include "Ventoy2Disk.h"
+#endif
+
+#include "VentoyJson.h"
+
+static void vtoy_json_free(VTOY_JSON *pstJsonHead)
+{
+    VTOY_JSON *pstNext = NULL;
+
+    while (NULL != pstJsonHead)
+    {
+        pstNext = pstJsonHead->pstNext;
+        if ((pstJsonHead->enDataType < JSON_TYPE_BUTT) && (NULL != pstJsonHead->pstChild))
+        {
+            vtoy_json_free(pstJsonHead->pstChild);
+        }
+
+        free(pstJsonHead);
+        pstJsonHead = pstNext;
+    }
+
+    return;
+}
+
+static char *vtoy_json_skip(const char *pcData)
+{
+    while ((NULL != pcData) && ('\0' != *pcData) && (*pcData <= 32))
+    {
+        pcData++;
+    }
+
+    return (char *)pcData;
+}
+
+VTOY_JSON *vtoy_json_find_item
+(
+    VTOY_JSON *pstJson,
+    JSON_TYPE  enDataType,
+    const char *szKey
+)
+{
+    while (NULL != pstJson)
+    {
+        if ((enDataType == pstJson->enDataType) && 
+            (0 == strcmp(szKey, pstJson->pcName)))
+        {
+            return pstJson;
+        }
+        pstJson = pstJson->pstNext;
+    }
+    
+    return NULL;
+}
+
+static int vtoy_json_parse_number
+(
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+)
+{
+    unsigned long Value;
+
+    Value = strtoul(pcData, (char **)ppcEnd, 10);
+    if (*ppcEnd == pcData)
+    {
+        Log("Failed to parse json number %s.", pcData);
+        return JSON_FAILED;
+    }
+
+    pstJson->enDataType = JSON_TYPE_NUMBER;
+    pstJson->unData.lValue = Value;
+    
+    return JSON_SUCCESS;
+}
+
+static int vtoy_json_parse_string
+(
+    char *pcNewStart,
+    char *pcRawStart,
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+)
+{
+    UINT32 uiLen = 0;
+    const char *pcPos = NULL;
+    const char *pcTmp = pcData + 1;
+    
+    *ppcEnd = pcData;
+
+    if ('\"' != *pcData)
+    {
+        return JSON_FAILED;
+    }
+
+    pcPos = strchr(pcTmp, '\"');
+    if ((NULL == pcPos) || (pcPos < pcTmp))
+    {
+        Log("Invalid string %s.", pcData);
+        return JSON_FAILED;
+    }
+
+    *ppcEnd = pcPos + 1;
+    uiLen = (UINT32)(unsigned long)(pcPos - pcTmp);    
+    
+    pstJson->enDataType = JSON_TYPE_STRING;
+    pstJson->unData.pcStrVal = pcNewStart + (pcTmp - pcRawStart);
+    pstJson->unData.pcStrVal[uiLen] = '\0';
+    
+    return JSON_SUCCESS;
+}
+
+static int vtoy_json_parse_array
+(
+    char *pcNewStart,
+    char *pcRawStart,
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+)
+{
+    int Ret = JSON_SUCCESS;
+    VTOY_JSON *pstJsonChild = NULL;
+    VTOY_JSON *pstJsonItem = NULL;
+    const char *pcTmp = pcData + 1;
+
+    *ppcEnd = pcData;
+    pstJson->enDataType = JSON_TYPE_ARRAY;
+
+    if ('[' != *pcData)
+    {
+        return JSON_FAILED;
+    }
+
+    pcTmp = vtoy_json_skip(pcTmp);
+
+    if (']' == *pcTmp)
+    {
+        *ppcEnd = pcTmp + 1;
+        return JSON_SUCCESS;
+    }
+
+    JSON_NEW_ITEM(pstJson->pstChild, JSON_FAILED);
+
+    Ret = vtoy_json_parse_value(pcNewStart, pcRawStart, pstJson->pstChild, pcTmp, ppcEnd);
+    if (JSON_SUCCESS != Ret)
+    {
+        Log("Failed to parse array child.");
+        return JSON_FAILED;
+    }
+
+    pstJsonChild = pstJson->pstChild;
+    pcTmp = vtoy_json_skip(*ppcEnd);
+    while ((NULL != pcTmp) && (',' == *pcTmp))
+    {
+        JSON_NEW_ITEM(pstJsonItem, JSON_FAILED);
+        pstJsonChild->pstNext = pstJsonItem;
+        pstJsonItem->pstPrev = pstJsonChild;
+        pstJsonChild = pstJsonItem;
+
+        Ret = vtoy_json_parse_value(pcNewStart, pcRawStart, pstJsonChild, vtoy_json_skip(pcTmp + 1), ppcEnd);
+        if (JSON_SUCCESS != Ret)
+        {
+            Log("Failed to parse array child.");
+            return JSON_FAILED;
+        }
+        pcTmp = vtoy_json_skip(*ppcEnd);
+    }
+
+    if ((NULL != pcTmp) && (']' == *pcTmp))
+    {
+        *ppcEnd = pcTmp + 1;
+        return JSON_SUCCESS;
+    }
+    else
+    {
+        *ppcEnd = pcTmp;
+        return JSON_FAILED;
+    }
+}
+
+static int vtoy_json_parse_object
+(
+    char *pcNewStart,
+    char *pcRawStart,
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+)
+{
+    int Ret = JSON_SUCCESS;
+    VTOY_JSON *pstJsonChild = NULL;
+    VTOY_JSON *pstJsonItem = NULL;
+    const char *pcTmp = pcData + 1;
+
+    *ppcEnd = pcData;
+    pstJson->enDataType = JSON_TYPE_OBJECT;
+
+    if ('{' != *pcData)
+    {
+        return JSON_FAILED;
+    }
+
+    pcTmp = vtoy_json_skip(pcTmp);
+    if ('}' == *pcTmp)
+    {
+        *ppcEnd = pcTmp + 1;
+        return JSON_SUCCESS;
+    }
+
+    JSON_NEW_ITEM(pstJson->pstChild, JSON_FAILED);
+
+    Ret = vtoy_json_parse_string(pcNewStart, pcRawStart, pstJson->pstChild, pcTmp, ppcEnd);
+    if (JSON_SUCCESS != Ret)
+    {
+        Log("Failed to parse array child.");
+        return JSON_FAILED;
+    }
+
+    pstJsonChild = pstJson->pstChild;
+    pstJsonChild->pcName = pstJsonChild->unData.pcStrVal;
+    pstJsonChild->unData.pcStrVal = NULL;
+
+    pcTmp = vtoy_json_skip(*ppcEnd);
+    if ((NULL == pcTmp) || (':' != *pcTmp))
+    {
+        *ppcEnd = pcTmp;
+        return JSON_FAILED;
+    }
+
+    Ret = vtoy_json_parse_value(pcNewStart, pcRawStart, pstJsonChild, vtoy_json_skip(pcTmp + 1), ppcEnd);
+    if (JSON_SUCCESS != Ret)
+    {
+        Log("Failed to parse array child.");
+        return JSON_FAILED;
+    }
+
+    pcTmp = vtoy_json_skip(*ppcEnd);
+    while ((NULL != pcTmp) && (',' == *pcTmp))
+    {
+        JSON_NEW_ITEM(pstJsonItem, JSON_FAILED);
+        pstJsonChild->pstNext = pstJsonItem;
+        pstJsonItem->pstPrev = pstJsonChild;
+        pstJsonChild = pstJsonItem;
+
+        Ret = vtoy_json_parse_string(pcNewStart, pcRawStart, pstJsonChild, vtoy_json_skip(pcTmp + 1), ppcEnd);
+        if (JSON_SUCCESS != Ret)
+        {
+            Log("Failed to parse array child.");
+            return JSON_FAILED;
+        }
+
+        pcTmp = vtoy_json_skip(*ppcEnd);
+        pstJsonChild->pcName = pstJsonChild->unData.pcStrVal;
+        pstJsonChild->unData.pcStrVal = NULL;
+        if ((NULL == pcTmp) || (':' != *pcTmp))
+        {
+            *ppcEnd = pcTmp;
+            return JSON_FAILED;
+        }
+
+        Ret = vtoy_json_parse_value(pcNewStart, pcRawStart, pstJsonChild, vtoy_json_skip(pcTmp + 1), ppcEnd);
+        if (JSON_SUCCESS != Ret)
+        {
+            Log("Failed to parse array child.");
+            return JSON_FAILED;
+        }
+
+        pcTmp = vtoy_json_skip(*ppcEnd);
+    }
+
+    if ((NULL != pcTmp) && ('}' == *pcTmp))
+    {
+        *ppcEnd = pcTmp + 1;
+        return JSON_SUCCESS;
+    }
+    else
+    {
+        *ppcEnd = pcTmp;
+        return JSON_FAILED;
+    }
+}
+
+int vtoy_json_parse_value
+(
+    char *pcNewStart,
+    char *pcRawStart,
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+)
+{
+    pcData = vtoy_json_skip(pcData);
+    
+    switch (*pcData)
+    {
+        case 'n':
+        {
+            if (0 == strncmp(pcData, "null", 4))
+            {
+                pstJson->enDataType = JSON_TYPE_NULL;
+                *ppcEnd = pcData + 4;
+                return JSON_SUCCESS;
+            }
+            break;
+        }
+        case 'f':
+        {
+            if (0 == strncmp(pcData, "false", 5))
+            {
+                pstJson->enDataType = JSON_TYPE_BOOL;
+                pstJson->unData.lValue = 0;
+                *ppcEnd = pcData + 5;
+                return JSON_SUCCESS;
+            }
+            break;
+        }
+        case 't':
+        {
+            if (0 == strncmp(pcData, "true", 4))
+            {
+                pstJson->enDataType = JSON_TYPE_BOOL;
+                pstJson->unData.lValue = 1;
+                *ppcEnd = pcData + 4;
+                return JSON_SUCCESS;
+            }
+            break;
+        }
+        case '\"':
+        {
+            return vtoy_json_parse_string(pcNewStart, pcRawStart, pstJson, pcData, ppcEnd);
+        }
+        case '[':
+        {
+            return vtoy_json_parse_array(pcNewStart, pcRawStart, pstJson, pcData, ppcEnd);
+        }
+        case '{':
+        {
+            return vtoy_json_parse_object(pcNewStart, pcRawStart, pstJson, pcData, ppcEnd);
+        }
+        case '-':
+        {
+            return vtoy_json_parse_number(pstJson, pcData, ppcEnd);
+        }
+        default :
+        {
+            if (*pcData >= '0' && *pcData <= '9')
+            {
+                return vtoy_json_parse_number(pstJson, pcData, ppcEnd);
+            }
+        }
+    }
+
+    *ppcEnd = pcData;
+    Log("Invalid json data %u.", (UINT8)(*pcData));
+    return JSON_FAILED;
+}
+
+VTOY_JSON * vtoy_json_create(void)
+{
+    VTOY_JSON *pstJson = NULL;
+
+    pstJson = (VTOY_JSON *)malloc(sizeof(VTOY_JSON));
+    if (NULL == pstJson)
+    {
+        return NULL;
+    }
+    memset(pstJson, 0, sizeof(VTOY_JSON));
+    return pstJson;
+}
+
+int vtoy_json_parse(VTOY_JSON *pstJson, const char *szJsonData)
+{
+    UINT32 uiMemSize = 0;
+    int Ret = JSON_SUCCESS;
+    char *pcNewBuf = NULL;
+    const char *pcEnd = NULL;
+
+    uiMemSize = strlen(szJsonData) + 1;
+    pcNewBuf = (char *)malloc(uiMemSize);
+    if (NULL == pcNewBuf)
+    {
+        Log("Failed to alloc new buf.");
+        return JSON_FAILED;
+    }
+    memcpy(pcNewBuf, szJsonData, uiMemSize);
+    pcNewBuf[uiMemSize - 1] = 0;
+
+    Ret = vtoy_json_parse_value(pcNewBuf, (char *)szJsonData, pstJson, szJsonData, &pcEnd);
+    if (JSON_SUCCESS != Ret)
+    {
+        Log("Failed to parse json data start=%p, end=%p", szJsonData, pcEnd);
+        return JSON_FAILED;
+    }
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_scan_parse
+(
+    const VTOY_JSON    *pstJson,
+    UINT32       uiParseNum,
+    JSON_PARSE         *pstJsonParse
+)
+{   
+    UINT32 i = 0;
+    const VTOY_JSON *pstJsonCur = NULL;
+    JSON_PARSE *pstCurParse = NULL;
+
+    for (pstJsonCur = pstJson; NULL != pstJsonCur; pstJsonCur = pstJsonCur->pstNext)
+    {
+        if ((JSON_TYPE_OBJECT == pstJsonCur->enDataType) ||
+            (JSON_TYPE_ARRAY == pstJsonCur->enDataType))
+        {
+            continue;
+        }
+
+        for (i = 0, pstCurParse = NULL; i < uiParseNum; i++)
+        {
+            if (0 == strcmp(pstJsonParse[i].pcKey, pstJsonCur->pcName))
+            {   
+                pstCurParse = pstJsonParse + i;
+                break;
+            }
+        }
+
+        if (NULL == pstCurParse)
+        {
+            continue;
+        }
+    
+        switch (pstJsonCur->enDataType)
+        {
+            case JSON_TYPE_NUMBER:
+            {
+                if (sizeof(UINT32) == pstCurParse->uiBufSize)
+                {
+                    *(UINT32 *)(pstCurParse->pDataBuf) = (UINT32)pstJsonCur->unData.lValue;
+                }
+                else if (sizeof(UINT16) == pstCurParse->uiBufSize)
+                {
+                    *(UINT16 *)(pstCurParse->pDataBuf) = (UINT16)pstJsonCur->unData.lValue;
+                }
+                else if (sizeof(UINT8) == pstCurParse->uiBufSize)
+                {
+                    *(UINT8 *)(pstCurParse->pDataBuf) = (UINT8)pstJsonCur->unData.lValue;
+                }
+                else if ((pstCurParse->uiBufSize > sizeof(UINT64)))
+                {
+                    sprintf_s((char *)pstCurParse->pDataBuf, pstCurParse->uiBufSize, "%llu",
+                        (unsigned long long)(pstJsonCur->unData.lValue));
+                }
+                else
+                {
+                    Log("Invalid number data buf size %u.", pstCurParse->uiBufSize);
+                }
+                break;
+            }
+            case JSON_TYPE_STRING:
+            {
+                strcpy_s((char *)pstCurParse->pDataBuf, pstCurParse->uiBufSize, pstJsonCur->unData.pcStrVal);
+                break;
+            }
+            case JSON_TYPE_BOOL:
+            {
+                *(UINT8 *)(pstCurParse->pDataBuf) = (pstJsonCur->unData.lValue) > 0 ? 1 : 0;
+                break;
+            }
+            default :
+            {
+                break;
+            }
+        }
+    }
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_scan_array
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     VTOY_JSON **ppstArrayItem
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_ARRAY, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *ppstArrayItem = pstJsonItem;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_scan_array_ex
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     VTOY_JSON **ppstArrayItem
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_ARRAY, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+    
+    *ppstArrayItem = pstJsonItem->pstChild;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_scan_object
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     VTOY_JSON **ppstObjectItem
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_OBJECT, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *ppstObjectItem = pstJsonItem;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_get_int
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    int *piValue
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_NUMBER, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *piValue = (int)pstJsonItem->unData.lValue;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_get_uint
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    UINT32 *puiValue
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_NUMBER, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *puiValue = (UINT32)pstJsonItem->unData.lValue;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_get_uint64
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    UINT64 *pui64Value
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_NUMBER, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *pui64Value = (UINT64)pstJsonItem->unData.lValue;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_get_bool
+(
+    VTOY_JSON *pstJson,
+    const char *szKey, 
+    UINT8 *pbValue
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_BOOL, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *pbValue = pstJsonItem->unData.lValue > 0 ? 1 : 0;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_get_string
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     UINT32  uiBufLen,
+     char *pcBuf
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_STRING, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    strcpy_s(pcBuf, uiBufLen, pstJsonItem->unData.pcStrVal);
+
+    return JSON_SUCCESS;
+}
+
+const char * vtoy_json_get_string_ex(VTOY_JSON *pstJson,  const char *szKey)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+
+    if ((NULL == pstJson) || (NULL == szKey))
+    {
+        return NULL;
+    }
+
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_STRING, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return NULL;
+    }
+
+    return pstJsonItem->unData.pcStrVal;
+}
+
+int vtoy_json_destroy(VTOY_JSON *pstJson)
+{
+    if (NULL == pstJson)
+    {   
+        return JSON_SUCCESS;
+    }
+
+    if (NULL != pstJson->pstChild)
+    {
+        vtoy_json_free(pstJson->pstChild);
+    }
+
+    if (NULL != pstJson->pstNext)
+    {
+        vtoy_json_free(pstJson->pstNext);
+    }
+
+    free(pstJson);
+    
+    return JSON_SUCCESS;
+}
+
+
+#ifdef FOR_VTOY_JSON_CHECK
+
+int main(int argc, char**argv)
+{
+    int ret = 1;
+    int FileSize;
+    FILE *fp;
+    void *Data = NULL;
+    VTOY_JSON *json = NULL;
+
+    fp = fopen(argv[1], "rb");
+    if (!fp)
+    {
+        Log("Failed to open %s\n", argv[1]);
+        goto out;
+    }
+
+    fseek(fp, 0, SEEK_END);
+    FileSize = (int)ftell(fp);
+    fseek(fp, 0, SEEK_SET);
+
+    Data = malloc(FileSize + 4);
+    if (!Data)
+    {
+        Log("Failed to malloc %d\n", FileSize + 4);
+        goto out;
+    }
+    *((char *)Data + FileSize) = 0;
+
+    fread(Data, 1, FileSize, fp);
+
+    json = vtoy_json_create();
+    if (!json)
+    {
+        Log("Failed vtoy_json_create\n");
+        goto out;
+    }
+
+    if (vtoy_json_parse(json, (char *)Data) != JSON_SUCCESS)
+    {
+        goto out;
+    }
+
+    ret = 0;
+
+out:
+    if (fp) fclose(fp);
+    if (Data) free(Data);
+    if (json) vtoy_json_destroy(json);
+
+    printf("\n");
+    return ret;
+}
+
+#endif

Ventoy2Disk/Ventoy2Disk/VentoyJson.h

@@ -0,0 +1,164 @@
+/******************************************************************************
+ * VentoyJson.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_JSON_H__
+#define __VENTOY_JSON_H__
+
+#ifdef FOR_VTOY_JSON_CHECK
+typedef unsigned char      UINT8;
+typedef unsigned short     UINT16;
+typedef unsigned int       UINT32;
+typedef unsigned long long UINT64;
+
+#define Log printf
+#define strcpy_s(a, b, c) strncpy(a, c, b)
+#define sprintf_s snprintf
+#endif
+
+#define JSON_SUCCESS    0
+#define JSON_FAILED     1
+#define JSON_NOT_FOUND  2
+
+typedef enum _JSON_TYPE
+{
+    JSON_TYPE_NUMBER = 0,
+    JSON_TYPE_STRING,
+    JSON_TYPE_BOOL,
+    JSON_TYPE_ARRAY,
+    JSON_TYPE_OBJECT,
+    JSON_TYPE_NULL,
+    JSON_TYPE_BUTT
+}JSON_TYPE;
+
+
+typedef struct _VTOY_JSON
+{
+    struct _VTOY_JSON *pstPrev;
+    struct _VTOY_JSON *pstNext;
+    struct _VTOY_JSON *pstChild;
+
+    JSON_TYPE enDataType;
+    union 
+    {
+        char  *pcStrVal;
+        int   iNumVal;
+        UINT64 lValue;
+    }unData;
+
+    char *pcName;
+}VTOY_JSON;
+
+typedef struct _JSON_PARSE
+{
+    char *pcKey;
+    void *pDataBuf;
+    UINT32  uiBufSize;
+}JSON_PARSE;
+
+#define JSON_NEW_ITEM(pstJson, ret) \
+{ \
+    (pstJson) = (VTOY_JSON *)malloc(sizeof(VTOY_JSON)); \
+    if (NULL == (pstJson)) \
+    { \
+        Log("Failed to alloc memory for json.\n"); \
+        return (ret); \
+    } \
+    memset((pstJson), 0, sizeof(VTOY_JSON));\
+}
+
+VTOY_JSON *vtoy_json_find_item
+(
+    VTOY_JSON *pstJson,
+    JSON_TYPE  enDataType,
+    const char *szKey
+);
+int vtoy_json_parse_value
+(
+    char *pcNewStart,
+    char *pcRawStart,
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+);
+VTOY_JSON * vtoy_json_create(void);
+int vtoy_json_parse(VTOY_JSON *pstJson, const char *szJsonData);
+
+int vtoy_json_scan_parse
+(
+    const VTOY_JSON    *pstJson,
+    UINT32              uiParseNum,
+    JSON_PARSE         *pstJsonParse
+);
+
+int vtoy_json_scan_array
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     VTOY_JSON **ppstArrayItem
+);
+
+int vtoy_json_scan_array_ex
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     VTOY_JSON **ppstArrayItem
+);
+int vtoy_json_scan_object
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+    VTOY_JSON **ppstObjectItem
+);
+int vtoy_json_get_int
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    int *piValue
+);
+int vtoy_json_get_uint
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    UINT32     *puiValue
+);
+int vtoy_json_get_uint64
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    UINT64 *pui64Value
+);
+int vtoy_json_get_bool
+(
+    VTOY_JSON *pstJson,
+    const char *szKey, 
+    UINT8 *pbValue
+);
+int vtoy_json_get_string
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     UINT32  uiBufLen,
+     char *pcBuf
+);
+const char * vtoy_json_get_string_ex(VTOY_JSON *pstJson,  const char *szKey);
+int vtoy_json_destroy(VTOY_JSON *pstJson);
+
+#endif /* __VENTOY_JSON_H__ */
+

VtoyTool/vtoydump.c

@@ -435,43 +435,6 @@ static int vtoy_printf_iso_path(ventoy_os_param *param)
     return 0;
 }
 
-static int vtoy_print_os_param(ventoy_os_param *param, char *diskname)
-{
-    int   cnt = 0;
-    char *path = param->vtoy_img_path;
-    const char *fs;
-
-    cnt = vtoy_find_disk_by_size(param->vtoy_disk_size, diskname);
-    if (cnt > 1)
-    {
-        cnt = vtoy_find_disk_by_guid(param, diskname);
-    }
-    else if (cnt == 0)
-    {
-        cnt = vtoy_find_disk_by_guid(param, diskname);
-        debug("find 0 disk by size, try with guid cnt=%d...\n", cnt);
-    }
-
-    if (param->vtoy_disk_part_type < ventoy_fs_max)
-    {
-        fs = g_ventoy_fs[param->vtoy_disk_part_type];
-    }
-    else
-    {
-        fs = "unknown";
-    }
-
-    if (1 == cnt)
-    {
-        printf("/dev/%s#%s#%s\n", diskname, fs, path);
-        return 0;
-    }
-    else
-    {
-        return 1;
-    }
-}
-
 static int vtoy_check_device(ventoy_os_param *param, const char *device)
 {
     unsigned long long size; 
@@ -499,6 +462,81 @@ static int vtoy_check_device(ventoy_os_param *param, const char *device)
     }
 }
 
+static int vtoy_print_os_param(ventoy_os_param *param, char *diskname)
+{
+    int fd, size;
+    int cnt = 0;
+    char *path = param->vtoy_img_path;
+    const char *fs;
+    char diskpath[256] = {0};
+    char sizebuf[64] = {0};
+    
+    cnt = vtoy_find_disk_by_size(param->vtoy_disk_size, diskname);
+    debug("find disk by size %llu, cnt=%d...\n", (unsigned long long)param->vtoy_disk_size, cnt);
+    if (1 == cnt)
+    {
+        if (vtoy_check_device(param, diskname) != 0)
+        {
+            cnt = 0;
+        }
+    }
+    else
+    {
+        cnt = vtoy_find_disk_by_guid(param, diskname);
+        debug("find disk by guid cnt=%d...\n", cnt);
+    }
+    
+    if (param->vtoy_disk_part_type < ventoy_fs_max)
+    {
+        fs = g_ventoy_fs[param->vtoy_disk_part_type];
+    }
+    else
+    {
+        fs = "unknown";
+    }
+
+    if (1 == cnt)
+    {
+        if (strstr(diskname, "nvme") || strstr(diskname, "mmc") || strstr(diskname, "nbd"))
+        {
+            snprintf(diskpath, sizeof(diskpath) - 1, "/sys/class/block/%sp2/size", diskname);
+        }
+        else
+        {
+            snprintf(diskpath, sizeof(diskpath) - 1, "/sys/class/block/%s2/size", diskname);
+        }
+
+        if (access(diskpath, F_OK) >= 0)
+        {
+            debug("get part size from sysfs for %s\n", diskpath);
+
+            fd = open(diskpath, O_RDONLY | O_BINARY);
+            if (fd >= 0)
+            {
+                read(fd, sizebuf, sizeof(sizebuf));
+                size = (int)strtoull(sizebuf, NULL, 10);
+                close(fd);
+                if ((size != (64 * 1024)) && (size != (8 * 1024)))
+                {
+                    debug("sizebuf=<%s> size=%d\n", sizebuf, size);
+                    return 1;
+                }
+            }
+        }
+        else
+        {
+            debug("%s not exist \n", diskpath);
+        }
+
+        printf("/dev/%s#%s#%s\n", diskname, fs, path);
+        return 0;
+    }
+    else
+    {
+        return 1;
+    }
+}
+
 /*
  *  Find disk and image path from ventoy runtime data.
  *  By default data is read from phymem(legacy bios) or efivar(UEFI), if -f is input, data is read from file.