]> glassweightruler.freedombox.rocks Git - Ventoy.git/blob - EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/Ventoy/VentoyProtocol.c
projects / Ventoy.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix a bug about unaligned read in UEFI mode.
[Ventoy.git] / EDK2 / edk2_mod / edk2-edk2-stable201911 / MdeModulePkg / Application / Ventoy / VentoyProtocol.c
1 /******************************************************************************
2 * Ventoy.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 <Uefi.h>
22 #include <Library/DebugLib.h>
23 #include <Library/PrintLib.h>
24 #include <Library/UefiLib.h>
25 #include <Library/BaseMemoryLib.h>
26 #include <Library/DevicePathLib.h>
27 #include <Library/MemoryAllocationLib.h>
28 #include <Library/UefiBootServicesTableLib.h>
29 #include <Library/UefiRuntimeServicesTableLib.h>
30 #include <Library/UefiApplicationEntryPoint.h>
31 #include <Protocol/LoadedImage.h>
32 #include <Guid/FileInfo.h>
33 #include <Guid/FileSystemInfo.h>
34 #include <Protocol/BlockIo.h>
35 #include <Protocol/RamDisk.h>
36 #include <Protocol/SimpleFileSystem.h>
37 #include <Ventoy.h>
38
39 UINT8 *g_iso_data_buf = NULL;
40 UINTN g_iso_buf_size = 0;
41 BOOLEAN gMemdiskMode = FALSE;
42 BOOLEAN gSector512Mode = FALSE;
43
44 ventoy_sector_flag *g_sector_flag = NULL;
45 UINT32 g_sector_flag_num = 0;
46
47 EFI_FILE_OPEN g_original_fopen = NULL;
48 EFI_FILE_CLOSE g_original_fclose = NULL;
49 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_OPEN_VOLUME g_original_open_volume = NULL;
50
51 /* EFI block device vendor device path GUID */
52 EFI_GUID gVtoyBlockDevicePathGuid = VTOY_BLOCK_DEVICE_PATH_GUID;
53
54 #define VENTOY_ISO9660_SECTOR_OVERFLOW 2097152
55
56 BOOLEAN g_fixup_iso9660_secover_enable = FALSE;
57 BOOLEAN g_fixup_iso9660_secover_start = FALSE;
58 UINT64 g_fixup_iso9660_secover_1st_secs = 0;
59 UINT64 g_fixup_iso9660_secover_cur_secs = 0;
60 UINT64 g_fixup_iso9660_secover_tot_secs = 0;
61
62 STATIC UINTN g_keyboard_hook_count = 0;
63 STATIC BOOLEAN g_blockio_start_record_bcd = FALSE;
64 STATIC BOOLEAN g_blockio_bcd_read_done = FALSE;
65
66 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *g_con_simple_input_ex = NULL;
67 STATIC EFI_INPUT_READ_KEY_EX g_org_read_key_ex = NULL;
68 STATIC EFI_INPUT_READ_KEY g_org_read_key = NULL;
69
70 STATIC EFI_LOCATE_HANDLE g_org_locate_handle = NULL;
71
72 STATIC UINT8 g_sector_buf[2048];
73 STATIC EFI_BLOCK_READ g_sector_2048_read = NULL;
74 STATIC EFI_BLOCK_WRITE g_sector_2048_write = NULL;
75
76 BOOLEAN ventoy_is_cdrom_dp_exist(VOID)
77 {
78 UINTN i = 0;
79 UINTN Count = 0;
80 EFI_HANDLE *Handles = NULL;
81 EFI_STATUS Status = EFI_SUCCESS;
82 EFI_DEVICE_PATH_PROTOCOL *DevicePath = NULL;
83
84 Status = gBS->LocateHandleBuffer(ByProtocol, &gEfiDevicePathProtocolGuid,
85 NULL, &Count, &Handles);
86 if (EFI_ERROR(Status))
87 {
88 return FALSE;
89 }
90
91 for (i = 0; i < Count; i++)
92 {
93 Status = gBS->HandleProtocol(Handles[i], &gEfiDevicePathProtocolGuid, (VOID **)&DevicePath);
94 if (EFI_ERROR(Status))
95 {
96 continue;
97 }
98
99 while (!IsDevicePathEnd(DevicePath))
100 {
101 if (MEDIA_DEVICE_PATH == DevicePath->Type && MEDIA_CDROM_DP == DevicePath->SubType)
102 {
103 FreePool(Handles);
104 return TRUE;
105 }
106
107 DevicePath = NextDevicePathNode(DevicePath);
108 }
109 }
110
111 FreePool(Handles);
112 return FALSE;
113 }
114
115 #if 0
116 /* Block IO procotol */
117 #endif
118
119 EFI_STATUS EFIAPI ventoy_block_io_reset
120 (
121 IN EFI_BLOCK_IO_PROTOCOL *This,
122 IN BOOLEAN ExtendedVerification
123 )
124 {
125 (VOID)This;
126 (VOID)ExtendedVerification;
127 return EFI_SUCCESS;
128 }
129
130 STATIC EFI_STATUS EFIAPI ventoy_read_iso_sector
131 (
132 IN UINT64 Sector,
133 IN UINTN Count,
134 OUT VOID *Buffer
135 )
136 {
137 EFI_STATUS Status = EFI_SUCCESS;
138 EFI_LBA MapLba = 0;
139 UINT32 i = 0;
140 UINTN secLeft = 0;
141 UINTN secRead = 0;
142 UINT64 ReadStart = 0;
143 UINT64 ReadEnd = 0;
144 UINT64 OverrideStart = 0;
145 UINT64 OverrideEnd= 0;
146 UINT8 *pCurBuf = (UINT8 *)Buffer;
147 ventoy_img_chunk *pchunk = g_chunk;
148 ventoy_override_chunk *pOverride = g_override_chunk;
149 EFI_BLOCK_IO_PROTOCOL *pRawBlockIo = gBlockData.pRawBlockIo;
150
151 debug("read iso sector %lu count %u Buffer:%p Align:%u", Sector, Count, Buffer, pRawBlockIo->Media->IoAlign);
152
153 ReadStart = Sector * 2048;
154 ReadEnd = (Sector + Count) * 2048;
155
156 for (i = 0; Count > 0 && i < g_img_chunk_num; i++, pchunk++)
157 {
158 if (Sector >= pchunk->img_start_sector && Sector <= pchunk->img_end_sector)
159 {
160 if (g_chain->disk_sector_size == 512)
161 {
162 MapLba = (Sector - pchunk->img_start_sector) * 4 + pchunk->disk_start_sector;
163 }
164 else if (g_chain->disk_sector_size == 1024)
165 {
166 MapLba = (Sector - pchunk->img_start_sector) * 2 + pchunk->disk_start_sector;
167 }
168 else if (g_chain->disk_sector_size == 2048)
169 {
170 MapLba = (Sector - pchunk->img_start_sector) + pchunk->disk_start_sector;
171 }
172 else if (g_chain->disk_sector_size == 4096)
173 {
174 MapLba = ((Sector - pchunk->img_start_sector) >> 1) + pchunk->disk_start_sector;
175 }
176
177 secLeft = pchunk->img_end_sector + 1 - Sector;
178 secRead = (Count < secLeft) ? Count : secLeft;
179
180 Status = pRawBlockIo->ReadBlocks(pRawBlockIo, pRawBlockIo->Media->MediaId,
181 MapLba, secRead * 2048, pCurBuf);
182 if (EFI_ERROR(Status))
183 {
184 debug("Raw disk read block failed %r LBA:%lu Count:%u %p", Status, MapLba, secRead, pCurBuf);
185 return Status;
186 }
187
188 Count -= secRead;
189 Sector += secRead;
190 pCurBuf += secRead * 2048;
191 }
192 }
193
194 if (ReadStart > g_chain->real_img_size_in_bytes)
195 {
196 return EFI_SUCCESS;
197 }
198
199 /* override data */
200 pCurBuf = (UINT8 *)Buffer;
201 for (i = 0; i < g_override_chunk_num; i++, pOverride++)
202 {
203 OverrideStart = pOverride->img_offset;
204 OverrideEnd = pOverride->img_offset + pOverride->override_size;
205
206 if (OverrideStart >= ReadEnd || ReadStart >= OverrideEnd)
207 {
208 continue;
209 }
210
211 if (ReadStart <= OverrideStart)
212 {
213 if (ReadEnd <= OverrideEnd)
214 {
215 CopyMem(pCurBuf + OverrideStart - ReadStart, pOverride->override_data, ReadEnd - OverrideStart);
216 }
217 else
218 {
219 CopyMem(pCurBuf + OverrideStart - ReadStart, pOverride->override_data, pOverride->override_size);
220 }
221 }
222 else
223 {
224 if (ReadEnd <= OverrideEnd)
225 {
226 CopyMem(pCurBuf, pOverride->override_data + ReadStart - OverrideStart, ReadEnd - ReadStart);
227 }
228 else
229 {
230 CopyMem(pCurBuf, pOverride->override_data + ReadStart - OverrideStart, OverrideEnd - ReadStart);
231 }
232 }
233
234 if (g_fixup_iso9660_secover_enable && (!g_fixup_iso9660_secover_start) &&
235 pOverride->override_size == sizeof(ventoy_iso9660_override))
236 {
237 ventoy_iso9660_override *dirent = (ventoy_iso9660_override *)pOverride->override_data;
238 if (dirent->first_sector >= VENTOY_ISO9660_SECTOR_OVERFLOW)
239 {
240 g_fixup_iso9660_secover_start = TRUE;
241 g_fixup_iso9660_secover_cur_secs = 0;
242 }
243 }
244 }
245
246 if (g_blockio_start_record_bcd && FALSE == g_blockio_bcd_read_done)
247 {
248 if (*(UINT32 *)Buffer == 0x66676572)
249 {
250 g_blockio_bcd_read_done = TRUE;
251 }
252 }
253
254 return EFI_SUCCESS;
255 }
256
257 STATIC EFI_STATUS EFIAPI ventoy_write_iso_sector
258 (
259 IN UINT64 Sector,
260 IN UINTN Count,
261 IN VOID *Buffer
262 )
263 {
264 EFI_STATUS Status = EFI_SUCCESS;
265 EFI_LBA MapLba = 0;
266 UINT32 i = 0;
267 UINTN secLeft = 0;
268 UINTN secRead = 0;
269 UINT64 ReadStart = 0;
270 UINT64 ReadEnd = 0;
271 UINT8 *pCurBuf = (UINT8 *)Buffer;
272 ventoy_img_chunk *pchunk = g_chunk;
273 EFI_BLOCK_IO_PROTOCOL *pRawBlockIo = gBlockData.pRawBlockIo;
274
275 debug("write iso sector %lu count %u", Sector, Count);
276
277 ReadStart = Sector * 2048;
278 ReadEnd = (Sector + Count) * 2048;
279
280 for (i = 0; Count > 0 && i < g_img_chunk_num; i++, pchunk++)
281 {
282 if (Sector >= pchunk->img_start_sector && Sector <= pchunk->img_end_sector)
283 {
284 if (g_chain->disk_sector_size == 512)
285 {
286 MapLba = (Sector - pchunk->img_start_sector) * 4 + pchunk->disk_start_sector;
287 }
288 else if (g_chain->disk_sector_size == 1024)
289 {
290 MapLba = (Sector - pchunk->img_start_sector) * 2 + pchunk->disk_start_sector;
291 }
292 else if (g_chain->disk_sector_size == 2048)
293 {
294 MapLba = (Sector - pchunk->img_start_sector) + pchunk->disk_start_sector;
295 }
296 else if (g_chain->disk_sector_size == 4096)
297 {
298 MapLba = ((Sector - pchunk->img_start_sector) >> 1) + pchunk->disk_start_sector;
299 }
300
301
302 secLeft = pchunk->img_end_sector + 1 - Sector;
303 secRead = (Count < secLeft) ? Count : secLeft;
304
305 Status = pRawBlockIo->WriteBlocks(pRawBlockIo, pRawBlockIo->Media->MediaId,
306 MapLba, secRead * 2048, pCurBuf);
307 if (EFI_ERROR(Status))
308 {
309 debug("Raw disk write block failed %r LBA:%lu Count:%u", Status, MapLba, secRead);
310 return Status;
311 }
312
313 Count -= secRead;
314 Sector += secRead;
315 pCurBuf += secRead * 2048;
316 }
317 }
318
319 return EFI_SUCCESS;
320 }
321
322 EFI_STATUS EFIAPI ventoy_block_io_ramdisk_write
323 (
324 IN EFI_BLOCK_IO_PROTOCOL *This,
325 IN UINT32 MediaId,
326 IN EFI_LBA Lba,
327 IN UINTN BufferSize,
328 IN VOID *Buffer
329 )
330 {
331 (VOID)This;
332 (VOID)MediaId;
333 (VOID)Lba;
334 (VOID)BufferSize;
335 (VOID)Buffer;
336
337 if (!gSector512Mode)
338 {
339 return EFI_WRITE_PROTECTED;
340 }
341
342 CopyMem(g_iso_data_buf + (Lba * 2048), Buffer, BufferSize);
343
344 return EFI_SUCCESS;
345 }
346
347 EFI_STATUS EFIAPI ventoy_block_io_ramdisk_read
348 (
349 IN EFI_BLOCK_IO_PROTOCOL *This,
350 IN UINT32 MediaId,
351 IN EFI_LBA Lba,
352 IN UINTN BufferSize,
353 OUT VOID *Buffer
354 )
355 {
356 //debug("### ventoy_block_io_ramdisk_read sector:%u count:%u", (UINT32)Lba, (UINT32)BufferSize / 2048);
357
358 (VOID)This;
359 (VOID)MediaId;
360
361 CopyMem(Buffer, g_iso_data_buf + (Lba * 2048), BufferSize);
362
363 if (g_blockio_start_record_bcd && FALSE == g_blockio_bcd_read_done)
364 {
365 if (*(UINT32 *)Buffer == 0x66676572)
366 {
367 g_blockio_bcd_read_done = TRUE;
368 }
369 }
370
371 return EFI_SUCCESS;
372 }
373
374 EFI_LBA EFIAPI ventoy_fixup_iso9660_sector(IN EFI_LBA Lba, UINT32 secNum)
375 {
376 UINT32 i = 0;
377
378 if (g_fixup_iso9660_secover_cur_secs > 0)
379 {
380 Lba += VENTOY_ISO9660_SECTOR_OVERFLOW;
381 g_fixup_iso9660_secover_cur_secs += secNum;
382 if (g_fixup_iso9660_secover_cur_secs >= g_fixup_iso9660_secover_tot_secs)
383 {
384 g_fixup_iso9660_secover_start = FALSE;
385 goto end;
386 }
387 }
388 else
389 {
390 ventoy_iso9660_override *dirent;
391 ventoy_override_chunk *pOverride;
392
393 for (i = 0, pOverride = g_override_chunk; i < g_override_chunk_num; i++, pOverride++)
394 {
395 dirent = (ventoy_iso9660_override *)pOverride->override_data;
396 if (Lba == dirent->first_sector)
397 {
398 g_fixup_iso9660_secover_start = FALSE;
399 goto end;
400 }
401 }
402
403 if (g_fixup_iso9660_secover_start)
404 {
405 for (i = 0, pOverride = g_override_chunk; i < g_override_chunk_num; i++, pOverride++)
406 {
407 dirent = (ventoy_iso9660_override *)pOverride->override_data;
408 if (Lba + VENTOY_ISO9660_SECTOR_OVERFLOW == dirent->first_sector)
409 {
410 g_fixup_iso9660_secover_tot_secs = (dirent->size + 2047) / 2048;
411 g_fixup_iso9660_secover_cur_secs = secNum;
412 if (g_fixup_iso9660_secover_cur_secs >= g_fixup_iso9660_secover_tot_secs)
413 {
414 g_fixup_iso9660_secover_start = FALSE;
415 }
416 Lba += VENTOY_ISO9660_SECTOR_OVERFLOW;
417 goto end;
418 }
419 }
420 }
421 }
422
423 end:
424 return Lba;
425 }
426
427 EFI_STATUS EFIAPI ventoy_block_io_read_real
428 (
429 IN EFI_BLOCK_IO_PROTOCOL *This,
430 IN UINT32 MediaId,
431 IN EFI_LBA Lba,
432 IN UINTN BufferSize,
433 OUT VOID *Buffer
434 )
435 {
436 UINT32 i = 0;
437 UINT32 j = 0;
438 UINT32 lbacount = 0;
439 UINT32 secNum = 0;
440 UINT32 TmpNum = 0;
441 UINT64 VirtSec = 0;
442 UINT64 offset = 0;
443 EFI_LBA curlba = 0;
444 EFI_LBA lastlba = 0;
445 UINT8 *lastbuffer;
446 ventoy_sector_flag *cur_flag;
447 ventoy_virt_chunk *node;
448
449 debug("### block_io_read_real sector:%u count:%u Buffer:%p", (UINT32)Lba, (UINT32)BufferSize / 2048, Buffer);
450
451 secNum = BufferSize / 2048;
452
453 /* Workaround for SSTR PE loader error */
454 if (g_fixup_iso9660_secover_start)
455 {
456 Lba = ventoy_fixup_iso9660_sector(Lba, secNum);
457 }
458
459 offset = Lba * 2048;
460
461 if (offset + BufferSize <= g_chain->real_img_size_in_bytes)
462 {
463 return ventoy_read_iso_sector(Lba, secNum, Buffer);
464 }
465 else if (offset < g_chain->real_img_size_in_bytes)
466 {
467 TmpNum = (g_chain->real_img_size_in_bytes - offset) / 2048;
468 ventoy_read_iso_sector(Lba, TmpNum, Buffer);
469
470 Lba += TmpNum;
471 secNum -= TmpNum;
472 Buffer = (UINT8 *)Buffer + (g_chain->real_img_size_in_bytes - offset);
473 offset = Lba * 2048;
474 }
475
476 VirtSec = g_chain->virt_img_size_in_bytes / 2048;
477 if (Lba >= VirtSec)
478 {
479 return EFI_SUCCESS;
480 }
481 else if (Lba + secNum > VirtSec)
482 {
483 secNum = VirtSec - Lba;
484 }
485
486 if (secNum > g_sector_flag_num)
487 {
488 cur_flag = AllocatePool(secNum * sizeof(ventoy_sector_flag));
489 if (NULL == cur_flag)
490 {
491 return EFI_OUT_OF_RESOURCES;
492 }
493
494 FreePool(g_sector_flag);
495 g_sector_flag = cur_flag;
496 g_sector_flag_num = secNum;
497 }
498
499 for (curlba = Lba, cur_flag = g_sector_flag, j = 0; j < secNum; j++, curlba++, cur_flag++)
500 {
501 cur_flag->flag = 0;
502 for (node = g_virt_chunk, i = 0; i < g_virt_chunk_num; i++, node++)
503 {
504 if (curlba >= node->mem_sector_start && curlba < node->mem_sector_end)
505 {
506 CopyMem((UINT8 *)Buffer + j * 2048,
507 (char *)g_virt_chunk + node->mem_sector_offset + (curlba - node->mem_sector_start) * 2048,
508 2048);
509 cur_flag->flag = 1;
510 break;
511 }
512 else if (curlba >= node->remap_sector_start && curlba < node->remap_sector_end)
513 {
514 cur_flag->remap_lba = node->org_sector_start + curlba - node->remap_sector_start;
515 cur_flag->flag = 2;
516 break;
517 }
518 }
519 }
520
521 for (curlba = Lba, cur_flag = g_sector_flag, j = 0; j < secNum; j++, curlba++, cur_flag++)
522 {
523 if (cur_flag->flag == 2)
524 {
525 if (lastlba == 0)
526 {
527 lastbuffer = (UINT8 *)Buffer + j * 2048;
528 lastlba = cur_flag->remap_lba;
529 lbacount = 1;
530 }
531 else if (lastlba + lbacount == cur_flag->remap_lba)
532 {
533 lbacount++;
534 }
535 else
536 {
537 ventoy_read_iso_sector(lastlba, lbacount, lastbuffer);
538 lastbuffer = (UINT8 *)Buffer + j * 2048;
539 lastlba = cur_flag->remap_lba;
540 lbacount = 1;
541 }
542 }
543 }
544
545 if (lbacount > 0)
546 {
547 ventoy_read_iso_sector(lastlba, lbacount, lastbuffer);
548 }
549
550 return EFI_SUCCESS;
551 }
552
553 EFI_STATUS EFIAPI ventoy_block_io_read
554 (
555 IN EFI_BLOCK_IO_PROTOCOL *This,
556 IN UINT32 MediaId,
557 IN EFI_LBA Lba,
558 IN UINTN BufferSize,
559 OUT VOID *Buffer
560 )
561 {
562 UINT32 IoAlign = 0;
563 VOID *NewBuf = NULL;
564 EFI_STATUS Status = EFI_OUT_OF_RESOURCES;
565
566 if (gBlockData.pRawBlockIo && gBlockData.pRawBlockIo->Media)
567 {
568 IoAlign = gBlockData.pRawBlockIo->Media->IoAlign;
569 }
570
571 if ((IoAlign == 0) || (((UINTN) Buffer & (IoAlign - 1)) == 0))
572 {
573 Status = ventoy_block_io_read_real(This, MediaId, Lba, BufferSize, Buffer);
574 }
575 else
576 {
577 NewBuf = AllocatePages(EFI_SIZE_TO_PAGES(BufferSize + IoAlign));
578 if (NewBuf)
579 {
580 Status = ventoy_block_io_read_real(This, MediaId, Lba, BufferSize, NewBuf);
581 CopyMem(Buffer, NewBuf, BufferSize);
582 FreePages(NewBuf, EFI_SIZE_TO_PAGES(BufferSize + IoAlign));
583 }
584 }
585
586 return Status;
587 }
588
589 EFI_STATUS EFIAPI ventoy_block_io_write
590 (
591 IN EFI_BLOCK_IO_PROTOCOL *This,
592 IN UINT32 MediaId,
593 IN EFI_LBA Lba,
594 IN UINTN BufferSize,
595 IN VOID *Buffer
596 )
597 {
598 UINT32 secNum = 0;
599 UINT64 offset = 0;
600
601 (VOID)This;
602 (VOID)MediaId;
603
604 if (!gSector512Mode)
605 {
606 return EFI_WRITE_PROTECTED;
607 }
608
609 secNum = BufferSize / 2048;
610 offset = Lba * 2048;
611
612 return ventoy_write_iso_sector(Lba, secNum, Buffer);
613 }
614
615 EFI_STATUS EFIAPI ventoy_block_io_flush(IN EFI_BLOCK_IO_PROTOCOL *This)
616 {
617 (VOID)This;
618 return EFI_SUCCESS;
619 }
620
621
622 EFI_STATUS EFIAPI ventoy_fill_device_path(VOID)
623 {
624 UINTN NameLen = 0;
625 UINT8 TmpBuf[128] = {0};
626 VENDOR_DEVICE_PATH *venPath = NULL;
627
628 venPath = (VENDOR_DEVICE_PATH *)TmpBuf;
629 NameLen = StrSize(VTOY_BLOCK_DEVICE_PATH_NAME);
630 venPath->Header.Type = HARDWARE_DEVICE_PATH;
631 venPath->Header.SubType = HW_VENDOR_DP;
632 venPath->Header.Length[0] = sizeof(VENDOR_DEVICE_PATH) + NameLen;
633 venPath->Header.Length[1] = 0;
634 CopyMem(&venPath->Guid, &gVtoyBlockDevicePathGuid, sizeof(EFI_GUID));
635 CopyMem(venPath + 1, VTOY_BLOCK_DEVICE_PATH_NAME, NameLen);
636
637 gBlockData.Path = AppendDevicePathNode(NULL, (EFI_DEVICE_PATH_PROTOCOL *)TmpBuf);
638 gBlockData.DevicePathCompareLen = sizeof(VENDOR_DEVICE_PATH) + NameLen;
639
640 debug("gBlockData.Path=<%s>\n", ConvertDevicePathToText(gBlockData.Path, FALSE, FALSE));
641
642 return EFI_SUCCESS;
643 }
644
645 EFI_STATUS EFIAPI ventoy_connect_driver(IN EFI_HANDLE ControllerHandle, IN CONST CHAR16 *DrvName)
646 {
647 UINTN i = 0;
648 UINTN Count = 0;
649 CHAR16 *DriverName = NULL;
650 EFI_HANDLE *Handles = NULL;
651 EFI_HANDLE DrvHandles[2] = { NULL };
652 EFI_STATUS Status = EFI_SUCCESS;
653 EFI_COMPONENT_NAME_PROTOCOL *NameProtocol = NULL;
654 EFI_COMPONENT_NAME2_PROTOCOL *Name2Protocol = NULL;
655
656 debug("ventoy_connect_driver <%s>...", DrvName);
657
658 Status = gBS->LocateHandleBuffer(ByProtocol, &gEfiComponentName2ProtocolGuid,
659 NULL, &Count, &Handles);
660 if (EFI_ERROR(Status))
661 {
662 return Status;
663 }
664
665 for (i = 0; i < Count; i++)
666 {
667 Status = gBS->HandleProtocol(Handles[i], &gEfiComponentName2ProtocolGuid, (VOID **)&Name2Protocol);
668 if (EFI_ERROR(Status))
669 {
670 continue;
671 }
672
673 Status = Name2Protocol->GetDriverName(Name2Protocol, "en", &DriverName);
674 if (EFI_ERROR(Status) || NULL == DriverName)
675 {
676 continue;
677 }
678
679 if (StrStr(DriverName, DrvName))
680 {
681 debug("Find driver name2:<%s>: <%s>", DriverName, DrvName);
682 DrvHandles[0] = Handles[i];
683 break;
684 }
685 }
686
687 if (i < Count)
688 {
689 Status = gBS->ConnectController(ControllerHandle, DrvHandles, NULL, TRUE);
690 debug("ventoy_connect_driver:<%s> <%r>", DrvName, Status);
691 goto end;
692 }
693
694 debug("%s NOT found, now try COMPONENT_NAME", DrvName);
695
696 Count = 0;
697 FreePool(Handles);
698 Handles = NULL;
699
700 Status = gBS->LocateHandleBuffer(ByProtocol, &gEfiComponentNameProtocolGuid,
701 NULL, &Count, &Handles);
702 if (EFI_ERROR(Status))
703 {
704 return Status;
705 }
706
707 for (i = 0; i < Count; i++)
708 {
709 Status = gBS->HandleProtocol(Handles[i], &gEfiComponentNameProtocolGuid, (VOID **)&NameProtocol);
710 if (EFI_ERROR(Status))
711 {
712 continue;
713 }
714
715 Status = NameProtocol->GetDriverName(NameProtocol, "en", &DriverName);
716 if (EFI_ERROR(Status))
717 {
718 continue;
719 }
720
721 if (StrStr(DriverName, DrvName))
722 {
723 debug("Find driver name:<%s>: <%s>", DriverName, DrvName);
724 DrvHandles[0] = Handles[i];
725 break;
726 }
727 }
728
729 if (i < Count)
730 {
731 Status = gBS->ConnectController(ControllerHandle, DrvHandles, NULL, TRUE);
732 debug("ventoy_connect_driver:<%s> <%r>", DrvName, Status);
733 goto end;
734 }
735
736 Status = EFI_NOT_FOUND;
737
738 end:
739 FreePool(Handles);
740
741 return Status;
742 }
743
744 EFI_STATUS EFIAPI ventoy_block_io_read_512
745 (
746 IN EFI_BLOCK_IO_PROTOCOL *This,
747 IN UINT32 MediaId,
748 IN EFI_LBA Lba,
749 IN UINTN BufferSize,
750 OUT VOID *Buffer
751 )
752 {
753 EFI_LBA Mod;
754 UINTN ReadSize;
755 UINT8 *CurBuf = NULL;
756 EFI_STATUS Status = EFI_SUCCESS;
757
758 debug("ventoy_block_io_read_512 %lu %lu Buffer:%p\n", Lba, BufferSize / 512, Buffer);
759
760 CurBuf = (UINT8 *)Buffer;
761
762 Mod = Lba % 4;
763 if (Mod > 0)
764 {
765 Status |= g_sector_2048_read(This, MediaId, Lba / 4, 2048, g_sector_buf);
766
767 if (BufferSize <= (4 - Mod) * 512)
768 {
769 CopyMem(CurBuf, g_sector_buf + Mod * 512, BufferSize);
770 return EFI_SUCCESS;
771 }
772 else
773 {
774 ReadSize = (4 - Mod) * 512;
775 CopyMem(CurBuf, g_sector_buf + Mod * 512, ReadSize);
776 CurBuf += ReadSize;
777 Lba += (4 - Mod);
778 BufferSize -= ReadSize;
779 }
780 }
781
782 if (BufferSize >= 2048)
783 {
784 ReadSize = BufferSize / 2048 * 2048;
785
786 Status |= g_sector_2048_read(This, MediaId, Lba / 4, ReadSize, CurBuf);
787 CurBuf += ReadSize;
788
789 Lba += ReadSize / 512;
790 BufferSize -= ReadSize;
791 }
792
793 if (BufferSize > 0)
794 {
795 Status |= g_sector_2048_read(This, MediaId, Lba / 4, 2048, g_sector_buf);
796 CopyMem(CurBuf, g_sector_buf, BufferSize);
797 }
798
799 return Status;
800 }
801
802 EFI_STATUS EFIAPI ventoy_block_io_write_512
803 (
804 IN EFI_BLOCK_IO_PROTOCOL *This,
805 IN UINT32 MediaId,
806 IN EFI_LBA Lba,
807 IN UINTN BufferSize,
808 IN VOID *Buffer
809 )
810 {
811 EFI_LBA Mod;
812 UINTN ReadSize;
813 UINT8 *CurBuf = NULL;
814 EFI_STATUS Status = EFI_SUCCESS;
815
816 debug("ventoy_block_io_write_512 %lu %lu\n", Lba, BufferSize / 512);
817
818 CurBuf = (UINT8 *)Buffer;
819
820 Mod = Lba % 4;
821 if (Mod > 0)
822 {
823 Status |= g_sector_2048_read(This, MediaId, Lba / 4, 2048, g_sector_buf);
824
825 if (BufferSize <= (4 - Mod) * 512)
826 {
827 CopyMem(g_sector_buf + Mod * 512, CurBuf, BufferSize);
828 return g_sector_2048_write(This, MediaId, Lba / 4, 2048, g_sector_buf);
829 }
830 else
831 {
832 ReadSize = (4 - Mod) * 512;
833 CopyMem(g_sector_buf + Mod * 512, CurBuf, ReadSize);
834 g_sector_2048_write(This, MediaId, Lba / 4, 2048, g_sector_buf);
835
836 CurBuf += ReadSize;
837 Lba += (4 - Mod);
838 BufferSize -= ReadSize;
839 }
840 }
841
842 if (BufferSize >= 2048)
843 {
844 ReadSize = BufferSize / 2048 * 2048;
845
846 Status |= g_sector_2048_write(This, MediaId, Lba / 4, ReadSize, CurBuf);
847 CurBuf += ReadSize;
848
849 Lba += ReadSize / 512;
850 BufferSize -= ReadSize;
851 }
852
853 if (BufferSize > 0)
854 {
855 Status |= g_sector_2048_read(This, MediaId, Lba / 4, 2048, g_sector_buf);
856
857 CopyMem(g_sector_buf, CurBuf, BufferSize);
858 g_sector_2048_write(This, MediaId, Lba / 4, 2048, g_sector_buf);
859 }
860
861 return Status;
862 }
863
864 EFI_STATUS EFIAPI ventoy_install_blockio(IN EFI_HANDLE ImageHandle, IN UINT64 ImgSize)
865 {
866 EFI_STATUS Status = EFI_SUCCESS;
867 EFI_BLOCK_IO_PROTOCOL *pBlockIo = &(gBlockData.BlockIo);
868
869 ventoy_fill_device_path();
870
871 debug("install block io protocol %p", ImageHandle);
872 ventoy_debug_pause();
873
874 if (gSector512Mode)
875 {
876 gBlockData.Media.BlockSize = 512;
877 gBlockData.Media.LastBlock = ImgSize / 512 - 1;
878 }
879 else
880 {
881 gBlockData.Media.BlockSize = 2048;
882 gBlockData.Media.LastBlock = ImgSize / 2048 - 1;
883 }
884
885 gBlockData.Media.ReadOnly = TRUE;
886 gBlockData.Media.MediaPresent = 1;
887 gBlockData.Media.LogicalBlocksPerPhysicalBlock = 1;
888
889 pBlockIo->Revision = EFI_BLOCK_IO_PROTOCOL_REVISION3;
890 pBlockIo->Media = &(gBlockData.Media);
891 pBlockIo->Reset = ventoy_block_io_reset;
892
893 if (gSector512Mode)
894 {
895 g_sector_2048_read = gMemdiskMode ? ventoy_block_io_ramdisk_read : ventoy_block_io_read;
896 g_sector_2048_write = gMemdiskMode ? ventoy_block_io_ramdisk_write : ventoy_block_io_write;
897 pBlockIo->ReadBlocks = ventoy_block_io_read_512;
898 pBlockIo->WriteBlocks = ventoy_block_io_write_512;
899 }
900 else
901 {
902 pBlockIo->ReadBlocks = gMemdiskMode ? ventoy_block_io_ramdisk_read : ventoy_block_io_read;
903 pBlockIo->WriteBlocks = ventoy_block_io_write;
904 }
905
906 pBlockIo->FlushBlocks = ventoy_block_io_flush;
907
908 Status = gBS->InstallMultipleProtocolInterfaces(&gBlockData.Handle,
909 &gEfiBlockIoProtocolGuid, &gBlockData.BlockIo,
910 &gEfiDevicePathProtocolGuid, gBlockData.Path,
911 NULL);
912 debug("Install protocol %r %p", Status, gBlockData.Handle);
913 if (EFI_ERROR(Status))
914 {
915 return Status;
916 }
917
918 Status = ventoy_connect_driver(gBlockData.Handle, L"Disk I/O Driver");
919 debug("Connect disk IO driver %r", Status);
920
921 Status = ventoy_connect_driver(gBlockData.Handle, L"Partition Driver");
922 debug("Connect partition driver %r", Status);
923 if (EFI_ERROR(Status))
924 {
925 Status = gBS->ConnectController(gBlockData.Handle, NULL, NULL, TRUE);
926 debug("Connect all controller %r", Status);
927 }
928
929 ventoy_debug_pause();
930
931 return EFI_SUCCESS;
932 }
933
934 #if 0
935 /* For file replace */
936 #endif
937
938 STATIC EFI_STATUS EFIAPI
939 ventoy_wrapper_fs_open(EFI_FILE_HANDLE This, EFI_FILE_HANDLE *New, CHAR16 *Name, UINT64 Mode, UINT64 Attributes)
940 {
941 (VOID)This;
942 (VOID)New;
943 (VOID)Name;
944 (VOID)Mode;
945 (VOID)Attributes;
946 return EFI_SUCCESS;
947 }
948
949 STATIC EFI_STATUS EFIAPI
950 ventoy_wrapper_file_open_ex(EFI_FILE_HANDLE This, EFI_FILE_HANDLE *New, CHAR16 *Name, UINT64 Mode, UINT64 Attributes, EFI_FILE_IO_TOKEN *Token)
951 {
952 return ventoy_wrapper_fs_open(This, New, Name, Mode, Attributes);
953 }
954
955 STATIC EFI_STATUS EFIAPI
956 ventoy_wrapper_file_delete(EFI_FILE_HANDLE This)
957 {
958 (VOID)This;
959 return EFI_SUCCESS;
960 }
961
962 STATIC EFI_STATUS EFIAPI
963 ventoy_wrapper_file_set_info(EFI_FILE_HANDLE This, EFI_GUID *Type, UINTN Len, VOID *Data)
964 {
965 return EFI_SUCCESS;
966 }
967
968 STATIC EFI_STATUS EFIAPI
969 ventoy_wrapper_file_flush(EFI_FILE_HANDLE This)
970 {
971 (VOID)This;
972 return EFI_SUCCESS;
973 }
974
975 /* Ex version */
976 STATIC EFI_STATUS EFIAPI
977 ventoy_wrapper_file_flush_ex(EFI_FILE_HANDLE This, EFI_FILE_IO_TOKEN *Token)
978 {
979 (VOID)This;
980 (VOID)Token;
981 return EFI_SUCCESS;
982 }
983
984
985 STATIC EFI_STATUS EFIAPI
986 ventoy_wrapper_file_write(EFI_FILE_HANDLE This, UINTN *Len, VOID *Data)
987 {
988 (VOID)This;
989 (VOID)Len;
990 (VOID)Data;
991
992 return EFI_WRITE_PROTECTED;
993 }
994
995 STATIC EFI_STATUS EFIAPI
996 ventoy_wrapper_file_write_ex(IN EFI_FILE_PROTOCOL *This, IN OUT EFI_FILE_IO_TOKEN *Token)
997 {
998 return ventoy_wrapper_file_write(This, &(Token->BufferSize), Token->Buffer);
999 }
1000
1001
1002 STATIC EFI_STATUS EFIAPI
1003 ventoy_wrapper_file_close(EFI_FILE_HANDLE This)
1004 {
1005 (VOID)This;
1006 return EFI_SUCCESS;
1007 }
1008
1009
1010 STATIC EFI_STATUS EFIAPI
1011 ventoy_wrapper_file_set_pos(EFI_FILE_HANDLE This, UINT64 Position)
1012 {
1013 (VOID)This;
1014
1015 if (Position <= g_efi_file_replace.FileSizeBytes)
1016 {
1017 g_efi_file_replace.CurPos = Position;
1018 }
1019 else
1020 {
1021 g_efi_file_replace.CurPos = g_efi_file_replace.FileSizeBytes;
1022 }
1023
1024 return EFI_SUCCESS;
1025 }
1026
1027 STATIC EFI_STATUS EFIAPI
1028 ventoy_wrapper_file_get_pos(EFI_FILE_HANDLE This, UINT64 *Position)
1029 {
1030 (VOID)This;
1031
1032 *Position = g_efi_file_replace.CurPos;
1033
1034 return EFI_SUCCESS;
1035 }
1036
1037
1038 STATIC EFI_STATUS EFIAPI
1039 ventoy_wrapper_file_get_info(EFI_FILE_HANDLE This, EFI_GUID *Type, UINTN *Len, VOID *Data)
1040 {
1041 EFI_FILE_INFO *Info = (EFI_FILE_INFO *) Data;
1042
1043 debug("ventoy_wrapper_file_get_info ... %u", *Len);
1044
1045 if (!CompareGuid(Type, &gEfiFileInfoGuid))
1046 {
1047 return EFI_INVALID_PARAMETER;
1048 }
1049
1050 if (*Len == 0)
1051 {
1052 *Len = 384;
1053 return EFI_BUFFER_TOO_SMALL;
1054 }
1055
1056 ZeroMem(Data, sizeof(EFI_FILE_INFO));
1057
1058 Info->Size = sizeof(EFI_FILE_INFO);
1059 Info->FileSize = g_efi_file_replace.FileSizeBytes;
1060 Info->PhysicalSize = g_efi_file_replace.FileSizeBytes;
1061 Info->Attribute = EFI_FILE_READ_ONLY;
1062 //Info->FileName = EFI_FILE_READ_ONLY;
1063
1064 *Len = Info->Size;
1065
1066 return EFI_SUCCESS;
1067 }
1068
1069 STATIC EFI_STATUS EFIAPI
1070 ventoy_wrapper_file_read(EFI_FILE_HANDLE This, UINTN *Len, VOID *Data)
1071 {
1072 EFI_LBA Lba;
1073 UINTN ReadLen = *Len;
1074
1075 (VOID)This;
1076
1077 debug("ventoy_wrapper_file_read ... %u", *Len);
1078
1079 if (g_efi_file_replace.CurPos + ReadLen > g_efi_file_replace.FileSizeBytes)
1080 {
1081 ReadLen = g_efi_file_replace.FileSizeBytes - g_efi_file_replace.CurPos;
1082 }
1083
1084 Lba = g_efi_file_replace.CurPos / 2048 + g_efi_file_replace.BlockIoSectorStart;
1085
1086 ventoy_block_io_read(NULL, 0, Lba, ReadLen, Data);
1087
1088 *Len = ReadLen;
1089
1090 g_efi_file_replace.CurPos += ReadLen;
1091
1092 return EFI_SUCCESS;
1093 }
1094
1095 STATIC EFI_STATUS EFIAPI
1096 ventoy_wrapper_file_read_ex(IN EFI_FILE_PROTOCOL *This, IN OUT EFI_FILE_IO_TOKEN *Token)
1097 {
1098 return ventoy_wrapper_file_read(This, &(Token->BufferSize), Token->Buffer);
1099 }
1100
1101 STATIC EFI_STATUS EFIAPI ventoy_wrapper_file_procotol(EFI_FILE_PROTOCOL *File)
1102 {
1103 File->Revision = EFI_FILE_PROTOCOL_REVISION2;
1104 File->Open = ventoy_wrapper_fs_open;
1105 File->Close = ventoy_wrapper_file_close;
1106 File->Delete = ventoy_wrapper_file_delete;
1107 File->Read = ventoy_wrapper_file_read;
1108 File->Write = ventoy_wrapper_file_write;
1109 File->GetPosition = ventoy_wrapper_file_get_pos;
1110 File->SetPosition = ventoy_wrapper_file_set_pos;
1111 File->GetInfo = ventoy_wrapper_file_get_info;
1112 File->SetInfo = ventoy_wrapper_file_set_info;
1113 File->Flush = ventoy_wrapper_file_flush;
1114 File->OpenEx = ventoy_wrapper_file_open_ex;
1115 File->ReadEx = ventoy_wrapper_file_read_ex;
1116 File->WriteEx = ventoy_wrapper_file_write_ex;
1117 File->FlushEx = ventoy_wrapper_file_flush_ex;
1118
1119 return EFI_SUCCESS;
1120 }
1121
1122 STATIC EFI_STATUS EFIAPI ventoy_wrapper_file_open
1123 (
1124 EFI_FILE_HANDLE This,
1125 EFI_FILE_HANDLE *New,
1126 CHAR16 *Name,
1127 UINT64 Mode,
1128 UINT64 Attributes
1129 )
1130 {
1131 UINT32 i = 0;
1132 UINT32 j = 0;
1133 UINT64 Sectors = 0;
1134 EFI_STATUS Status = EFI_SUCCESS;
1135 CHAR8 TmpName[256];
1136 ventoy_virt_chunk *virt = NULL;
1137
1138 debug("## ventoy_wrapper_file_open <%s> ", Name);
1139
1140 Status = g_original_fopen(This, New, Name, Mode, Attributes);
1141 if (EFI_ERROR(Status))
1142 {
1143 return Status;
1144 }
1145
1146 if (g_file_replace_list && g_file_replace_list->magic == GRUB_FILE_REPLACE_MAGIC &&
1147 g_file_replace_list->new_file_virtual_id < g_virt_chunk_num)
1148 {
1149 AsciiSPrint(TmpName, sizeof(TmpName), "%s", Name);
1150 for (j = 0; j < 4; j++)
1151 {
1152 if (0 == AsciiStrCmp(g_file_replace_list[i].old_file_name[j], TmpName))
1153 {
1154 g_original_fclose(*New);
1155 *New = &g_efi_file_replace.WrapperHandle;
1156 ventoy_wrapper_file_procotol(*New);
1157
1158 virt = g_virt_chunk + g_file_replace_list->new_file_virtual_id;
1159
1160 Sectors = (virt->mem_sector_end - virt->mem_sector_start) + (virt->remap_sector_end - virt->remap_sector_start);
1161
1162 g_efi_file_replace.BlockIoSectorStart = virt->mem_sector_start;
1163 g_efi_file_replace.FileSizeBytes = Sectors * 2048;
1164
1165 if (gDebugPrint)
1166 {
1167 debug("## ventoy_wrapper_file_open <%s> BlockStart:%lu Sectors:%lu Bytes:%lu", Name,
1168 g_efi_file_replace.BlockIoSectorStart, Sectors, Sectors * 2048);
1169 sleep(3);
1170 }
1171
1172 return Status;
1173 }
1174 }
1175
1176 if (StrCmp(Name, L"\\EFI\\BOOT") == 0)
1177 {
1178 (*New)->Open = ventoy_wrapper_file_open;
1179 }
1180 }
1181
1182 return Status;
1183 }
1184
1185 EFI_STATUS EFIAPI ventoy_wrapper_open_volume
1186 (
1187 IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
1188 OUT EFI_FILE_PROTOCOL **Root
1189 )
1190 {
1191 EFI_STATUS Status = EFI_SUCCESS;
1192
1193 Status = g_original_open_volume(This, Root);
1194 if (!EFI_ERROR(Status))
1195 {
1196 g_original_fopen = (*Root)->Open;
1197 g_original_fclose = (*Root)->Close;
1198 (*Root)->Open = ventoy_wrapper_file_open;
1199 }
1200
1201 return Status;
1202 }
1203
1204 EFI_STATUS EFIAPI ventoy_wrapper_push_openvolume(IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_OPEN_VOLUME OpenVolume)
1205 {
1206 g_original_open_volume = OpenVolume;
1207 return EFI_SUCCESS;
1208 }
1209
1210 #if 0
1211 /* For auto skip Windows 'Press any key to boot from CD or DVD ...' */
1212 #endif
1213
1214 STATIC EFI_STATUS EFIAPI ventoy_wrapper_read_key_ex
1215 (
1216 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,
1217 OUT EFI_KEY_DATA *KeyData
1218 )
1219 {
1220 /* only hook once before BCD file read */
1221 if (g_keyboard_hook_count == 0 && g_blockio_bcd_read_done == FALSE)
1222 {
1223 g_keyboard_hook_count++;
1224
1225 KeyData->Key.ScanCode = SCAN_DELETE;
1226 KeyData->Key.UnicodeChar = 0;
1227 KeyData->KeyState.KeyShiftState = 0;
1228 KeyData->KeyState.KeyToggleState = 0;
1229
1230 return EFI_SUCCESS;
1231 }
1232
1233 return g_org_read_key_ex(This, KeyData);
1234 }
1235
1236 EFI_STATUS EFIAPI ventoy_wrapper_read_key
1237 (
1238 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *This,
1239 OUT EFI_INPUT_KEY *Key
1240 )
1241 {
1242 /* only hook once before BCD file read */
1243 if (g_keyboard_hook_count == 0 && g_blockio_bcd_read_done == FALSE)
1244 {
1245 g_keyboard_hook_count++;
1246
1247 Key->ScanCode = SCAN_DELETE;
1248 Key->UnicodeChar = 0;
1249 return EFI_SUCCESS;
1250 }
1251
1252 return g_org_read_key(This, Key);
1253 }
1254
1255 EFI_STATUS ventoy_hook_keyboard_start(VOID)
1256 {
1257 g_blockio_start_record_bcd = TRUE;
1258 g_blockio_bcd_read_done = FALSE;
1259 g_keyboard_hook_count = 0;
1260
1261 if (g_con_simple_input_ex)
1262 {
1263 g_org_read_key_ex = g_con_simple_input_ex->ReadKeyStrokeEx;
1264 g_con_simple_input_ex->ReadKeyStrokeEx = ventoy_wrapper_read_key_ex;
1265 }
1266
1267 g_org_read_key = gST->ConIn->ReadKeyStroke;
1268 gST->ConIn->ReadKeyStroke = ventoy_wrapper_read_key;
1269
1270 return EFI_SUCCESS;
1271 }
1272
1273 EFI_STATUS ventoy_hook_keyboard_stop(VOID)
1274 {
1275 g_blockio_start_record_bcd = FALSE;
1276 g_blockio_bcd_read_done = FALSE;
1277 g_keyboard_hook_count = 0;
1278
1279 if (g_con_simple_input_ex)
1280 {
1281 g_con_simple_input_ex->ReadKeyStrokeEx = g_org_read_key_ex;
1282 }
1283
1284 gST->ConIn->ReadKeyStroke = g_org_read_key;
1285
1286 return EFI_SUCCESS;
1287 }
1288
1289 #if 0
1290 /* Fixup the 1st cdrom influnce for Windows boot */
1291 #endif
1292
1293 STATIC EFI_STATUS EFIAPI ventoy_wrapper_locate_handle
1294 (
1295 IN EFI_LOCATE_SEARCH_TYPE SearchType,
1296 IN EFI_GUID *Protocol, OPTIONAL
1297 IN VOID *SearchKey, OPTIONAL
1298 IN OUT UINTN *BufferSize,
1299 OUT EFI_HANDLE *Buffer
1300 )
1301 {
1302 UINTN i;
1303 EFI_HANDLE Handle = NULL;
1304 EFI_STATUS Status = EFI_SUCCESS;
1305
1306 Status = g_org_locate_handle(SearchType, Protocol, SearchKey, BufferSize, Buffer);
1307
1308 if (EFI_SUCCESS == Status && Protocol && CompareGuid(&gEfiBlockIoProtocolGuid, Protocol))
1309 {
1310 for (i = 0; i < (*BufferSize) / sizeof(EFI_HANDLE); i++)
1311 {
1312 if (Buffer[i] == gBlockData.Handle)
1313 {
1314 Handle = Buffer[0];
1315 Buffer[0] = Buffer[i];
1316 Buffer[i] = Handle;
1317 break;
1318 }
1319 }
1320 }
1321
1322 return Status;
1323 }
1324
1325 EFI_STATUS ventoy_hook_1st_cdrom_start(VOID)
1326 {
1327 g_org_locate_handle = gBS->LocateHandle;
1328 gBS->LocateHandle = ventoy_wrapper_locate_handle;
1329
1330 return EFI_SUCCESS;
1331 }
1332
1333 EFI_STATUS ventoy_hook_1st_cdrom_stop(VOID)
1334 {
1335 gBS->LocateHandle = g_org_locate_handle;
1336 g_org_locate_handle = NULL;
1337
1338 return EFI_SUCCESS;
1339 }
1340
https://github.com/ventoy/Ventoy