]> glassweightruler.freedombox.rocks Git - Ventoy.git/blob - VtoyTool/vtoykmod.c
projects / Ventoy.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix arch iso boot issue (#2825 #2824)
[Ventoy.git] / VtoyTool / vtoykmod.c
1 /******************************************************************************
2 * vtoykmod.c ---- ventoy kmod
3 *
4 * Copyright (c) 2021, 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 <stdio.h>
22 #include <stdlib.h>
23 #include <stdint.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h>
27 #ifdef VTOY_X86_64
28 #include <cpuid.h>
29 #endif
30
31 #define _ull unsigned long long
32
33 #define magic_sig 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF
34
35 #define EI_NIDENT (16)
36
37 #define EI_MAG0 0 /* e_ident[] indexes */
38 #define EI_MAG1 1
39 #define EI_MAG2 2
40 #define EI_MAG3 3
41 #define EI_CLASS 4
42 #define EI_DATA 5
43 #define EI_VERSION 6
44 #define EI_OSABI 7
45 #define EI_PAD 8
46
47 #define ELFMAG0 0x7f /* EI_MAG */
48 #define ELFMAG1 'E'
49 #define ELFMAG2 'L'
50 #define ELFMAG3 'F'
51 #define ELFMAG "\177ELF"
52 #define SELFMAG 4
53
54 #define ELFCLASSNONE 0 /* EI_CLASS */
55 #define ELFCLASS32 1
56 #define ELFCLASS64 2
57 #define ELFCLASSNUM 3
58
59 #define ELFDATANONE 0 /* e_ident[EI_DATA] */
60 #define ELFDATA2LSB 1
61 #define ELFDATA2MSB 2
62
63 #define EV_NONE 0 /* e_version, EI_VERSION */
64 #define EV_CURRENT 1
65 #define EV_NUM 2
66
67 #define ELFOSABI_NONE 0
68 #define ELFOSABI_LINUX 3
69
70 #define SHT_STRTAB 3
71
72 #pragma pack(1)
73
74
75 typedef struct
76 {
77 unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */
78 uint16_t e_type; /* Object file type */
79 uint16_t e_machine; /* Architecture */
80 uint32_t e_version; /* Object file version */
81 uint32_t e_entry; /* Entry point virtual address */
82 uint32_t e_phoff; /* Program header table file offset */
83 uint32_t e_shoff; /* Section header table file offset */
84 uint32_t e_flags; /* Processor-specific flags */
85 uint16_t e_ehsize; /* ELF header size in bytes */
86 uint16_t e_phentsize; /* Program header table entry size */
87 uint16_t e_phnum; /* Program header table entry count */
88 uint16_t e_shentsize; /* Section header table entry size */
89 uint16_t e_shnum; /* Section header table entry count */
90 uint16_t e_shstrndx; /* Section header string table index */
91 } Elf32_Ehdr;
92
93 typedef struct
94 {
95 unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */
96 uint16_t e_type; /* Object file type */
97 uint16_t e_machine; /* Architecture */
98 uint32_t e_version; /* Object file version */
99 uint64_t e_entry; /* Entry point virtual address */
100 uint64_t e_phoff; /* Program header table file offset */
101 uint64_t e_shoff; /* Section header table file offset */
102 uint32_t e_flags; /* Processor-specific flags */
103 uint16_t e_ehsize; /* ELF header size in bytes */
104 uint16_t e_phentsize; /* Program header table entry size */
105 uint16_t e_phnum; /* Program header table entry count */
106 uint16_t e_shentsize; /* Section header table entry size */
107 uint16_t e_shnum; /* Section header table entry count */
108 uint16_t e_shstrndx; /* Section header string table index */
109 } Elf64_Ehdr;
110
111 typedef struct
112 {
113 uint32_t sh_name; /* Section name (string tbl index) */
114 uint32_t sh_type; /* Section type */
115 uint32_t sh_flags; /* Section flags */
116 uint32_t sh_addr; /* Section virtual addr at execution */
117 uint32_t sh_offset; /* Section file offset */
118 uint32_t sh_size; /* Section size in bytes */
119 uint32_t sh_link; /* Link to another section */
120 uint32_t sh_info; /* Additional section information */
121 uint32_t sh_addralign; /* Section alignment */
122 uint32_t sh_entsize; /* Entry size if section holds table */
123 } Elf32_Shdr;
124
125 typedef struct
126 {
127 uint32_t sh_name; /* Section name (string tbl index) */
128 uint32_t sh_type; /* Section type */
129 uint64_t sh_flags; /* Section flags */
130 uint64_t sh_addr; /* Section virtual addr at execution */
131 uint64_t sh_offset; /* Section file offset */
132 uint64_t sh_size; /* Section size in bytes */
133 uint32_t sh_link; /* Link to another section */
134 uint32_t sh_info; /* Additional section information */
135 uint64_t sh_addralign; /* Section alignment */
136 uint64_t sh_entsize; /* Entry size if section holds table */
137 } Elf64_Shdr;
138
139 typedef struct elf32_rel {
140 uint32_t r_offset;
141 uint32_t r_info;
142 } Elf32_Rel;
143
144 typedef struct elf64_rel {
145 uint64_t r_offset; /* Location at which to apply the action */
146 uint64_t r_info; /* index and type of relocation */
147 } Elf64_Rel;
148
149 typedef struct elf32_rela{
150 uint32_t r_offset;
151 uint32_t r_info;
152 int32_t r_addend;
153 } Elf32_Rela;
154
155 typedef struct elf64_rela {
156 uint64_t r_offset; /* Location at which to apply the action */
157 uint64_t r_info; /* index and type of relocation */
158 int64_t r_addend; /* Constant addend used to compute value */
159 } Elf64_Rela;
160
161
162 struct modversion_info {
163 unsigned long crc;
164 char name[64 - sizeof(unsigned long)];
165 };
166
167 struct modversion_info2 {
168 /* Offset of the next modversion entry in relation to this one. */
169 uint32_t next;
170 uint32_t crc;
171 char name[0];
172 };
173
174
175 typedef struct ko_param
176 {
177 unsigned char magic[16];
178 unsigned long struct_size;
179 unsigned long pgsize;
180 unsigned long printk_addr;
181 unsigned long ro_addr;
182 unsigned long rw_addr;
183 unsigned long reg_kprobe_addr;
184 unsigned long unreg_kprobe_addr;
185 unsigned long sym_get_addr;
186 unsigned long sym_get_size;
187 unsigned long sym_put_addr;
188 unsigned long sym_put_size;
189 unsigned long kv_major;
190 unsigned long ibt;
191 unsigned long kv_minor;
192 unsigned long blkdev_get_addr;
193 unsigned long blkdev_put_addr;
194 unsigned long bdev_open_addr;
195 unsigned long kv_subminor;
196 unsigned long padding[1];
197 }ko_param;
198
199 #pragma pack()
200
201 static int verbose = 0;
202 #define debug(fmt, ...) if(verbose) printf(fmt, ##__VA_ARGS__)
203
204 static int vtoykmod_write_file(char *name, void *buf, int size)
205 {
206 FILE *fp;
207
208 fp = fopen(name, "wb+");
209 if (!fp)
210 {
211 return -1;
212 }
213
214 fwrite(buf, 1, size, fp);
215 fclose(fp);
216
217 return 0;
218 }
219
220 static int vtoykmod_read_file(char *name, char **buf)
221 {
222 int size;
223 FILE *fp;
224 char *databuf;
225
226 fp = fopen(name, "rb");
227 if (!fp)
228 {
229 debug("failed to open %s %d\n", name, errno);
230 return -1;
231 }
232
233 fseek(fp, 0, SEEK_END);
234 size = (int)ftell(fp);
235 fseek(fp, 0, SEEK_SET);
236
237 databuf = malloc(size);
238 if (!databuf)
239 {
240 debug("failed to open malloc %d\n", size);
241 return -1;
242 }
243
244 fread(databuf, 1, size, fp);
245 fclose(fp);
246
247 *buf = databuf;
248 return size;
249 }
250
251 static int vtoykmod_find_section64(char *buf, char *section, int *offset, int *len, Elf64_Shdr **shdr)
252 {
253 uint16_t i;
254 int cmplen;
255 char *name = NULL;
256 char *strtbl = NULL;
257 Elf64_Ehdr *elf = NULL;
258 Elf64_Shdr *sec = NULL;
259
260 cmplen = (int)strlen(section);
261
262 elf = (Elf64_Ehdr *)buf;
263 sec = (Elf64_Shdr *)(buf + elf->e_shoff);
264 strtbl = buf + sec[elf->e_shstrndx].sh_offset;
265
266 for (i = 0; i < elf->e_shnum; i++)
267 {
268 name = strtbl + sec[i].sh_name;
269 if (name && strncmp(name, section, cmplen) == 0)
270 {
271 *offset = (int)(sec[i].sh_offset);
272 *len = (int)(sec[i].sh_size);
273 if (shdr)
274 {
275 *shdr = sec + i;
276 }
277 return 0;
278 }
279 }
280
281 return 1;
282 }
283
284 static int vtoykmod_find_section32(char *buf, char *section, int *offset, int *len, Elf32_Shdr **shdr)
285 {
286 uint16_t i;
287 int cmplen;
288 char *name = NULL;
289 char *strtbl = NULL;
290 Elf32_Ehdr *elf = NULL;
291 Elf32_Shdr *sec = NULL;
292
293 cmplen = (int)strlen(section);
294
295 elf = (Elf32_Ehdr *)buf;
296 sec = (Elf32_Shdr *)(buf + elf->e_shoff);
297 strtbl = buf + sec[elf->e_shstrndx].sh_offset;
298
299 for (i = 0; i < elf->e_shnum; i++)
300 {
301 name = strtbl + sec[i].sh_name;
302 if (name && strncmp(name, section, cmplen) == 0)
303 {
304 *offset = (int)(sec[i].sh_offset);
305 *len = (int)(sec[i].sh_size);
306 if (shdr)
307 {
308 *shdr = sec + i;
309 }
310 return 0;
311 }
312 }
313
314 return 1;
315 }
316
317 static int vtoykmod_update_modcrc1(char *oldmodver, int oldcnt, char *newmodver, int newcnt)
318 {
319 int i, j;
320 struct modversion_info *pold, *pnew;
321
322 pold = (struct modversion_info *)oldmodver;
323 pnew = (struct modversion_info *)newmodver;
324
325 debug("module update modver format 1\n");
326 for (i = 0; i < oldcnt; i++)
327 {
328 for (j = 0; j < newcnt; j++)
329 {
330 if (strcmp(pold[i].name, pnew[j].name) == 0)
331 {
332 debug("CRC 0x%08lx --> 0x%08lx %s\n", pold[i].crc, pnew[i].crc, pold[i].name);
333 pold[i].crc = pnew[j].crc;
334 break;
335 }
336 }
337 }
338
339 return 0;
340 }
341
342
343 static int vtoykmod_update_modcrc2(char *oldmodver, int oldlen, char *newmodver, int newlen)
344 {
345 struct modversion_info2 *pold, *pnew, *pnewend;
346
347 pold = (struct modversion_info2 *)oldmodver;
348 pnew = (struct modversion_info2 *)newmodver;
349 pnewend = (struct modversion_info2 *)(newmodver + newlen);
350
351 debug("module update modver format 2\n");
352 /* here we think that there is only module_layout in oldmodver */
353
354 for (; pnew < pnewend && pnew->next; pnew = (struct modversion_info2 *)((char *)pnew + pnew->next))
355 {
356 if (strcmp(pnew->name, "module_layout") == 0)
357 {
358 debug("CRC 0x%08x --> 0x%08x %s\n", pold->crc, pnew->crc, pnew->name);
359 memset(pold, 0, oldlen);
360 pold->next = 0x18; /* 8 + module_layout align 8 */
361 pold->crc = pnew->crc;
362 strcpy(pold->name, pnew->name);
363 break;
364 }
365 }
366
367 return 0;
368 }
369
370
371 static int vtoykmod_update_modcrc(char *oldmodver, int oldlen, char *newmodver, int newlen)
372 {
373 uint32_t uiCrc = 0;
374
375 memcpy(&uiCrc, newmodver + 4, 4);
376
377 if (uiCrc > 0)
378 {
379 return vtoykmod_update_modcrc2(oldmodver, oldlen, newmodver, newlen);
380 }
381 else
382 {
383 return vtoykmod_update_modcrc1(oldmodver, oldlen / 64, newmodver, newlen / 64);
384 }
385 }
386
387 static int vtoykmod_update_vermagic(char *oldbuf, int oldsize, char *newbuf, int newsize, int *modver)
388 {
389 int i = 0;
390 char *oldver = NULL;
391 char *newver = NULL;
392
393 *modver = 0;
394
395 for (i = 0; i < oldsize - 9; i++)
396 {
397 if (strncmp(oldbuf + i, "vermagic=", 9) == 0)
398 {
399 oldver = oldbuf + i + 9;
400 debug("Find old vermagic at %d <%s>\n", i, oldver);
401 break;
402 }
403 }
404
405 for (i = 0; i < newsize - 9; i++)
406 {
407 if (strncmp(newbuf + i, "vermagic=", 9) == 0)
408 {
409 newver = newbuf + i + 9;
410 debug("Find new vermagic at %d <%s>\n", i, newver);
411 break;
412 }
413 }
414
415 if (oldver && newver)
416 {
417 memcpy(oldver, newver, strlen(newver) + 1);
418 //if (strstr(newver, "modversions"))
419 {
420 *modver = 1;
421 }
422 }
423
424 return 0;
425 }
426
427 int vtoykmod_update(int kvMajor, int kvMinor, char *oldko, char *newko)
428 {
429 int rc = 0;
430 int modver = 0;
431 int oldoff, oldlen;
432 int newoff, newlen;
433 int oldsize, newsize;
434 char *newbuf, *oldbuf;
435 Elf64_Shdr *sec = NULL;
436
437 oldsize = vtoykmod_read_file(oldko, &oldbuf);
438 newsize = vtoykmod_read_file(newko, &newbuf);
439 if (oldsize < 0 || newsize < 0)
440 {
441 return 1;
442 }
443
444 /* 1: update vermagic */
445 vtoykmod_update_vermagic(oldbuf, oldsize, newbuf, newsize, &modver);
446
447 /* 2: update modversion crc */
448 if (modver)
449 {
450 if (oldbuf[EI_CLASS] == ELFCLASS64)
451 {
452 rc = vtoykmod_find_section64(oldbuf, "__versions", &oldoff, &oldlen, NULL);
453 rc += vtoykmod_find_section64(newbuf, "__versions", &newoff, &newlen, NULL);
454 }
455 else
456 {
457 rc = vtoykmod_find_section32(oldbuf, "__versions", &oldoff, &oldlen, NULL);
458 rc += vtoykmod_find_section32(newbuf, "__versions", &newoff, &newlen, NULL);
459 }
460
461 if (rc == 0)
462 {
463 vtoykmod_update_modcrc(oldbuf + oldoff, oldlen, newbuf + newoff, newlen);
464 }
465 }
466 else
467 {
468 debug("no need to proc modversions\n");
469 }
470
471 /* 3: update relocate address */
472 if (oldbuf[EI_CLASS] == ELFCLASS64)
473 {
474 Elf64_Rela *oldRela, *newRela;
475
476 rc = vtoykmod_find_section64(oldbuf, ".rela.gnu.linkonce.this_module", &oldoff, &oldlen, NULL);
477 rc += vtoykmod_find_section64(newbuf, ".rela.gnu.linkonce.this_module", &newoff, &newlen, NULL);
478 if (rc == 0)
479 {
480 oldRela = (Elf64_Rela *)(oldbuf + oldoff);
481 newRela = (Elf64_Rela *)(newbuf + newoff);
482
483 debug("init_module rela: 0x%llx --> 0x%llx\n", (_ull)(oldRela[0].r_offset), (_ull)(newRela[0].r_offset));
484 oldRela[0].r_offset = newRela[0].r_offset;
485 oldRela[0].r_addend = newRela[0].r_addend;
486
487 debug("cleanup_module rela: 0x%llx --> 0x%llx\n", (_ull)(oldRela[1].r_offset), (_ull)(newRela[1].r_offset));
488 oldRela[1].r_offset = newRela[1].r_offset;
489 oldRela[1].r_addend = newRela[1].r_addend;
490 }
491 else
492 {
493 debug("section .rela.gnu.linkonce.this_module not found\n");
494 }
495
496 if (kvMajor > 6 || (kvMajor == 6 && kvMinor >= 3))
497 {
498 rc = vtoykmod_find_section64(oldbuf, ".gnu.linkonce.this_module", &oldoff, &oldlen, &sec);
499 rc += vtoykmod_find_section64(newbuf, ".gnu.linkonce.this_module", &newoff, &newlen, NULL);
500 if (rc == 0)
501 {
502 debug("section .gnu.linkonce.this_module change oldlen:0x%x to newlen:0x%x\n", oldlen, newlen);
503 if (sec)
504 {
505 sec->sh_size = newlen;
506 }
507 }
508 else
509 {
510 debug("section .gnu.linkonce.this_module not found\n");
511 }
512 }
513 }
514 else
515 {
516 Elf32_Rel *oldRel, *newRel;
517
518 rc = vtoykmod_find_section32(oldbuf, ".rel.gnu.linkonce.this_module", &oldoff, &oldlen, NULL);
519 rc += vtoykmod_find_section32(newbuf, ".rel.gnu.linkonce.this_module", &newoff, &newlen, NULL);
520 if (rc == 0)
521 {
522 oldRel = (Elf32_Rel *)(oldbuf + oldoff);
523 newRel = (Elf32_Rel *)(newbuf + newoff);
524
525 debug("init_module rel: 0x%x --> 0x%x\n", oldRel[0].r_offset, newRel[0].r_offset);
526 oldRel[0].r_offset = newRel[0].r_offset;
527
528 debug("cleanup_module rel: 0x%x --> 0x%x\n", oldRel[0].r_offset, newRel[0].r_offset);
529 oldRel[1].r_offset = newRel[1].r_offset;
530 }
531 else
532 {
533 debug("section .rel.gnu.linkonce.this_module not found\n");
534 }
535 }
536
537 vtoykmod_write_file(oldko, oldbuf, oldsize);
538
539 free(oldbuf);
540 free(newbuf);
541
542 return 0;
543 }
544
545 int vtoykmod_fill_param(char **argv)
546 {
547 int i;
548 int size;
549 char *buf = NULL;
550 ko_param *param;
551 unsigned char magic[16] = { magic_sig };
552
553 size = vtoykmod_read_file(argv[0], &buf);
554 if (size < 0)
555 {
556 return 1;
557 }
558
559 for (i = 0; i < size; i++)
560 {
561 if (memcmp(buf + i, magic, 16) == 0)
562 {
563 debug("Find param magic at %d\n", i);
564 param = (ko_param *)(buf + i);
565
566 param->struct_size = (unsigned long)sizeof(ko_param);
567 param->pgsize = strtoul(argv[1], NULL, 10);
568 param->printk_addr = strtoul(argv[2], NULL, 16);
569 param->ro_addr = strtoul(argv[3], NULL, 16);
570 param->rw_addr = strtoul(argv[4], NULL, 16);
571 param->sym_get_addr = strtoul(argv[5], NULL, 16);
572 param->sym_get_size = strtoul(argv[6], NULL, 10);
573 param->sym_put_addr = strtoul(argv[7], NULL, 16);
574 param->sym_put_size = strtoul(argv[8], NULL, 10);
575 param->reg_kprobe_addr = strtoul(argv[9], NULL, 16);
576 param->unreg_kprobe_addr = strtoul(argv[10], NULL, 16);
577 param->kv_major = strtoul(argv[11], NULL, 10);
578 param->ibt = strtoul(argv[12], NULL, 16);;
579 param->kv_minor = strtoul(argv[13], NULL, 10);
580 param->blkdev_get_addr = strtoul(argv[14], NULL, 16);
581 param->blkdev_put_addr = strtoul(argv[15], NULL, 16);
582 param->kv_subminor = strtoul(argv[16], NULL, 10);
583 param->bdev_open_addr = strtoul(argv[17], NULL, 16);
584
585 debug("pgsize=%lu (%s)\n", param->pgsize, argv[1]);
586 debug("printk_addr=0x%lx (%s)\n", param->printk_addr, argv[2]);
587 debug("ro_addr=0x%lx (%s)\n", param->ro_addr, argv[3]);
588 debug("rw_addr=0x%lx (%s)\n", param->rw_addr, argv[4]);
589 debug("sym_get_addr=0x%lx (%s)\n", param->sym_get_addr, argv[5]);
590 debug("sym_get_size=%lu (%s)\n", param->sym_get_size, argv[6]);
591 debug("sym_put_addr=0x%lx (%s)\n", param->sym_put_addr, argv[7]);
592 debug("sym_put_size=%lu (%s)\n", param->sym_put_size, argv[8]);
593 debug("reg_kprobe_addr=0x%lx (%s)\n", param->reg_kprobe_addr, argv[9]);
594 debug("unreg_kprobe_addr=0x%lx (%s)\n", param->unreg_kprobe_addr, argv[10]);
595 debug("kv_major=%lu (%s)\n", param->kv_major, argv[11]);
596 debug("ibt=0x%lx (%s)\n", param->ibt, argv[12]);
597 debug("kv_minor=%lu (%s)\n", param->kv_minor, argv[13]);
598 debug("blkdev_get_addr=0x%lx (%s)\n", param->blkdev_get_addr, argv[14]);
599 debug("blkdev_put_addr=0x%lx (%s)\n", param->blkdev_put_addr, argv[15]);
600 debug("kv_subminor=%lu (%s)\n", param->kv_subminor, argv[16]);
601 debug("bdev_open_addr=0x%lx (%s)\n", param->bdev_open_addr, argv[17]);
602
603 break;
604 }
605 }
606
607 if (i >= size)
608 {
609 debug("### param magic not found \n");
610 }
611
612 vtoykmod_write_file(argv[0], buf, size);
613
614 free(buf);
615 return 0;
616 }
617
618 #ifdef VTOY_X86_64
619 static int vtoykmod_check_ibt(void)
620 {
621 uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
622
623 __cpuid_count(7, 0, eax, ebx, ecx, edx);
624
625 if (edx & (1 << 20))
626 {
627 return 0;
628 }
629 return 1;
630 }
631 #else
632 static int vtoykmod_check_ibt(void)
633 {
634 return 1;
635 }
636 #endif
637
638 int vtoykmod_main(int argc, char **argv)
639 {
640 int i;
641 int kvMajor = 0;
642 int kvMinor = 0;
643
644 for (i = 0; i < argc; i++)
645 {
646 if (argv[i][0] == '-' && argv[i][1] == 'v')
647 {
648 verbose = 1;
649 break;
650 }
651 }
652
653 if (verbose)
654 {
655 printf("==== Dump Argv ====\n");
656 for (i = 0; i < argc; i++)
657 {
658 printf("<%s> ", argv[i]);
659 }
660 printf("\n");
661 }
662
663 if (argv[1][0] == '-' && argv[1][1] == 'f')
664 {
665 return vtoykmod_fill_param(argv + 2);
666 }
667 else if (argv[1][0] == '-' && argv[1][1] == 'u')
668 {
669 kvMajor = (int)strtol(argv[2], NULL, 10);
670 kvMinor = (int)strtol(argv[3], NULL, 10);
671 return vtoykmod_update(kvMajor, kvMinor, argv[4], argv[5]);
672 }
673 else if (argv[1][0] == '-' && argv[1][1] == 'I')
674 {
675 return vtoykmod_check_ibt();
676 }
677
678 return 0;
679 }
680
681 // wrapper main
682 #ifndef BUILD_VTOY_TOOL
683 int main(int argc, char **argv)
684 {
685 return vtoykmod_main(argc, argv);
686 }
687 #endif
688
https://github.com/ventoy/Ventoy