#include <Protocol/SimpleFileSystem.h>
#include <Ventoy.h>
+UINT8 *g_iso_data_buf = NULL;
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;
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;
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;
{
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;
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 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,
(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)
{
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,
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;
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;
{
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)
{
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,
IN VOID *Buffer
)
{
+ UINT32 secNum = 0;
+ UINT64 offset = 0;
+
(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)
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;
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;
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,
{
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"Partition Driver");
debug("Connect partition driver %r", Status);
if (EFI_ERROR(Status))
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;
}
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))
{
return Status;
}
}
+
+ if (StrCmp(Name, L"\\EFI\\BOOT") == 0)
+ {
+ (*New)->Open = ventoy_wrapper_file_open;
+ }
}
return Status;
projects / Ventoy.git / blobdiff