Fix a bug about unaligned read in UEFI mode.

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

diff --git a/EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/Ventoy/VentoyProtocol.c b/EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/Ventoy/VentoyProtocol.c
index ed595b9f1c7b635bdcc67e281dbd3bdc5ba1584d..f9323cb933e5a86442e582e21a2540d9a257ba5a 100644 (file)
--- a/EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/Ventoy/VentoyProtocol.c
+++ b/EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/Ventoy/VentoyProtocol.c
@@ -36,8 +36,10 @@
 #include <Protocol/SimpleFileSystem.h>
 #include <Ventoy.h>
 
 #include <Protocol/SimpleFileSystem.h>
 #include <Ventoy.h>
 

+UINT8 *g_iso_data_buf = NULL;

 UINTN g_iso_buf_size = 0;
 BOOLEAN gMemdiskMode = FALSE;
 UINTN g_iso_buf_size = 0;
 BOOLEAN gMemdiskMode = FALSE;

+BOOLEAN gSector512Mode = FALSE;

 
 ventoy_sector_flag *g_sector_flag = NULL;
 UINT32 g_sector_flag_num = 0;
 
 ventoy_sector_flag *g_sector_flag = NULL;
 UINT32 g_sector_flag_num = 0;


@@ -67,6 +69,10 @@ STATIC EFI_INPUT_READ_KEY g_org_read_key = NULL;
 
 STATIC EFI_LOCATE_HANDLE g_org_locate_handle = NULL;
 
 
 STATIC EFI_LOCATE_HANDLE g_org_locate_handle = NULL;
 

+STATIC UINT8 g_sector_buf[2048];
+STATIC EFI_BLOCK_READ g_sector_2048_read = NULL;
+STATIC EFI_BLOCK_WRITE g_sector_2048_write = NULL;
+

 BOOLEAN ventoy_is_cdrom_dp_exist(VOID)
 {
     UINTN i = 0;
 BOOLEAN ventoy_is_cdrom_dp_exist(VOID)
 {
     UINTN i = 0;


@@ -142,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;
     
     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;
 
     ReadStart = Sector * 2048;
     ReadEnd = (Sector + Count) * 2048;


@@ -155,9 +161,17 @@ STATIC EFI_STATUS EFIAPI ventoy_read_iso_sector
             {
                 MapLba = (Sector - pchunk->img_start_sector) * 4 + pchunk->disk_start_sector;
             }
             {
                 MapLba = (Sector - pchunk->img_start_sector) * 4 + pchunk->disk_start_sector;
             }

-            else
+            else if (g_chain->disk_sector_size == 1024)
+            {
+                MapLba = (Sector - pchunk->img_start_sector) * 2 + pchunk->disk_start_sector;
+            }
+            else if (g_chain->disk_sector_size == 2048)

             {
             {

-                MapLba = (Sector - pchunk->img_start_sector) * 2048 / g_chain->disk_sector_size + pchunk->disk_start_sector;
+                MapLba = (Sector - pchunk->img_start_sector) + pchunk->disk_start_sector;
+            }
+            else if (g_chain->disk_sector_size == 4096)
+            {
+                MapLba = ((Sector - pchunk->img_start_sector) >> 1) + pchunk->disk_start_sector;

             }
 
             secLeft = pchunk->img_end_sector + 1 - Sector;
             }
 
             secLeft = pchunk->img_end_sector + 1 - Sector;


@@ -167,7 +181,7 @@ STATIC EFI_STATUS EFIAPI ventoy_read_iso_sector
                                      MapLba, secRead * 2048, pCurBuf);
             if (EFI_ERROR(Status))
             {
                                      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;
             }
 
                 return Status;
             }
 


@@ -240,6 +254,96 @@ STATIC EFI_STATUS EFIAPI ventoy_read_iso_sector
     return EFI_SUCCESS;    
 }
 
     return EFI_SUCCESS;    
 }
 

+STATIC EFI_STATUS EFIAPI ventoy_write_iso_sector
+(
+    IN UINT64                 Sector,
+    IN UINTN                  Count,
+    IN VOID                  *Buffer
+)
+{
+    EFI_STATUS Status = EFI_SUCCESS;
+    EFI_LBA MapLba = 0;
+    UINT32 i = 0;
+    UINTN secLeft = 0;
+    UINTN secRead = 0;
+    UINT64 ReadStart = 0;
+    UINT64 ReadEnd = 0;
+    UINT8 *pCurBuf = (UINT8 *)Buffer;
+    ventoy_img_chunk *pchunk = g_chunk;
+    EFI_BLOCK_IO_PROTOCOL *pRawBlockIo = gBlockData.pRawBlockIo;
+    
+    debug("write iso sector %lu  count %u", Sector, Count);
+
+    ReadStart = Sector * 2048;
+    ReadEnd = (Sector + Count) * 2048;
+
+    for (i = 0; Count > 0 && i < g_img_chunk_num; i++, pchunk++)
+    {
+        if (Sector >= pchunk->img_start_sector && Sector <= pchunk->img_end_sector)
+        {
+            if (g_chain->disk_sector_size == 512)
+            {
+                MapLba = (Sector - pchunk->img_start_sector) * 4 + pchunk->disk_start_sector;
+            }
+            else if (g_chain->disk_sector_size == 1024)
+            {
+                MapLba = (Sector - pchunk->img_start_sector) * 2 + pchunk->disk_start_sector;
+            }
+            else if (g_chain->disk_sector_size == 2048)
+            {
+                MapLba = (Sector - pchunk->img_start_sector) + pchunk->disk_start_sector;
+            }
+            else if (g_chain->disk_sector_size == 4096)
+            {
+                MapLba = ((Sector - pchunk->img_start_sector) >> 1) + pchunk->disk_start_sector;
+            }
+
+
+            secLeft = pchunk->img_end_sector + 1 - Sector;
+            secRead = (Count < secLeft) ? Count : secLeft;
+
+            Status = pRawBlockIo->WriteBlocks(pRawBlockIo, pRawBlockIo->Media->MediaId,
+                                     MapLba, secRead * 2048, pCurBuf);
+            if (EFI_ERROR(Status))
+            {
+                debug("Raw disk write block failed %r LBA:%lu Count:%u", Status, MapLba, secRead);
+                return Status;
+            }
+
+            Count -= secRead;
+            Sector += secRead;
+            pCurBuf += secRead * 2048;
+        }
+    }
+
+    return EFI_SUCCESS;    
+}
+
+EFI_STATUS EFIAPI ventoy_block_io_ramdisk_write 
+(
+    IN EFI_BLOCK_IO_PROTOCOL          *This,
+    IN UINT32                          MediaId,
+    IN EFI_LBA                         Lba,
+    IN UINTN                           BufferSize,
+    IN VOID                           *Buffer
+) 
+{
+    (VOID)This;
+    (VOID)MediaId;
+    (VOID)Lba;
+    (VOID)BufferSize;
+    (VOID)Buffer;
+
+    if (!gSector512Mode)
+    {
+        return EFI_WRITE_PROTECTED;
+    }
+
+    CopyMem(g_iso_data_buf + (Lba * 2048), Buffer, BufferSize);
+
+       return EFI_SUCCESS;
+}
+

 EFI_STATUS EFIAPI ventoy_block_io_ramdisk_read 
 (
     IN EFI_BLOCK_IO_PROTOCOL          *This,
 EFI_STATUS EFIAPI ventoy_block_io_ramdisk_read 
 (
     IN EFI_BLOCK_IO_PROTOCOL          *This,


@@ -254,7 +358,7 @@ EFI_STATUS EFIAPI ventoy_block_io_ramdisk_read
     (VOID)This;
     (VOID)MediaId;
 
     (VOID)This;
     (VOID)MediaId;
 

-    CopyMem(Buffer, (char *)g_chain + (Lba * 2048), BufferSize);
+    CopyMem(Buffer, g_iso_data_buf + (Lba * 2048), BufferSize);

     
     if (g_blockio_start_record_bcd && FALSE == g_blockio_bcd_read_done)
     {
     
     if (g_blockio_start_record_bcd && FALSE == g_blockio_bcd_read_done)
     {


@@ -320,7 +424,7 @@ end:
     return Lba;
 }
 
     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,
 (
     IN EFI_BLOCK_IO_PROTOCOL          *This,
     IN UINT32                          MediaId,


@@ -333,6 +437,8 @@ EFI_STATUS EFIAPI ventoy_block_io_read
     UINT32 j = 0;
     UINT32 lbacount = 0;
     UINT32 secNum = 0;
     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;
     UINT64 offset = 0;
     EFI_LBA curlba = 0;
     EFI_LBA lastlba = 0;


@@ -340,7 +446,7 @@ EFI_STATUS EFIAPI ventoy_block_io_read
     ventoy_sector_flag *cur_flag;
     ventoy_virt_chunk *node;
     
     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;
 
 
     secNum = BufferSize / 2048;
 


@@ -356,6 +462,26 @@ EFI_STATUS EFIAPI ventoy_block_io_read
     {
         return ventoy_read_iso_sector(Lba, secNum, Buffer);
     }
     {
         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)
     {
 
     if (secNum > g_sector_flag_num)
     {


@@ -424,6 +550,42 @@ EFI_STATUS EFIAPI ventoy_block_io_read
        return EFI_SUCCESS;
 }
 
        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,
 EFI_STATUS EFIAPI ventoy_block_io_write 
 (
     IN EFI_BLOCK_IO_PROTOCOL          *This,


@@ -433,12 +595,21 @@ EFI_STATUS EFIAPI ventoy_block_io_write
     IN VOID                           *Buffer
 ) 
 {
     IN VOID                           *Buffer
 ) 
 {

+    UINT32 secNum = 0;
+    UINT64 offset = 0;
+    

     (VOID)This;
     (VOID)MediaId;
     (VOID)This;
     (VOID)MediaId;

-    (VOID)Lba;
-    (VOID)BufferSize;
-    (VOID)Buffer;
-       return EFI_WRITE_PROTECTED;
+
+    if (!gSector512Mode)
+    {
+        return EFI_WRITE_PROTECTED;
+    }
+
+    secNum = BufferSize / 2048;
+    offset = Lba * 2048;
+
+    return ventoy_write_iso_sector(Lba, secNum, Buffer);

 }
 
 EFI_STATUS EFIAPI ventoy_block_io_flush(IN EFI_BLOCK_IO_PROTOCOL *This)
 }
 
 EFI_STATUS EFIAPI ventoy_block_io_flush(IN EFI_BLOCK_IO_PROTOCOL *This)


@@ -570,6 +741,126 @@ end:
     return Status;
 }
 
     return Status;
 }
 

+EFI_STATUS EFIAPI ventoy_block_io_read_512
+(
+    IN EFI_BLOCK_IO_PROTOCOL          *This,
+    IN UINT32                          MediaId,
+    IN EFI_LBA                         Lba,
+    IN UINTN                           BufferSize,
+    OUT VOID                          *Buffer
+)
+{
+    EFI_LBA Mod;
+    UINTN ReadSize;
+    UINT8 *CurBuf = NULL;
+    EFI_STATUS Status = EFI_SUCCESS;
+
+    debug("ventoy_block_io_read_512 %lu %lu Buffer:%p\n", Lba, BufferSize / 512, Buffer);
+
+    CurBuf = (UINT8 *)Buffer;
+
+    Mod = Lba % 4;
+    if (Mod > 0)
+    {
+        Status |= g_sector_2048_read(This, MediaId, Lba / 4, 2048, g_sector_buf);
+
+        if (BufferSize <= (4 - Mod) * 512)
+        {
+            CopyMem(CurBuf, g_sector_buf + Mod * 512, BufferSize);
+            return EFI_SUCCESS;
+        }
+        else
+        {
+            ReadSize = (4 - Mod) * 512;
+            CopyMem(CurBuf, g_sector_buf + Mod * 512, ReadSize);
+            CurBuf += ReadSize;
+            Lba += (4 - Mod);
+            BufferSize -= ReadSize;
+        }
+    }
+
+    if (BufferSize >= 2048)
+    {
+        ReadSize = BufferSize / 2048 * 2048;
+            
+        Status |= g_sector_2048_read(This, MediaId, Lba / 4, ReadSize, CurBuf);
+        CurBuf += ReadSize;
+        
+        Lba += ReadSize / 512;
+        BufferSize -= ReadSize;
+    }
+
+    if (BufferSize > 0)
+    {
+        Status |= g_sector_2048_read(This, MediaId, Lba / 4, 2048, g_sector_buf);
+        CopyMem(CurBuf, g_sector_buf, BufferSize);
+    }
+
+    return Status;
+}
+
+EFI_STATUS EFIAPI ventoy_block_io_write_512
+(
+    IN EFI_BLOCK_IO_PROTOCOL          *This,
+    IN UINT32                          MediaId,
+    IN EFI_LBA                         Lba,
+    IN UINTN                           BufferSize,
+    IN VOID                           *Buffer
+)
+{
+    EFI_LBA Mod;
+    UINTN ReadSize;
+    UINT8 *CurBuf = NULL;
+    EFI_STATUS Status = EFI_SUCCESS;
+
+    debug("ventoy_block_io_write_512 %lu %lu\n", Lba, BufferSize / 512);
+
+    CurBuf = (UINT8 *)Buffer;
+
+    Mod = Lba % 4;
+    if (Mod > 0)
+    {
+        Status |= g_sector_2048_read(This, MediaId, Lba / 4, 2048, g_sector_buf);
+
+        if (BufferSize <= (4 - Mod) * 512)
+        {
+            CopyMem(g_sector_buf + Mod * 512, CurBuf, BufferSize);
+            return g_sector_2048_write(This, MediaId, Lba / 4, 2048, g_sector_buf);
+        }
+        else
+        {
+            ReadSize = (4 - Mod) * 512;
+            CopyMem(g_sector_buf + Mod * 512, CurBuf, ReadSize);
+            g_sector_2048_write(This, MediaId, Lba / 4, 2048, g_sector_buf);
+            
+            CurBuf += ReadSize;
+            Lba += (4 - Mod);
+            BufferSize -= ReadSize;
+        }
+    }
+
+    if (BufferSize >= 2048)
+    {
+        ReadSize = BufferSize / 2048 * 2048;
+            
+        Status |= g_sector_2048_write(This, MediaId, Lba / 4, ReadSize, CurBuf);
+        CurBuf += ReadSize;
+        
+        Lba += ReadSize / 512;
+        BufferSize -= ReadSize;
+    }
+
+    if (BufferSize > 0)
+    {
+        Status |= g_sector_2048_read(This, MediaId, Lba / 4, 2048, g_sector_buf);
+        
+        CopyMem(g_sector_buf, CurBuf, BufferSize);
+        g_sector_2048_write(This, MediaId, Lba / 4, 2048, g_sector_buf);
+    }
+
+    return Status;
+}
+

 EFI_STATUS EFIAPI ventoy_install_blockio(IN EFI_HANDLE ImageHandle, IN UINT64 ImgSize)
 {   
     EFI_STATUS Status = EFI_SUCCESS;
 EFI_STATUS EFIAPI ventoy_install_blockio(IN EFI_HANDLE ImageHandle, IN UINT64 ImgSize)
 {   
     EFI_STATUS Status = EFI_SUCCESS;


@@ -579,9 +870,18 @@ EFI_STATUS EFIAPI ventoy_install_blockio(IN EFI_HANDLE ImageHandle, IN UINT64 Im
 
     debug("install block io protocol %p", ImageHandle);
     ventoy_debug_pause();
 
     debug("install block io protocol %p", ImageHandle);
     ventoy_debug_pause();

+
+    if (gSector512Mode)
+    {
+        gBlockData.Media.BlockSize = 512;
+        gBlockData.Media.LastBlock = ImgSize / 512 - 1;
+    }
+    else
+    {
+        gBlockData.Media.BlockSize = 2048;
+        gBlockData.Media.LastBlock = ImgSize / 2048 - 1;        
+    }

     
     

-    gBlockData.Media.BlockSize = 2048;
-    gBlockData.Media.LastBlock = ImgSize / 2048 - 1;

     gBlockData.Media.ReadOnly = TRUE;
     gBlockData.Media.MediaPresent = 1;
     gBlockData.Media.LogicalBlocksPerPhysicalBlock = 1;
     gBlockData.Media.ReadOnly = TRUE;
     gBlockData.Media.MediaPresent = 1;
     gBlockData.Media.LogicalBlocksPerPhysicalBlock = 1;


@@ -589,8 +889,20 @@ EFI_STATUS EFIAPI ventoy_install_blockio(IN EFI_HANDLE ImageHandle, IN UINT64 Im
        pBlockIo->Revision = EFI_BLOCK_IO_PROTOCOL_REVISION3;
        pBlockIo->Media = &(gBlockData.Media);
        pBlockIo->Reset = ventoy_block_io_reset;
        pBlockIo->Revision = EFI_BLOCK_IO_PROTOCOL_REVISION3;
        pBlockIo->Media = &(gBlockData.Media);
        pBlockIo->Reset = ventoy_block_io_reset;

-    pBlockIo->ReadBlocks = gMemdiskMode ? ventoy_block_io_ramdisk_read : ventoy_block_io_read;
-       pBlockIo->WriteBlocks = ventoy_block_io_write;
+
+    if (gSector512Mode)
+    {
+        g_sector_2048_read = gMemdiskMode ? ventoy_block_io_ramdisk_read : ventoy_block_io_read;
+        g_sector_2048_write = gMemdiskMode ? ventoy_block_io_ramdisk_write : ventoy_block_io_write;
+        pBlockIo->ReadBlocks = ventoy_block_io_read_512;
+       pBlockIo->WriteBlocks = ventoy_block_io_write_512;
+    }
+    else
+    {
+        pBlockIo->ReadBlocks = gMemdiskMode ? ventoy_block_io_ramdisk_read : ventoy_block_io_read;        
+       pBlockIo->WriteBlocks = ventoy_block_io_write;
+    }
+        

        pBlockIo->FlushBlocks = ventoy_block_io_flush;
 
     Status = gBS->InstallMultipleProtocolInterfaces(&gBlockData.Handle,
        pBlockIo->FlushBlocks = ventoy_block_io_flush;
 
     Status = gBS->InstallMultipleProtocolInterfaces(&gBlockData.Handle,


@@ -602,10 +914,10 @@ EFI_STATUS EFIAPI ventoy_install_blockio(IN EFI_HANDLE ImageHandle, IN UINT64 Im
     {
         return Status;
     }
     {
         return Status;
     }

-    
+

     Status = ventoy_connect_driver(gBlockData.Handle, L"Disk I/O Driver");
     debug("Connect disk IO driver %r", Status);
     Status = ventoy_connect_driver(gBlockData.Handle, L"Disk I/O Driver");
     debug("Connect disk IO driver %r", Status);

-    
+

     Status = ventoy_connect_driver(gBlockData.Handle, L"Partition Driver");
     debug("Connect partition driver %r", Status);
     if (EFI_ERROR(Status))
     Status = ventoy_connect_driver(gBlockData.Handle, L"Partition Driver");
     debug("Connect partition driver %r", Status);
     if (EFI_ERROR(Status))


@@ -699,8 +1011,16 @@ STATIC EFI_STATUS EFIAPI
 ventoy_wrapper_file_set_pos(EFI_FILE_HANDLE This, UINT64 Position)
 {
     (VOID)This;
 ventoy_wrapper_file_set_pos(EFI_FILE_HANDLE This, UINT64 Position)
 {
     (VOID)This;

+        
+    if (Position <= g_efi_file_replace.FileSizeBytes)
+    {
+        g_efi_file_replace.CurPos = Position;
+    }
+    else
+    {
+        g_efi_file_replace.CurPos = g_efi_file_replace.FileSizeBytes;
+    }

     
     

-    g_efi_file_replace.CurPos = Position;

     return EFI_SUCCESS;
 }
 
     return EFI_SUCCESS;
 }
 


@@ -815,6 +1135,8 @@ STATIC EFI_STATUS EFIAPI ventoy_wrapper_file_open
     CHAR8 TmpName[256];
     ventoy_virt_chunk *virt = NULL;
 
     CHAR8 TmpName[256];
     ventoy_virt_chunk *virt = NULL;
 

+    debug("## ventoy_wrapper_file_open <%s> ", Name);
+

     Status = g_original_fopen(This, New, Name, Mode, Attributes);
     if (EFI_ERROR(Status))
     {
     Status = g_original_fopen(This, New, Name, Mode, Attributes);
     if (EFI_ERROR(Status))
     {


@@ -850,6 +1172,11 @@ STATIC EFI_STATUS EFIAPI ventoy_wrapper_file_open
                 return Status;
             }
         }
                 return Status;
             }
         }

+
+        if (StrCmp(Name, L"\\EFI\\BOOT") == 0)
+        {
+            (*New)->Open = ventoy_wrapper_file_open;
+        }

     }
 
     return Status;
     }
 
     return Status;