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

   1 /******************************************************************************
   2  * ventoy_vhd.c
   3  *
   4  * Copyright (c) 2020, longpanda <admin@ventoy.net>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 3 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include <grub/types.h>
  22 #include <grub/misc.h>
  23 #include <grub/mm.h>
  24 #include <grub/err.h>
  25 #include <grub/dl.h>
  26 #include <grub/disk.h>
  27 #include <grub/device.h>
  28 #include <grub/term.h>
  29 #include <grub/partition.h>
  30 #include <grub/file.h>
  31 #include <grub/normal.h>
  32 #include <grub/extcmd.h>
  33 #include <grub/datetime.h>
  34 #include <grub/i18n.h>
  35 #include <grub/net.h>
  36 #include <grub/time.h>
  37 #include <grub/crypto.h>
  38 #include <grub/charset.h>
  39 #ifdef GRUB_MACHINE_EFI
  40 #include <grub/efi/efi.h>
  41 #endif
  42 #include <grub/ventoy.h>
  43 #include "ventoy_def.h"
  44
  45 GRUB_MOD_LICENSE ("GPLv3+");
  46
  47 static int g_vhdboot_isolen = 0;
  48 static char *g_vhdboot_totbuf = NULL;
  49 static char *g_vhdboot_isobuf = NULL;
  50 static grub_uint64_t g_img_trim_head_secnum = 0;
  51
  52 static int ventoy_vhd_find_bcd(int *bcdoffset, int *bcdlen, const char *path)
  53 {
  54     grub_uint32_t offset;
  55     grub_file_t file;
  56     char cmdbuf[128];
  57
  58     grub_snprintf(cmdbuf, sizeof(cmdbuf), "loopback vhdiso mem:0x%lx:size:%d", (ulong)g_vhdboot_isobuf, g_vhdboot_isolen);
  59
  60     grub_script_execute_sourcecode(cmdbuf);
  61
  62     file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "(vhdiso)%s", path);
  63     if (!file)
  64     {
  65         return 1;
  66     }
  67
  68     grub_file_read(file, &offset, 4);
  69     offset = (grub_uint32_t)grub_iso9660_get_last_read_pos(file);
  70
  71     *bcdoffset = (int)offset;
  72     *bcdlen = (int)file->size;
  73
  74     debug("vhdiso bcd file offset:%d len:%d\n", *bcdoffset, *bcdlen);
  75
  76     grub_file_close(file);
  77
  78     grub_script_execute_sourcecode("loopback -d vhdiso");
  79
  80     return 0;
  81 }
  82
  83 static int ventoy_vhd_patch_path(char *vhdpath, ventoy_patch_vhd *patch1, ventoy_patch_vhd *patch2,
  84     int bcdoffset, int bcdlen)
  85 {
  86     int i;
  87     int cnt = 0;
  88     char *pos;
  89     grub_size_t pathlen;
  90     const char *plat;
  91     char *newpath = NULL;
  92     grub_uint16_t *unicode_path;
  93     const grub_uint8_t winloadexe[] =
  94     {
  95         0x77, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x61, 0x00, 0x64, 0x00, 0x2E, 0x00,
  96         0x65, 0x00, 0x78, 0x00, 0x65, 0x00
  97     };
  98
  99     while ((*vhdpath) != '/')
 100     {
 101         vhdpath++;
 102     }
 103
 104     pathlen = sizeof(grub_uint16_t) * (grub_strlen(vhdpath) + 1);
 105     debug("unicode path for <%s> len:%d\n", vhdpath, (int)pathlen);
 106
 107     unicode_path = grub_zalloc(pathlen);
 108     if (!unicode_path)
 109     {
 110         return 0;
 111     }
 112
 113     plat = grub_env_get("grub_platform");
 114
 115     if (plat && (plat[0] == 'e')) /* UEFI */
 116     {
 117         pos = g_vhdboot_isobuf + bcdoffset;
 118
 119         /* winload.exe ==> winload.efi */
 120         for (i = 0; i + (int)sizeof(winloadexe) < bcdlen; i++)
 121         {
 122             if (*((grub_uint32_t *)(pos + i)) == 0x00690077 &&
 123                 grub_memcmp(pos + i, winloadexe, sizeof(winloadexe)) == 0)
 124             {
 125                 pos[i + sizeof(winloadexe) - 4] = 0x66;
 126                 pos[i + sizeof(winloadexe) - 2] = 0x69;
 127                 cnt++;
 128             }
 129         }
 130
 131         debug("winload patch %d times\n", cnt);
 132     }
 133
 134     newpath = grub_strdup(vhdpath);
 135     for (pos = newpath; *pos; pos++)
 136     {
 137         if (*pos == '/')
 138         {
 139             *pos = '\\';
 140         }
 141     }
 142
 143     grub_utf8_to_utf16(unicode_path, pathlen, (grub_uint8_t *)newpath, -1, NULL);
 144     grub_memcpy(patch1->vhd_file_path, unicode_path, pathlen);
 145     grub_memcpy(patch2->vhd_file_path, unicode_path, pathlen);
 146
 147     grub_free(newpath);
 148     return 0;
 149 }
 150
 151 static int ventoy_vhd_read_parttbl(const char *filename, ventoy_gpt_info *gpt, int *index)
 152 {
 153     int ret = 1;
 154     grub_file_t file = NULL;
 155     grub_disk_t disk = NULL;
 156
 157     file = grub_file_open(filename, VENTOY_FILE_TYPE);
 158     if (!file)
 159     {
 160         goto end;
 161     }
 162
 163     disk = grub_disk_open(file->device->disk->name);
 164     if (!disk)
 165     {
 166         goto end;
 167     }
 168
 169     *index = file->device->disk->partition->index;
 170     grub_disk_read(disk, 0, 0, sizeof(ventoy_gpt_info), gpt);
 171
 172     ret = 0;
 173
 174 end:
 175     check_free(file, grub_file_close);
 176     check_free(disk, grub_disk_close);
 177
 178     return ret;
 179 }
 180
 181 static int ventoy_vhd_patch_disk(const char *vhdpath, ventoy_patch_vhd *patch1, ventoy_patch_vhd *patch2)
 182 {
 183     int partIndex = 0;
 184     grub_uint64_t offset = 0;
 185     char efipart[16] = {0};
 186     ventoy_gpt_info *gpt = NULL;
 187
 188     if (vhdpath[0] == '/')
 189     {
 190         gpt = g_ventoy_part_info;
 191         partIndex = 0;
 192         debug("This is Ventoy ISO partIndex %d %s\n", partIndex, vhdpath);
 193     }
 194     else
 195     {
 196         gpt = grub_zalloc(sizeof(ventoy_gpt_info));
 197         ventoy_vhd_read_parttbl(vhdpath, gpt, &partIndex);
 198         debug("This is HDD partIndex %d %s\n", partIndex, vhdpath);
 199     }
 200
 201     grub_memcpy(efipart, gpt->Head.Signature, sizeof(gpt->Head.Signature));
 202
 203     grub_memset(patch1, 0, OFFSET_OF(ventoy_patch_vhd, vhd_file_path));
 204     grub_memset(patch2, 0, OFFSET_OF(ventoy_patch_vhd, vhd_file_path));
 205
 206     if (grub_strncmp(efipart, "EFI PART", 8) == 0)
 207     {
 208         ventoy_debug_dump_guid("GPT disk GUID: ", gpt->Head.DiskGuid);
 209         ventoy_debug_dump_guid("GPT partIndex GUID: ", gpt->PartTbl[partIndex].PartGuid);
 210
 211         grub_memcpy(patch1->disk_signature_or_guid, gpt->Head.DiskGuid, 16);
 212         grub_memcpy(patch1->part_offset_or_guid, gpt->PartTbl[partIndex].PartGuid, 16);
 213         grub_memcpy(patch2->disk_signature_or_guid, gpt->Head.DiskGuid, 16);
 214         grub_memcpy(patch2->part_offset_or_guid, gpt->PartTbl[partIndex].PartGuid, 16);
 215
 216         patch1->part_type = patch2->part_type = 0;
 217     }
 218     else
 219     {
 220         offset = gpt->MBR.PartTbl[partIndex].StartSectorId;
 221         offset *= 512;
 222
 223         debug("MBR disk signature: %02x%02x%02x%02x Part(%d) offset:%llu\n",
 224             gpt->MBR.BootCode[0x1b8 + 0], gpt->MBR.BootCode[0x1b8 + 1],
 225             gpt->MBR.BootCode[0x1b8 + 2], gpt->MBR.BootCode[0x1b8 + 3],
 226             partIndex + 1, offset);
 227
 228         grub_memcpy(patch1->part_offset_or_guid, &offset, 8);
 229         grub_memcpy(patch2->part_offset_or_guid, &offset, 8);
 230
 231         grub_memcpy(patch1->disk_signature_or_guid, gpt->MBR.BootCode + 0x1b8, 4);
 232         grub_memcpy(patch2->disk_signature_or_guid, gpt->MBR.BootCode + 0x1b8, 4);
 233
 234         patch1->part_type = patch2->part_type = 1;
 235     }
 236
 237     if (gpt != g_ventoy_part_info)
 238     {
 239         grub_free(gpt);
 240     }
 241
 242     return 0;
 243 }
 244
 245 static int ventoy_find_vhdpatch_offset(int bcdoffset, int bcdlen, int *offset)
 246 {
 247     int i;
 248     int cnt = 0;
 249     grub_uint8_t *buf = (grub_uint8_t *)(g_vhdboot_isobuf + bcdoffset);
 250     grub_uint8_t magic[16] = {
 251         0x5C, 0x00, 0x58, 0x00, 0x58, 0x00, 0x58, 0x00, 0x58, 0x00, 0x58, 0x00, 0x58, 0x00, 0x58, 0x00
 252     };
 253
 254     for (i = 0; i < bcdlen - 16 && cnt < 2; i++)
 255     {
 256         if (*(grub_uint32_t *)(buf + i) == 0x0058005C)
 257         {
 258             if (grub_memcmp(magic, buf + i, 16) == 0)
 259             {
 260                 *offset++ = i - (int)OFFSET_OF(ventoy_patch_vhd, vhd_file_path);
 261                 cnt++;
 262             }
 263         }
 264     }
 265
 266     return 0;
 267 }
 268
 269 grub_err_t ventoy_cmd_patch_vhdboot(grub_extcmd_context_t ctxt, int argc, char **args)
 270 {
 271     int rc;
 272     int bcdoffset, bcdlen;
 273     int patchoffset[2];
 274     ventoy_patch_vhd *patch1;
 275     ventoy_patch_vhd *patch2;
 276     char envbuf[64];
 277
 278     (void)ctxt;
 279     (void)argc;
 280
 281     grub_env_unset("vtoy_vhd_buf_addr");
 282
 283     debug("patch vhd <%s>\n", args[0]);
 284
 285     if ((!g_vhdboot_enable) || (!g_vhdboot_totbuf))
 286     {
 287         debug("vhd boot not ready %d %p\n", g_vhdboot_enable, g_vhdboot_totbuf);
 288         return 0;
 289     }
 290
 291     rc = ventoy_vhd_find_bcd(&bcdoffset, &bcdlen, "/boot/bcd");
 292     if (rc)
 293     {
 294         debug("failed to get bcd location %d\n", rc);
 295     }
 296     else
 297     {
 298         ventoy_find_vhdpatch_offset(bcdoffset, bcdlen, patchoffset);
 299         patch1 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + bcdoffset + patchoffset[0]);
 300         patch2 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + bcdoffset + patchoffset[1]);
 301
 302         debug("Find /boot/bcd (%d %d) now patch it (offset: 0x%x 0x%x) ...\n",
 303               bcdoffset, bcdlen, patchoffset[0], patchoffset[1]);
 304         ventoy_vhd_patch_disk(args[0], patch1, patch2);
 305         ventoy_vhd_patch_path(args[0], patch1, patch2, bcdoffset, bcdlen);
 306     }
 307
 308     rc = ventoy_vhd_find_bcd(&bcdoffset, &bcdlen, "/boot/BCD");
 309     if (rc)
 310     {
 311         debug("No file /boot/BCD \n");
 312     }
 313     else
 314     {
 315         ventoy_find_vhdpatch_offset(bcdoffset, bcdlen, patchoffset);
 316         patch1 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + bcdoffset + patchoffset[0]);
 317         patch2 = (ventoy_patch_vhd *)(g_vhdboot_isobuf + bcdoffset + patchoffset[1]);
 318
 319         debug("Find /boot/BCD (%d %d) now patch it (offset: 0x%x 0x%x) ...\n",
 320               bcdoffset, bcdlen, patchoffset[0], patchoffset[1]);
 321         ventoy_vhd_patch_disk(args[0], patch1, patch2);
 322         ventoy_vhd_patch_path(args[0], patch1, patch2, bcdoffset, bcdlen);
 323     }
 324
 325     /* set buffer and size */
 326 #ifdef GRUB_MACHINE_EFI
 327     grub_snprintf(envbuf, sizeof(envbuf), "0x%lx", (ulong)g_vhdboot_totbuf);
 328     grub_env_set("vtoy_vhd_buf_addr", envbuf);
 329     grub_snprintf(envbuf, sizeof(envbuf), "%d", (int)(g_vhdboot_isolen + sizeof(ventoy_chain_head)));
 330     grub_env_set("vtoy_vhd_buf_size", envbuf);
 331 #else
 332     grub_snprintf(envbuf, sizeof(envbuf), "0x%lx", (ulong)g_vhdboot_isobuf);
 333     grub_env_set("vtoy_vhd_buf_addr", envbuf);
 334     grub_snprintf(envbuf, sizeof(envbuf), "%d", g_vhdboot_isolen);
 335     grub_env_set("vtoy_vhd_buf_size", envbuf);
 336 #endif
 337
 338     VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 339 }
 340
 341 grub_err_t ventoy_cmd_load_vhdboot(grub_extcmd_context_t ctxt, int argc, char **args)
 342 {
 343     int buflen;
 344     grub_file_t file;
 345
 346     (void)ctxt;
 347     (void)argc;
 348
 349     g_vhdboot_enable = 0;
 350     grub_check_free(g_vhdboot_totbuf);
 351
 352     file = grub_file_open(args[0], VENTOY_FILE_TYPE);
 353     if (!file)
 354     {
 355         return 0;
 356     }
 357
 358     debug("load vhd boot: <%s> <%lu>\n", args[0], (ulong)file->size);
 359
 360     if (file->size < VTOY_SIZE_1KB * 32)
 361     {
 362         grub_file_close(file);
 363         return 0;
 364     }
 365
 366     g_vhdboot_isolen = (int)file->size;
 367
 368     buflen = (int)(file->size + sizeof(ventoy_chain_head));
 369
 370 #ifdef GRUB_MACHINE_EFI
 371     g_vhdboot_totbuf = (char *)grub_efi_allocate_iso_buf(buflen);
 372 #else
 373     g_vhdboot_totbuf = (char *)grub_malloc(buflen);
 374 #endif
 375
 376     if (!g_vhdboot_totbuf)
 377     {
 378         grub_file_close(file);
 379         return 0;
 380     }
 381
 382     g_vhdboot_isobuf = g_vhdboot_totbuf + sizeof(ventoy_chain_head);
 383
 384     grub_file_read(file, g_vhdboot_isobuf, file->size);
 385     grub_file_close(file);
 386
 387     g_vhdboot_enable = 1;
 388
 389     return 0;
 390 }
 391
 392 static int ventoy_raw_trim_head(grub_uint64_t offset)
 393 {
 394     grub_uint32_t i;
 395     grub_uint32_t memsize;
 396     grub_uint32_t imgstart = 0;
 397     grub_uint32_t imgsecs = 0;
 398     grub_uint64_t sectors = 0;
 399     grub_uint64_t cursecs = 0;
 400     grub_uint64_t delta = 0;
 401
 402     if ((!g_img_chunk_list.chunk) || (!offset))
 403     {
 404         debug("image chunk not ready %p %lu\n", g_img_chunk_list.chunk, (ulong)offset);
 405         return 0;
 406     }
 407
 408     debug("image trim head %lu\n", (ulong)offset);
 409
 410     for (i = 0; i < g_img_chunk_list.cur_chunk; i++)
 411     {
 412         cursecs = g_img_chunk_list.chunk[i].disk_end_sector + 1 - g_img_chunk_list.chunk[i].disk_start_sector;
 413         sectors += cursecs;
 414         if (sectors >= offset)
 415         {
 416             delta = cursecs - (sectors - offset);
 417             break;
 418         }
 419     }
 420
 421     if (sectors < offset || i >= g_img_chunk_list.cur_chunk)
 422     {
 423         debug("Invalid size %lu %lu\n", (ulong)sectors, (ulong)offset);
 424         return 0;
 425     }
 426
 427     if (sectors == offset)
 428     {
 429         memsize = (g_img_chunk_list.cur_chunk - (i + 1)) * sizeof(ventoy_img_chunk);
 430         grub_memmove(g_img_chunk_list.chunk, g_img_chunk_list.chunk + i + 1, memsize);
 431         g_img_chunk_list.cur_chunk -= (i + 1);
 432     }
 433     else
 434     {
 435         g_img_chunk_list.chunk[i].disk_start_sector += delta;
 436         g_img_chunk_list.chunk[i].img_start_sector += (grub_uint32_t)(delta / 4);
 437
 438         if (i > 0)
 439         {
 440             memsize = (g_img_chunk_list.cur_chunk - i) * sizeof(ventoy_img_chunk);
 441             grub_memmove(g_img_chunk_list.chunk, g_img_chunk_list.chunk + i, memsize);
 442             g_img_chunk_list.cur_chunk -= i;
 443         }
 444     }
 445
 446     for (i = 0; i < g_img_chunk_list.cur_chunk; i++)
 447     {
 448         imgsecs = g_img_chunk_list.chunk[i].img_end_sector + 1 - g_img_chunk_list.chunk[i].img_start_sector;
 449         g_img_chunk_list.chunk[i].img_start_sector = imgstart;
 450         g_img_chunk_list.chunk[i].img_end_sector = imgstart + (imgsecs - 1);
 451         imgstart += imgsecs;
 452     }
 453
 454     return 0;
 455 }
 456
 457 grub_err_t ventoy_cmd_get_vtoy_type(grub_extcmd_context_t ctxt, int argc, char **args)
 458 {
 459     int i;
 460     int altboot = 0;
 461     int offset = -1;
 462     grub_file_t file;
 463     grub_uint8_t data = 0;
 464     vhd_footer_t vhdfoot;
 465     VDIPREHEADER vdihdr;
 466     char type[16] = {0};
 467     ventoy_gpt_info *gpt;
 468
 469     (void)ctxt;
 470
 471     g_img_trim_head_secnum = 0;
 472
 473     if (argc != 4)
 474     {
 475         return 0;
 476     }
 477
 478     file = grub_file_open(args[0], VENTOY_FILE_TYPE);
 479     if (!file)
 480     {
 481         debug("Failed to open file %s\n", args[0]);
 482         return 0;
 483     }
 484
 485     grub_snprintf(type, sizeof(type), "unknown");
 486
 487     grub_file_seek(file, file->size - 512);
 488     grub_file_read(file, &vhdfoot, sizeof(vhdfoot));
 489
 490     if (grub_strncmp(vhdfoot.cookie, "conectix", 8) == 0)
 491     {
 492         offset = 0;
 493         grub_snprintf(type, sizeof(type), "vhd%u", grub_swap_bytes32(vhdfoot.disktype));
 494     }
 495     else
 496     {
 497         grub_file_seek(file, 0);
 498         grub_file_read(file, &vdihdr, sizeof(vdihdr));
 499         if (vdihdr.u32Signature == VDI_IMAGE_SIGNATURE &&
 500             grub_strncmp(vdihdr.szFileInfo, VDI_IMAGE_FILE_INFO, grub_strlen(VDI_IMAGE_FILE_INFO)) == 0)
 501         {
 502             offset = 2 * 1048576;
 503             g_img_trim_head_secnum = offset / 512;
 504             grub_snprintf(type, sizeof(type), "vdi");
 505         }
 506         else
 507         {
 508             offset = 0;
 509             grub_snprintf(type, sizeof(type), "raw");
 510         }
 511     }
 512
 513     grub_env_set(args[1], type);
 514     debug("<%s> vtoy type: <%s> ", args[0], type);
 515
 516     if (offset >= 0)
 517     {
 518         gpt = grub_zalloc(sizeof(ventoy_gpt_info));
 519         if (!gpt)
 520         {
 521             grub_env_set(args[1], "unknown");
 522             goto end;
 523         }
 524
 525         grub_file_seek(file, offset);
 526         grub_file_read(file, gpt, sizeof(ventoy_gpt_info));
 527
 528         if (gpt->MBR.Byte55 != 0x55 || gpt->MBR.ByteAA != 0xAA)
 529         {
 530             grub_env_set(args[1], "unknown");
 531             debug("invalid mbr signature: 0x%x 0x%x\n", gpt->MBR.Byte55, gpt->MBR.ByteAA);
 532             goto end;
 533         }
 534
 535         if (grub_memcmp(gpt->Head.Signature, "EFI PART", 8) == 0)
 536         {
 537             grub_env_set(args[2], "gpt");
 538             debug("part type: %s\n", "GPT");
 539
 540             if (gpt->MBR.PartTbl[0].FsFlag == 0xEE)
 541             {
 542                 for (i = 0; i < 128; i++)
 543                 {
 544                     if (grub_memcmp(gpt->PartTbl[i].PartType, "Hah!IdontNeedEFI", 16) == 0)
 545                     {
 546                         debug("part %d is grub_bios part\n", i);
 547                         altboot = 1;
 548                         grub_env_set(args[3], "1");
 549                         break;
 550                     }
 551                     else if (gpt->PartTbl[i].LastLBA == 0)
 552                     {
 553                         break;
 554                     }
 555                 }
 556             }
 557
 558             if (!altboot)
 559             {
 560                 if (gpt->MBR.BootCode[92] == 0x22)
 561                 {
 562                     grub_file_seek(file, offset + 17908);
 563                     grub_file_read(file, &data, 1);
 564                     if (data == 0x23)
 565                     {
 566                         altboot = 1;
 567                         grub_env_set(args[3], "1");
 568                     }
 569                 }
 570             }
 571         }
 572         else
 573         {
 574             grub_env_set(args[2], "mbr");
 575             debug("part type: %s\n", "MBR");
 576
 577             for (i = 0; i < 4; i++)
 578             {
 579                 if (gpt->MBR.PartTbl[i].FsFlag == 0xEF)
 580                 {
 581                     debug("part %d is esp part in MBR mode\n", i);
 582                     altboot = 1;
 583                     grub_env_set(args[3], "1");
 584                     break;
 585                 }
 586             }
 587         }
 588     }
 589     else
 590     {
 591         debug("part type: %s\n", "xxx");
 592     }
 593
 594 end:
 595     grub_check_free(gpt);
 596     grub_file_close(file);
 597     VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 598 }
 599
 600 grub_err_t ventoy_cmd_raw_chain_data(grub_extcmd_context_t ctxt, int argc, char **args)
 601 {
 602     grub_uint32_t size = 0;
 603     grub_uint32_t img_chunk_size = 0;
 604     grub_file_t file;
 605     grub_disk_t disk;
 606     const char *pLastChain = NULL;
 607     ventoy_chain_head *chain;
 608     char envbuf[64];
 609
 610     (void)ctxt;
 611     (void)argc;
 612
 613     if (NULL == g_img_chunk_list.chunk)
 614     {
 615         grub_printf("ventoy not ready\n");
 616         return 1;
 617     }
 618
 619     if (g_img_trim_head_secnum > 0)
 620     {
 621         ventoy_raw_trim_head(g_img_trim_head_secnum);
 622     }
 623
 624     file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
 625     if (!file)
 626     {
 627         return 1;
 628     }
 629
 630     img_chunk_size = g_img_chunk_list.cur_chunk * sizeof(ventoy_img_chunk);
 631
 632     size = sizeof(ventoy_chain_head) + img_chunk_size;
 633
 634     pLastChain = grub_env_get("vtoy_chain_mem_addr");
 635     if (pLastChain)
 636     {
 637         chain = (ventoy_chain_head *)grub_strtoul(pLastChain, NULL, 16);
 638         if (chain)
 639         {
 640             debug("free last chain memory %p\n", chain);
 641             grub_free(chain);
 642         }
 643     }
 644
 645     chain = grub_malloc(size);
 646     if (!chain)
 647     {
 648         grub_printf("Failed to alloc chain memory size %u\n", size);
 649         grub_file_close(file);
 650         return 1;
 651     }
 652
 653     grub_snprintf(envbuf, sizeof(envbuf), "0x%lx", (unsigned long)chain);
 654     grub_env_set("vtoy_chain_mem_addr", envbuf);
 655     grub_snprintf(envbuf, sizeof(envbuf), "%u", size);
 656     grub_env_set("vtoy_chain_mem_size", envbuf);
 657
 658     grub_env_export("vtoy_chain_mem_addr");
 659     grub_env_export("vtoy_chain_mem_size");
 660
 661     grub_memset(chain, 0, sizeof(ventoy_chain_head));
 662
 663     /* part 1: os parameter */
 664     g_ventoy_chain_type = ventoy_chain_linux;
 665     ventoy_fill_os_param(file, &(chain->os_param));
 666
 667     /* part 2: chain head */
 668     disk = file->device->disk;
 669     chain->disk_drive = disk->id;
 670     chain->disk_sector_size = (1 << disk->log_sector_size);
 671
 672     chain->real_img_size_in_bytes = file->size;
 673     if (g_img_trim_head_secnum > 0)
 674     {
 675         chain->real_img_size_in_bytes -= g_img_trim_head_secnum * 512;
 676     }
 677
 678     chain->virt_img_size_in_bytes = chain->real_img_size_in_bytes;
 679     chain->boot_catalog = 0;
 680
 681     /* part 3: image chunk */
 682     chain->img_chunk_offset = sizeof(ventoy_chain_head);
 683     chain->img_chunk_num = g_img_chunk_list.cur_chunk;
 684     grub_memcpy((char *)chain + chain->img_chunk_offset, g_img_chunk_list.chunk, img_chunk_size);
 685
 686     grub_file_seek(file, g_img_trim_head_secnum * 512);
 687     grub_file_read(file, chain->boot_catalog_sector, 512);
 688
 689     grub_file_close(file);
 690
 691     VENTOY_CMD_RETURN(GRUB_ERR_NONE);
 692 }