]> glassweightruler.freedombox.rocks Git - Ventoy.git/blob - EDK2/edk2_mod/edk2-edk2-stable201911/MdeModulePkg/Application/Ventoy/VentoyProtocol.c
projects / Ventoy.git / blob
? search:


2ba882b3e33bcd46bf0b89971064ee981b470643
[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 debug("XXX block_io_read_real sector:%u count:%u Buffer:%p", (UINT32)Lba, (UINT32)BufferSize / 2048, Buffer);
487
488 if (secNum > g_sector_flag_num)
489 {
490 cur_flag = AllocatePool(secNum * sizeof(ventoy_sector_flag));
491 if (NULL == cur_flag)
492 {
493 return EFI_OUT_OF_RESOURCES;
494 }
495
496 FreePool(g_sector_flag);
497 g_sector_flag = cur_flag;
498 g_sector_flag_num = secNum;
499 }
500
501 for (curlba = Lba, cur_flag = g_sector_flag, j = 0; j < secNum; j++, curlba++, cur_flag++)
502 {
503 cur_flag->flag = 0;
504 for (node = g_virt_chunk, i = 0; i < g_virt_chunk_num; i++, node++)
505 {
506 if (curlba >= node->mem_sector_start && curlba < node->mem_sector_end)
507 {
508 CopyMem((UINT8 *)Buffer + j * 2048,
509 (char *)g_virt_chunk + node->mem_sector_offset + (curlba - node->mem_sector_start) * 2048,
510 2048);
511 cur_flag->flag = 1;
512 break;
513 }
514 else if (curlba >= node->remap_sector_start && curlba < node->remap_sector_end)
515 {
516 cur_flag->remap_lba = node->org_sector_start + curlba - node->remap_sector_start;
517 cur_flag->flag = 2;
518 break;
519 }
520 }
521 }
522
523 for (curlba = Lba, cur_flag = g_sector_flag, j = 0; j < secNum; j++, curlba++, cur_flag++)
524 {
525 if (cur_flag->flag == 2)
526 {
527 if (lastlba == 0)
528 {
529 lastbuffer = (UINT8 *)Buffer + j * 2048;
530 lastlba = cur_flag->remap_lba;
531 lbacount = 1;
532 }
533 else if (lastlba + lbacount == cur_flag->remap_lba)
534 {
535 lbacount++;
536 }
537 else
538 {
539 ventoy_read_iso_sector(lastlba, lbacount, lastbuffer);
540 lastbuffer = (UINT8 *)Buffer + j * 2048;
541 lastlba = cur_flag->remap_lba;
542 lbacount = 1;
543 }
544 }
545 }
546
547 if (lbacount > 0)
548 {
549 ventoy_read_iso_sector(lastlba, lbacount, lastbuffer);
550 }
551
552 return EFI_SUCCESS;
553 }
554
555 EFI_STATUS EFIAPI ventoy_block_io_read
556 (
557 IN EFI_BLOCK_IO_PROTOCOL *This,
558 IN UINT32 MediaId,
559 IN EFI_LBA Lba,
560 IN UINTN BufferSize,
561 OUT VOID *Buffer
562 )
563 {
564 UINT32 IoAlign = 0;
565 VOID *NewBuf = NULL;
566 EFI_STATUS Status = EFI_OUT_OF_RESOURCES;
567
568 if (gBlockData.pRawBlockIo && gBlockData.pRawBlockIo->Media)
569 {
570 IoAlign = gBlockData.pRawBlockIo->Media->IoAlign;
571 }
572
573 if ((IoAlign == 0) || (((UINTN) Buffer & (IoAlign - 1)) == 0))
574 {
575 Status = ventoy_block_io_read_real(This, MediaId, Lba, BufferSize, Buffer);
576 }
577 else
578 {
579 NewBuf = AllocatePages(EFI_SIZE_TO_PAGES(BufferSize + IoAlign));
580 if (NewBuf)
581 {
582 Status = ventoy_block_io_read_real(This, MediaId, Lba, BufferSize, NewBuf);
583 CopyMem(Buffer, NewBuf, BufferSize);
584 FreePages(NewBuf, EFI_SIZE_TO_PAGES(BufferSize + IoAlign));
585 }
586 }
587
588 return Status;
589 }
590
591 EFI_STATUS EFIAPI ventoy_block_io_write
592 (
593 IN EFI_BLOCK_IO_PROTOCOL *This,
594 IN UINT32 MediaId,
595 IN EFI_LBA Lba,
596 IN UINTN BufferSize,
597 IN VOID *Buffer
598 )
599 {
600 UINT32 secNum = 0;
601 UINT64 offset = 0;
602
603 (VOID)This;
604 (VOID)MediaId;
605
606 if (!gSector512Mode)
607 {
608 return EFI_WRITE_PROTECTED;
609 }
610
611 secNum = BufferSize / 2048;
612 offset = Lba * 2048;
613
614 return ventoy_write_iso_sector(Lba, secNum, Buffer);
615 }
616
617 EFI_STATUS EFIAPI ventoy_block_io_flush(IN EFI_BLOCK_IO_PROTOCOL *This)
618 {
619 (VOID)This;
620 return EFI_SUCCESS;
621 }
622
623
624 EFI_STATUS EFIAPI ventoy_fill_device_path(VOID)
625 {
626 UINTN NameLen = 0;
627 UINT8 TmpBuf[128] = {0};
628 VENDOR_DEVICE_PATH *venPath = NULL;
629
630 venPath = (VENDOR_DEVICE_PATH *)TmpBuf;
631 NameLen = StrSize(VTOY_BLOCK_DEVICE_PATH_NAME);
632 venPath->Header.Type = HARDWARE_DEVICE_PATH;
633 venPath->Header.SubType = HW_VENDOR_DP;
634 venPath->Header.Length[0] = sizeof(VENDOR_DEVICE_PATH) + NameLen;
635 venPath->Header.Length[1] = 0;
636 CopyMem(&venPath->Guid, &gVtoyBlockDevicePathGuid, sizeof(EFI_GUID));
637 CopyMem(venPath + 1, VTOY_BLOCK_DEVICE_PATH_NAME, NameLen);
638
639 gBlockData.Path = AppendDevicePathNode(NULL, (EFI_DEVICE_PATH_PROTOCOL *)TmpBuf);
640 gBlockData.DevicePathCompareLen = sizeof(VENDOR_DEVICE_PATH) + NameLen;
641
642 debug("gBlockData.Path=<%s>\n", ConvertDevicePathToText(gBlockData.Path, FALSE, FALSE));
643
644 return EFI_SUCCESS;
645 }
646
647 EFI_STATUS EFIAPI ventoy_connect_driver(IN EFI_HANDLE ControllerHandle, IN CONST CHAR16 *DrvName)
648 {
649 UINTN i = 0;
650 UINTN Count = 0;
651 CHAR16 *DriverName = NULL;
652 EFI_HANDLE *Handles = NULL;
653 EFI_HANDLE DrvHandles[2] = { NULL };
654 EFI_STATUS Status = EFI_SUCCESS;
655 EFI_COMPONENT_NAME_PROTOCOL *NameProtocol = NULL;
656 EFI_COMPONENT_NAME2_PROTOCOL *Name2Protocol = NULL;
657
658 debug("ventoy_connect_driver <%s>...", DrvName);
659
660 Status = gBS->LocateHandleBuffer(ByProtocol, &gEfiComponentName2ProtocolGuid,
661 NULL, &Count, &Handles);
662 if (EFI_ERROR(Status))
663 {
664 return Status;
665 }
666
667 for (i = 0; i < Count; i++)
668 {
669 Status = gBS->HandleProtocol(Handles[i], &gEfiComponentName2ProtocolGuid, (VOID **)&Name2Protocol);
670 if (EFI_ERROR(Status))
671 {
672 continue;
673 }
674
675 Status = Name2Protocol->GetDriverName(Name2Protocol, "en", &DriverName);
676 if (EFI_ERROR(Status) || NULL == DriverName)
677 {
678 continue;
679 }
680
681 if (StrStr(DriverName, DrvName))
682 {
683 debug("Find driver name2:<%s>: <%s>", DriverName, DrvName);
684 DrvHandles[0] = Handles[i];
685 break;
686 }
687 }
688
689 if (i < Count)
690 {
691 Status = gBS->ConnectController(ControllerHandle, DrvHandles, NULL, TRUE);
692 debug("ventoy_connect_driver:<%s> <%r>", DrvName, Status);
693 goto end;
694 }
695
696 debug("%s NOT found, now try COMPONENT_NAME", DrvName);
697
698 Count = 0;
699 FreePool(Handles);
700 Handles = NULL;
701
702 Status = gBS->LocateHandleBuffer(ByProtocol, &gEfiComponentNameProtocolGuid,
703 NULL, &Count, &Handles);
704 if (EFI_ERROR(Status))
705 {
706 return Status;
707 }
708
709 for (i = 0; i < Count; i++)
710 {
711 Status = gBS->HandleProtocol(Handles[i], &gEfiComponentNameProtocolGuid, (VOID **)&NameProtocol);
712 if (EFI_ERROR(Status))
713 {
714 continue;
715 }
716
717 Status = NameProtocol->GetDriverName(NameProtocol, "en", &DriverName);
718 if (EFI_ERROR(Status))
719 {
720 continue;
721 }
722
723 if (StrStr(DriverName, DrvName))
724 {
725 debug("Find driver name:<%s>: <%s>", DriverName, DrvName);
726 DrvHandles[0] = Handles[i];
727 break;
728 }
729 }
730
731 if (i < Count)
732 {
733 Status = gBS->ConnectController(ControllerHandle, DrvHandles, NULL, TRUE);
734 debug("ventoy_connect_driver:<%s> <%r>", DrvName, Status);
735 goto end;
736 }
737
738 Status = EFI_NOT_FOUND;
739
740 end:
741 FreePool(Handles);
742
743 return Status;
744 }
745
746 EFI_STATUS EFIAPI ventoy_block_io_read_512
747 (
748 IN EFI_BLOCK_IO_PROTOCOL *This,
749 IN UINT32 MediaId,
750 IN EFI_LBA Lba,
751 IN UINTN BufferSize,
752 OUT VOID *Buffer
753 )
754 {
755 EFI_LBA Mod;
756 UINTN ReadSize;
757 UINT8 *CurBuf = NULL;
758 EFI_STATUS Status = EFI_SUCCESS;
759
760 debug("ventoy_block_io_read_512 %lu %lu Buffer:%p\n", Lba, BufferSize / 512, Buffer);
761
762 CurBuf = (UINT8 *)Buffer;
763
764 Mod = Lba % 4;
765 if (Mod > 0)
766 {
767 Status |= g_sector_2048_read(This, MediaId, Lba / 4, 2048, g_sector_buf);
768
769 if (BufferSize <= (4 - Mod) * 512)
770 {
771 CopyMem(CurBuf, g_sector_buf + Mod * 512, BufferSize);
772 return EFI_SUCCESS;
773 }
774 else
775 {
776 ReadSize = (4 - Mod) * 512;
777 CopyMem(CurBuf, g_sector_buf + Mod * 512, ReadSize);
778 CurBuf += ReadSize;
779 Lba += (4 - Mod);
780 BufferSize -= ReadSize;
781 }
782 }
783
784 if (BufferSize >= 2048)
785 {
786 ReadSize = BufferSize / 2048 * 2048;
787
788 Status |= g_sector_2048_read(This, MediaId, Lba / 4, ReadSize, CurBuf);
789 CurBuf += ReadSize;
790
791 Lba += ReadSize / 512;
792 BufferSize -= ReadSize;
793 }
794
795 if (BufferSize > 0)
796 {
797 Status |= g_sector_2048_read(This, MediaId, Lba / 4, 2048, g_sector_buf);
798 CopyMem(CurBuf, g_sector_buf, BufferSize);
799 }
800
801 return Status;
802 }
803
804 EFI_STATUS EFIAPI ventoy_block_io_write_512
805 (
806 IN EFI_BLOCK_IO_PROTOCOL *This,
807 IN UINT32 MediaId,
808 IN EFI_LBA Lba,
809 IN UINTN BufferSize,
810 IN VOID *Buffer
811 )
812 {
813 EFI_LBA Mod;
814 UINTN ReadSize;
815 UINT8 *CurBuf = NULL;
816 EFI_STATUS Status = EFI_SUCCESS;
817
818 debug("ventoy_block_io_write_512 %lu %lu\n", Lba, BufferSize / 512);
819
820 CurBuf = (UINT8 *)Buffer;
821
822 Mod = Lba % 4;
823 if (Mod > 0)
824 {
825 Status |= g_sector_2048_read(This, MediaId, Lba / 4, 2048, g_sector_buf);
826
827 if (BufferSize <= (4 - Mod) * 512)
828 {
829 CopyMem(g_sector_buf + Mod * 512, CurBuf, BufferSize);
830 return g_sector_2048_write(This, MediaId, Lba / 4, 2048, g_sector_buf);
831 }
832 else
833 {
834 ReadSize = (4 - Mod) * 512;
835 CopyMem(g_sector_buf + Mod * 512, CurBuf, ReadSize);
836 g_sector_2048_write(This, MediaId, Lba / 4, 2048, g_sector_buf);
837
838 CurBuf += ReadSize;
839 Lba += (4 - Mod);
840 BufferSize -= ReadSize;
841 }
842 }
843
844 if (BufferSize >= 2048)
845 {
846 ReadSize = BufferSize / 2048 * 2048;
847
848 Status |= g_sector_2048_write(This, MediaId, Lba / 4, ReadSize, CurBuf);
849 CurBuf += ReadSize;
850
851 Lba += ReadSize / 512;
852 BufferSize -= ReadSize;
853 }
854
855 if (BufferSize > 0)
856 {
857 Status |= g_sector_2048_read(This, MediaId, Lba / 4, 2048, g_sector_buf);
858
859 CopyMem(g_sector_buf, CurBuf, BufferSize);
860 g_sector_2048_write(This, MediaId, Lba / 4, 2048, g_sector_buf);
861 }
862
863 return Status;
864 }
865
866 EFI_STATUS EFIAPI ventoy_install_blockio(IN EFI_HANDLE ImageHandle, IN UINT64 ImgSize)
867 {
868 EFI_STATUS Status = EFI_SUCCESS;
869 EFI_BLOCK_IO_PROTOCOL *pBlockIo = &(gBlockData.BlockIo);
870
871 ventoy_fill_device_path();
872
873 debug("install block io protocol %p", ImageHandle);
874 ventoy_debug_pause();
875
876 if (gSector512Mode)
877 {
878 gBlockData.Media.BlockSize = 512;
879 gBlockData.Media.LastBlock = ImgSize / 512 - 1;
880 }
881 else
882 {
883 gBlockData.Media.BlockSize = 2048;
884 gBlockData.Media.LastBlock = ImgSize / 2048 - 1;
885 }
886
887 gBlockData.Media.ReadOnly = TRUE;
888 gBlockData.Media.MediaPresent = 1;
889 gBlockData.Media.LogicalBlocksPerPhysicalBlock = 1;
890
891 pBlockIo->Revision = EFI_BLOCK_IO_PROTOCOL_REVISION3;
892 pBlockIo->Media = &(gBlockData.Media);
893 pBlockIo->Reset = ventoy_block_io_reset;
894
895 if (gSector512Mode)
896 {
897 g_sector_2048_read = gMemdiskMode ? ventoy_block_io_ramdisk_read : ventoy_block_io_read;
898 g_sector_2048_write = gMemdiskMode ? ventoy_block_io_ramdisk_write : ventoy_block_io_write;
899 pBlockIo->ReadBlocks = ventoy_block_io_read_512;
900 pBlockIo->WriteBlocks = ventoy_block_io_write_512;
901 }
902 else
903 {
904 pBlockIo->ReadBlocks = gMemdiskMode ? ventoy_block_io_ramdisk_read : ventoy_block_io_read;
905 pBlockIo->WriteBlocks = ventoy_block_io_write;
906 }
907
908 pBlockIo->FlushBlocks = ventoy_block_io_flush;
909
910 Status = gBS->InstallMultipleProtocolInterfaces(&gBlockData.Handle,
911 &gEfiBlockIoProtocolGuid, &gBlockData.BlockIo,
912 &gEfiDevicePathProtocolGuid, gBlockData.Path,
913 NULL);
914 debug("Install protocol %r %p", Status, gBlockData.Handle);
915 if (EFI_ERROR(Status))
916 {
917 return Status;
918 }
919
920 Status = ventoy_connect_driver(gBlockData.Handle, L"Disk I/O Driver");
921 debug("Connect disk IO driver %r", Status);
922
923 Status = ventoy_connect_driver(gBlockData.Handle, L"Partition Driver");
924 debug("Connect partition driver %r", Status);
925 if (EFI_ERROR(Status))
926 {
927 Status = gBS->ConnectController(gBlockData.Handle, NULL, NULL, TRUE);
928 debug("Connect all controller %r", Status);
929 }
930
931 ventoy_debug_pause();
932
933 return EFI_SUCCESS;
934 }
935
936 #if 0
937 /* For file replace */
938 #endif
939
940 STATIC EFI_STATUS EFIAPI
941 ventoy_wrapper_fs_open(EFI_FILE_HANDLE This, EFI_FILE_HANDLE *New, CHAR16 *Name, UINT64 Mode, UINT64 Attributes)
942 {
943 (VOID)This;
944 (VOID)New;
945 (VOID)Name;
946 (VOID)Mode;
947 (VOID)Attributes;
948 return EFI_SUCCESS;
949 }
950
951 STATIC EFI_STATUS EFIAPI
952 ventoy_wrapper_file_open_ex(EFI_FILE_HANDLE This, EFI_FILE_HANDLE *New, CHAR16 *Name, UINT64 Mode, UINT64 Attributes, EFI_FILE_IO_TOKEN *Token)
953 {
954 return ventoy_wrapper_fs_open(This, New, Name, Mode, Attributes);
955 }
956
957 STATIC EFI_STATUS EFIAPI
958 ventoy_wrapper_file_delete(EFI_FILE_HANDLE This)
959 {
960 (VOID)This;
961 return EFI_SUCCESS;
962 }
963
964 STATIC EFI_STATUS EFIAPI
965 ventoy_wrapper_file_set_info(EFI_FILE_HANDLE This, EFI_GUID *Type, UINTN Len, VOID *Data)
966 {
967 return EFI_SUCCESS;
968 }
969
970 STATIC EFI_STATUS EFIAPI
971 ventoy_wrapper_file_flush(EFI_FILE_HANDLE This)
972 {
973 (VOID)This;
974 return EFI_SUCCESS;
975 }
976
977 /* Ex version */
978 STATIC EFI_STATUS EFIAPI
979 ventoy_wrapper_file_flush_ex(EFI_FILE_HANDLE This, EFI_FILE_IO_TOKEN *Token)
980 {
981 (VOID)This;
982 (VOID)Token;
983 return EFI_SUCCESS;
984 }
985
986
987 STATIC EFI_STATUS EFIAPI
988 ventoy_wrapper_file_write(EFI_FILE_HANDLE This, UINTN *Len, VOID *Data)
989 {
990 (VOID)This;
991 (VOID)Len;
992 (VOID)Data;
993
994 return EFI_WRITE_PROTECTED;
995 }
996
997 STATIC EFI_STATUS EFIAPI
998 ventoy_wrapper_file_write_ex(IN EFI_FILE_PROTOCOL *This, IN OUT EFI_FILE_IO_TOKEN *Token)
999 {
1000 return ventoy_wrapper_file_write(This, &(Token->BufferSize), Token->Buffer);
1001 }
1002
1003
1004 STATIC EFI_STATUS EFIAPI
1005 ventoy_wrapper_file_close(EFI_FILE_HANDLE This)
1006 {
1007 (VOID)This;
1008 return EFI_SUCCESS;
1009 }
1010
1011
1012 STATIC EFI_STATUS EFIAPI
1013 ventoy_wrapper_file_set_pos(EFI_FILE_HANDLE This, UINT64 Position)
1014 {
1015 (VOID)This;
1016
1017 if (Position <= g_efi_file_replace.FileSizeBytes)
1018 {
1019 g_efi_file_replace.CurPos = Position;
1020 }
1021 else
1022 {
1023 g_efi_file_replace.CurPos = g_efi_file_replace.FileSizeBytes;
1024 }
1025
1026 return EFI_SUCCESS;
1027 }
1028
1029 STATIC EFI_STATUS EFIAPI
1030 ventoy_wrapper_file_get_pos(EFI_FILE_HANDLE This, UINT64 *Position)
1031 {
1032 (VOID)This;
1033
1034 *Position = g_efi_file_replace.CurPos;
1035
1036 return EFI_SUCCESS;
1037 }
1038
1039
1040 STATIC EFI_STATUS EFIAPI
1041 ventoy_wrapper_file_get_info(EFI_FILE_HANDLE This, EFI_GUID *Type, UINTN *Len, VOID *Data)
1042 {
1043 EFI_FILE_INFO *Info = (EFI_FILE_INFO *) Data;
1044
1045 debug("ventoy_wrapper_file_get_info ... %u", *Len);
1046
1047 if (!CompareGuid(Type, &gEfiFileInfoGuid))
1048 {
1049 return EFI_INVALID_PARAMETER;
1050 }
1051
1052 if (*Len == 0)
1053 {
1054 *Len = 384;
1055 return EFI_BUFFER_TOO_SMALL;
1056 }
1057
1058 ZeroMem(Data, sizeof(EFI_FILE_INFO));
1059
1060 Info->Size = sizeof(EFI_FILE_INFO);
1061 Info->FileSize = g_efi_file_replace.FileSizeBytes;
1062 Info->PhysicalSize = g_efi_file_replace.FileSizeBytes;
1063 Info->Attribute = EFI_FILE_READ_ONLY;
1064 //Info->FileName = EFI_FILE_READ_ONLY;
1065
1066 *Len = Info->Size;
1067
1068 return EFI_SUCCESS;
1069 }
1070
1071 STATIC EFI_STATUS EFIAPI
1072 ventoy_wrapper_file_read(EFI_FILE_HANDLE This, UINTN *Len, VOID *Data)
1073 {
1074 EFI_LBA Lba;
1075 UINTN ReadLen = *Len;
1076
1077 (VOID)This;
1078
1079 debug("ventoy_wrapper_file_read ... %u", *Len);
1080
1081 if (g_efi_file_replace.CurPos + ReadLen > g_efi_file_replace.FileSizeBytes)
1082 {
1083 ReadLen = g_efi_file_replace.FileSizeBytes - g_efi_file_replace.CurPos;
1084 }
1085
1086 Lba = g_efi_file_replace.CurPos / 2048 + g_efi_file_replace.BlockIoSectorStart;
1087
1088 ventoy_block_io_read(NULL, 0, Lba, ReadLen, Data);
1089
1090 *Len = ReadLen;
1091
1092 g_efi_file_replace.CurPos += ReadLen;
1093
1094 return EFI_SUCCESS;
1095 }
1096
1097 STATIC EFI_STATUS EFIAPI
1098 ventoy_wrapper_file_read_ex(IN EFI_FILE_PROTOCOL *This, IN OUT EFI_FILE_IO_TOKEN *Token)
1099 {
1100 return ventoy_wrapper_file_read(This, &(Token->BufferSize), Token->Buffer);
1101 }
1102
1103 STATIC EFI_STATUS EFIAPI ventoy_wrapper_file_procotol(EFI_FILE_PROTOCOL *File)
1104 {
1105 File->Revision = EFI_FILE_PROTOCOL_REVISION2;
1106 File->Open = ventoy_wrapper_fs_open;
1107 File->Close = ventoy_wrapper_file_close;
1108 File->Delete = ventoy_wrapper_file_delete;
1109 File->Read = ventoy_wrapper_file_read;
1110 File->Write = ventoy_wrapper_file_write;
1111 File->GetPosition = ventoy_wrapper_file_get_pos;
1112 File->SetPosition = ventoy_wrapper_file_set_pos;
1113 File->GetInfo = ventoy_wrapper_file_get_info;
1114 File->SetInfo = ventoy_wrapper_file_set_info;
1115 File->Flush = ventoy_wrapper_file_flush;
1116 File->OpenEx = ventoy_wrapper_file_open_ex;
1117 File->ReadEx = ventoy_wrapper_file_read_ex;
1118 File->WriteEx = ventoy_wrapper_file_write_ex;
1119 File->FlushEx = ventoy_wrapper_file_flush_ex;
1120
1121 return EFI_SUCCESS;
1122 }
1123
1124 STATIC EFI_STATUS EFIAPI ventoy_wrapper_file_open
1125 (
1126 EFI_FILE_HANDLE This,
1127 EFI_FILE_HANDLE *New,
1128 CHAR16 *Name,
1129 UINT64 Mode,
1130 UINT64 Attributes
1131 )
1132 {
1133 UINT32 i = 0;
1134 UINT32 j = 0;
1135 UINT64 Sectors = 0;
1136 EFI_STATUS Status = EFI_SUCCESS;
1137 CHAR8 TmpName[256];
1138 ventoy_virt_chunk *virt = NULL;
1139
1140 debug("## ventoy_wrapper_file_open <%s> ", Name);
1141
1142 Status = g_original_fopen(This, New, Name, Mode, Attributes);
1143 if (EFI_ERROR(Status))
1144 {
1145 return Status;
1146 }
1147
1148 if (g_file_replace_list && g_file_replace_list->magic == GRUB_FILE_REPLACE_MAGIC &&
1149 g_file_replace_list->new_file_virtual_id < g_virt_chunk_num)
1150 {
1151 AsciiSPrint(TmpName, sizeof(TmpName), "%s", Name);
1152 for (j = 0; j < 4; j++)
1153 {
1154 if (0 == AsciiStrCmp(g_file_replace_list[i].old_file_name[j], TmpName))
1155 {
1156 g_original_fclose(*New);
1157 *New = &g_efi_file_replace.WrapperHandle;
1158 ventoy_wrapper_file_procotol(*New);
1159
1160 virt = g_virt_chunk + g_file_replace_list->new_file_virtual_id;
1161
1162 Sectors = (virt->mem_sector_end - virt->mem_sector_start) + (virt->remap_sector_end - virt->remap_sector_start);
1163
1164 g_efi_file_replace.BlockIoSectorStart = virt->mem_sector_start;
1165 g_efi_file_replace.FileSizeBytes = Sectors * 2048;
1166
1167 if (gDebugPrint)
1168 {
1169 debug("## ventoy_wrapper_file_open <%s> BlockStart:%lu Sectors:%lu Bytes:%lu", Name,
1170 g_efi_file_replace.BlockIoSectorStart, Sectors, Sectors * 2048);
1171 sleep(3);
1172 }
1173
1174 return Status;
1175 }
1176 }
1177
1178 if (StrCmp(Name, L"\\EFI\\BOOT") == 0)
1179 {
1180 (*New)->Open = ventoy_wrapper_file_open;
1181 }
1182 }
1183
1184 return Status;
1185 }
1186
1187 EFI_STATUS EFIAPI ventoy_wrapper_open_volume
1188 (
1189 IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
1190 OUT EFI_FILE_PROTOCOL **Root
1191 )
1192 {
1193 EFI_STATUS Status = EFI_SUCCESS;
1194
1195 Status = g_original_open_volume(This, Root);
1196 if (!EFI_ERROR(Status))
1197 {
1198 g_original_fopen = (*Root)->Open;
1199 g_original_fclose = (*Root)->Close;
1200 (*Root)->Open = ventoy_wrapper_file_open;
1201 }
1202
1203 return Status;
1204 }
1205
1206 EFI_STATUS EFIAPI ventoy_wrapper_push_openvolume(IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_OPEN_VOLUME OpenVolume)
1207 {
1208 g_original_open_volume = OpenVolume;
1209 return EFI_SUCCESS;
1210 }
1211
1212 #if 0
1213 /* For auto skip Windows 'Press any key to boot from CD or DVD ...' */
1214 #endif
1215
1216 STATIC EFI_STATUS EFIAPI ventoy_wrapper_read_key_ex
1217 (
1218 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,
1219 OUT EFI_KEY_DATA *KeyData
1220 )
1221 {
1222 /* only hook once before BCD file read */
1223 if (g_keyboard_hook_count == 0 && g_blockio_bcd_read_done == FALSE)
1224 {
1225 g_keyboard_hook_count++;
1226
1227 KeyData->Key.ScanCode = SCAN_DELETE;
1228 KeyData->Key.UnicodeChar = 0;
1229 KeyData->KeyState.KeyShiftState = 0;
1230 KeyData->KeyState.KeyToggleState = 0;
1231
1232 return EFI_SUCCESS;
1233 }
1234
1235 return g_org_read_key_ex(This, KeyData);
1236 }
1237
1238 EFI_STATUS EFIAPI ventoy_wrapper_read_key
1239 (
1240 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *This,
1241 OUT EFI_INPUT_KEY *Key
1242 )
1243 {
1244 /* only hook once before BCD file read */
1245 if (g_keyboard_hook_count == 0 && g_blockio_bcd_read_done == FALSE)
1246 {
1247 g_keyboard_hook_count++;
1248
1249 Key->ScanCode = SCAN_DELETE;
1250 Key->UnicodeChar = 0;
1251 return EFI_SUCCESS;
1252 }
1253
1254 return g_org_read_key(This, Key);
1255 }
1256
1257 EFI_STATUS ventoy_hook_keyboard_start(VOID)
1258 {
1259 g_blockio_start_record_bcd = TRUE;
1260 g_blockio_bcd_read_done = FALSE;
1261 g_keyboard_hook_count = 0;
1262
1263 if (g_con_simple_input_ex)
1264 {
1265 g_org_read_key_ex = g_con_simple_input_ex->ReadKeyStrokeEx;
1266 g_con_simple_input_ex->ReadKeyStrokeEx = ventoy_wrapper_read_key_ex;
1267 }
1268
1269 g_org_read_key = gST->ConIn->ReadKeyStroke;
1270 gST->ConIn->ReadKeyStroke = ventoy_wrapper_read_key;
1271
1272 return EFI_SUCCESS;
1273 }
1274
1275 EFI_STATUS ventoy_hook_keyboard_stop(VOID)
1276 {
1277 g_blockio_start_record_bcd = FALSE;
1278 g_blockio_bcd_read_done = FALSE;
1279 g_keyboard_hook_count = 0;
1280
1281 if (g_con_simple_input_ex)
1282 {
1283 g_con_simple_input_ex->ReadKeyStrokeEx = g_org_read_key_ex;
1284 }
1285
1286 gST->ConIn->ReadKeyStroke = g_org_read_key;
1287
1288 return EFI_SUCCESS;
1289 }
1290
1291 #if 0
1292 /* Fixup the 1st cdrom influnce for Windows boot */
1293 #endif
1294
1295 STATIC EFI_STATUS EFIAPI ventoy_wrapper_locate_handle
1296 (
1297 IN EFI_LOCATE_SEARCH_TYPE SearchType,
1298 IN EFI_GUID *Protocol, OPTIONAL
1299 IN VOID *SearchKey, OPTIONAL
1300 IN OUT UINTN *BufferSize,
1301 OUT EFI_HANDLE *Buffer
1302 )
1303 {
1304 UINTN i;
1305 EFI_HANDLE Handle = NULL;
1306 EFI_STATUS Status = EFI_SUCCESS;
1307
1308 Status = g_org_locate_handle(SearchType, Protocol, SearchKey, BufferSize, Buffer);
1309
1310 if (EFI_SUCCESS == Status && Protocol && CompareGuid(&gEfiBlockIoProtocolGuid, Protocol))
1311 {
1312 for (i = 0; i < (*BufferSize) / sizeof(EFI_HANDLE); i++)
1313 {
1314 if (Buffer[i] == gBlockData.Handle)
1315 {
1316 Handle = Buffer[0];
1317 Buffer[0] = Buffer[i];
1318 Buffer[i] = Handle;
1319 break;
1320 }
1321 }
1322 }
1323
1324 return Status;
1325 }
1326
1327 EFI_STATUS ventoy_hook_1st_cdrom_start(VOID)
1328 {
1329 g_org_locate_handle = gBS->LocateHandle;
1330 gBS->LocateHandle = ventoy_wrapper_locate_handle;
1331
1332 return EFI_SUCCESS;
1333 }
1334
1335 EFI_STATUS ventoy_hook_1st_cdrom_stop(VOID)
1336 {
1337 gBS->LocateHandle = g_org_locate_handle;
1338 g_org_locate_handle = NULL;
1339
1340 return EFI_SUCCESS;
1341 }
1342
https://github.com/ventoy/Ventoy