]> 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
update tool
[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 padding[1];
195 }ko_param;
196
197 #pragma pack()
198
199 static int verbose = 0;
200 #define debug(fmt, ...) if(verbose) printf(fmt, ##__VA_ARGS__)
201
202 static int vtoykmod_write_file(char *name, void *buf, int size)
203 {
204 FILE *fp;
205
206 fp = fopen(name, "wb+");
207 if (!fp)
208 {
209 return -1;
210 }
211
212 fwrite(buf, 1, size, fp);
213 fclose(fp);
214
215 return 0;
216 }
217
218 static int vtoykmod_read_file(char *name, char **buf)
219 {
220 int size;
221 FILE *fp;
222 char *databuf;
223
224 fp = fopen(name, "rb");
225 if (!fp)
226 {
227 debug("failed to open %s %d\n", name, errno);
228 return -1;
229 }
230
231 fseek(fp, 0, SEEK_END);
232 size = (int)ftell(fp);
233 fseek(fp, 0, SEEK_SET);
234
235 databuf = malloc(size);
236 if (!databuf)
237 {
238 debug("failed to open malloc %d\n", size);
239 return -1;
240 }
241
242 fread(databuf, 1, size, fp);
243 fclose(fp);
244
245 *buf = databuf;
246 return size;
247 }
248
249 static int vtoykmod_find_section64(char *buf, char *section, int *offset, int *len, Elf64_Shdr **shdr)
250 {
251 uint16_t i;
252 int cmplen;
253 char *name = NULL;
254 char *strtbl = NULL;
255 Elf64_Ehdr *elf = NULL;
256 Elf64_Shdr *sec = NULL;
257
258 cmplen = (int)strlen(section);
259
260 elf = (Elf64_Ehdr *)buf;
261 sec = (Elf64_Shdr *)(buf + elf->e_shoff);
262 strtbl = buf + sec[elf->e_shstrndx].sh_offset;
263
264 for (i = 0; i < elf->e_shnum; i++)
265 {
266 name = strtbl + sec[i].sh_name;
267 if (name && strncmp(name, section, cmplen) == 0)
268 {
269 *offset = (int)(sec[i].sh_offset);
270 *len = (int)(sec[i].sh_size);
271 if (shdr)
272 {
273 *shdr = sec + i;
274 }
275 return 0;
276 }
277 }
278
279 return 1;
280 }
281
282 static int vtoykmod_find_section32(char *buf, char *section, int *offset, int *len, Elf32_Shdr **shdr)
283 {
284 uint16_t i;
285 int cmplen;
286 char *name = NULL;
287 char *strtbl = NULL;
288 Elf32_Ehdr *elf = NULL;
289 Elf32_Shdr *sec = NULL;
290
291 cmplen = (int)strlen(section);
292
293 elf = (Elf32_Ehdr *)buf;
294 sec = (Elf32_Shdr *)(buf + elf->e_shoff);
295 strtbl = buf + sec[elf->e_shstrndx].sh_offset;
296
297 for (i = 0; i < elf->e_shnum; i++)
298 {
299 name = strtbl + sec[i].sh_name;
300 if (name && strncmp(name, section, cmplen) == 0)
301 {
302 *offset = (int)(sec[i].sh_offset);
303 *len = (int)(sec[i].sh_size);
304 if (shdr)
305 {
306 *shdr = sec + i;
307 }
308 return 0;
309 }
310 }
311
312 return 1;
313 }
314
315 static int vtoykmod_update_modcrc1(char *oldmodver, int oldcnt, char *newmodver, int newcnt)
316 {
317 int i, j;
318 struct modversion_info *pold, *pnew;
319
320 pold = (struct modversion_info *)oldmodver;
321 pnew = (struct modversion_info *)newmodver;
322
323 debug("module update modver format 1\n");
324 for (i = 0; i < oldcnt; i++)
325 {
326 for (j = 0; j < newcnt; j++)
327 {
328 if (strcmp(pold[i].name, pnew[j].name) == 0)
329 {
330 debug("CRC 0x%08lx --> 0x%08lx %s\n", pold[i].crc, pnew[i].crc, pold[i].name);
331 pold[i].crc = pnew[j].crc;
332 break;
333 }
334 }
335 }
336
337 return 0;
338 }
339
340
341 static int vtoykmod_update_modcrc2(char *oldmodver, int oldlen, char *newmodver, int newlen)
342 {
343 struct modversion_info2 *pold, *pnew, *pnewend;
344
345 pold = (struct modversion_info2 *)oldmodver;
346 pnew = (struct modversion_info2 *)newmodver;
347 pnewend = (struct modversion_info2 *)(newmodver + newlen);
348
349 debug("module update modver format 2\n");
350 /* here we think that there is only module_layout in oldmodver */
351
352 for (; pnew < pnewend && pnew->next; pnew = (struct modversion_info2 *)((char *)pnew + pnew->next))
353 {
354 if (strcmp(pnew->name, "module_layout") == 0)
355 {
356 debug("CRC 0x%08x --> 0x%08x %s\n", pold->crc, pnew->crc, pnew->name);
357 memset(pold, 0, oldlen);
358 pold->next = 0x18; /* 8 + module_layout align 8 */
359 pold->crc = pnew->crc;
360 strcpy(pold->name, pnew->name);
361 break;
362 }
363 }
364
365 return 0;
366 }
367
368
369 static int vtoykmod_update_modcrc(char *oldmodver, int oldlen, char *newmodver, int newlen)
370 {
371 uint32_t uiCrc = 0;
372
373 memcpy(&uiCrc, newmodver + 4, 4);
374
375 if (uiCrc > 0)
376 {
377 return vtoykmod_update_modcrc2(oldmodver, oldlen, newmodver, newlen);
378 }
379 else
380 {
381 return vtoykmod_update_modcrc1(oldmodver, oldlen / 64, newmodver, newlen / 64);
382 }
383 }
384
385 static int vtoykmod_update_vermagic(char *oldbuf, int oldsize, char *newbuf, int newsize, int *modver)
386 {
387 int i = 0;
388 char *oldver = NULL;
389 char *newver = NULL;
390
391 *modver = 0;
392
393 for (i = 0; i < oldsize - 9; i++)
394 {
395 if (strncmp(oldbuf + i, "vermagic=", 9) == 0)
396 {
397 oldver = oldbuf + i + 9;
398 debug("Find old vermagic at %d <%s>\n", i, oldver);
399 break;
400 }
401 }
402
403 for (i = 0; i < newsize - 9; i++)
404 {
405 if (strncmp(newbuf + i, "vermagic=", 9) == 0)
406 {
407 newver = newbuf + i + 9;
408 debug("Find new vermagic at %d <%s>\n", i, newver);
409 break;
410 }
411 }
412
413 if (oldver && newver)
414 {
415 memcpy(oldver, newver, strlen(newver) + 1);
416 //if (strstr(newver, "modversions"))
417 {
418 *modver = 1;
419 }
420 }
421
422 return 0;
423 }
424
425 int vtoykmod_update(int kvMajor, int kvMinor, char *oldko, char *newko)
426 {
427 int rc = 0;
428 int modver = 0;
429 int oldoff, oldlen;
430 int newoff, newlen;
431 int oldsize, newsize;
432 char *newbuf, *oldbuf;
433 Elf64_Shdr *sec = NULL;
434
435 oldsize = vtoykmod_read_file(oldko, &oldbuf);
436 newsize = vtoykmod_read_file(newko, &newbuf);
437 if (oldsize < 0 || newsize < 0)
438 {
439 return 1;
440 }
441
442 /* 1: update vermagic */
443 vtoykmod_update_vermagic(oldbuf, oldsize, newbuf, newsize, &modver);
444
445 /* 2: update modversion crc */
446 if (modver)
447 {
448 if (oldbuf[EI_CLASS] == ELFCLASS64)
449 {
450 rc = vtoykmod_find_section64(oldbuf, "__versions", &oldoff, &oldlen, NULL);
451 rc += vtoykmod_find_section64(newbuf, "__versions", &newoff, &newlen, NULL);
452 }
453 else
454 {
455 rc = vtoykmod_find_section32(oldbuf, "__versions", &oldoff, &oldlen, NULL);
456 rc += vtoykmod_find_section32(newbuf, "__versions", &newoff, &newlen, NULL);
457 }
458
459 if (rc == 0)
460 {
461 vtoykmod_update_modcrc(oldbuf + oldoff, oldlen, newbuf + newoff, newlen);
462 }
463 }
464 else
465 {
466 debug("no need to proc modversions\n");
467 }
468
469 /* 3: update relocate address */
470 if (oldbuf[EI_CLASS] == ELFCLASS64)
471 {
472 Elf64_Rela *oldRela, *newRela;
473
474 rc = vtoykmod_find_section64(oldbuf, ".rela.gnu.linkonce.this_module", &oldoff, &oldlen, NULL);
475 rc += vtoykmod_find_section64(newbuf, ".rela.gnu.linkonce.this_module", &newoff, &newlen, NULL);
476 if (rc == 0)
477 {
478 oldRela = (Elf64_Rela *)(oldbuf + oldoff);
479 newRela = (Elf64_Rela *)(newbuf + newoff);
480
481 debug("init_module rela: 0x%llx --> 0x%llx\n", (_ull)(oldRela[0].r_offset), (_ull)(newRela[0].r_offset));
482 oldRela[0].r_offset = newRela[0].r_offset;
483 oldRela[0].r_addend = newRela[0].r_addend;
484
485 debug("cleanup_module rela: 0x%llx --> 0x%llx\n", (_ull)(oldRela[1].r_offset), (_ull)(newRela[1].r_offset));
486 oldRela[1].r_offset = newRela[1].r_offset;
487 oldRela[1].r_addend = newRela[1].r_addend;
488 }
489 else
490 {
491 debug("section .rela.gnu.linkonce.this_module not found\n");
492 }
493
494 if (kvMajor > 6 || (kvMajor == 6 && kvMinor >= 3))
495 {
496 rc = vtoykmod_find_section64(oldbuf, ".gnu.linkonce.this_module", &oldoff, &oldlen, &sec);
497 rc += vtoykmod_find_section64(newbuf, ".gnu.linkonce.this_module", &newoff, &newlen, NULL);
498 if (rc == 0)
499 {
500 debug("section .gnu.linkonce.this_module change oldlen:0x%x to newlen:0x%x\n", oldlen, newlen);
501 if (sec)
502 {
503 sec->sh_size = newlen;
504 }
505 }
506 else
507 {
508 debug("section .gnu.linkonce.this_module not found\n");
509 }
510 }
511 }
512 else
513 {
514 Elf32_Rel *oldRel, *newRel;
515
516 rc = vtoykmod_find_section32(oldbuf, ".rel.gnu.linkonce.this_module", &oldoff, &oldlen, NULL);
517 rc += vtoykmod_find_section32(newbuf, ".rel.gnu.linkonce.this_module", &newoff, &newlen, NULL);
518 if (rc == 0)
519 {
520 oldRel = (Elf32_Rel *)(oldbuf + oldoff);
521 newRel = (Elf32_Rel *)(newbuf + newoff);
522
523 debug("init_module rel: 0x%x --> 0x%x\n", oldRel[0].r_offset, newRel[0].r_offset);
524 oldRel[0].r_offset = newRel[0].r_offset;
525
526 debug("cleanup_module rel: 0x%x --> 0x%x\n", oldRel[0].r_offset, newRel[0].r_offset);
527 oldRel[1].r_offset = newRel[1].r_offset;
528 }
529 else
530 {
531 debug("section .rel.gnu.linkonce.this_module not found\n");
532 }
533 }
534
535 vtoykmod_write_file(oldko, oldbuf, oldsize);
536
537 free(oldbuf);
538 free(newbuf);
539
540 return 0;
541 }
542
543 int vtoykmod_fill_param(char **argv)
544 {
545 int i;
546 int size;
547 char *buf = NULL;
548 ko_param *param;
549 unsigned char magic[16] = { magic_sig };
550
551 size = vtoykmod_read_file(argv[0], &buf);
552 if (size < 0)
553 {
554 return 1;
555 }
556
557 for (i = 0; i < size; i++)
558 {
559 if (memcmp(buf + i, magic, 16) == 0)
560 {
561 debug("Find param magic at %d\n", i);
562 param = (ko_param *)(buf + i);
563
564 param->struct_size = (unsigned long)sizeof(ko_param);
565 param->pgsize = strtoul(argv[1], NULL, 10);
566 param->printk_addr = strtoul(argv[2], NULL, 16);
567 param->ro_addr = strtoul(argv[3], NULL, 16);
568 param->rw_addr = strtoul(argv[4], NULL, 16);
569 param->sym_get_addr = strtoul(argv[5], NULL, 16);
570 param->sym_get_size = strtoul(argv[6], NULL, 10);
571 param->sym_put_addr = strtoul(argv[7], NULL, 16);
572 param->sym_put_size = strtoul(argv[8], NULL, 10);
573 param->reg_kprobe_addr = strtoul(argv[9], NULL, 16);
574 param->unreg_kprobe_addr = strtoul(argv[10], NULL, 16);
575 param->kv_major = strtoul(argv[11], NULL, 10);
576 param->ibt = strtoul(argv[12], NULL, 16);;
577 param->kv_minor = strtoul(argv[13], NULL, 10);
578 param->blkdev_get_addr = strtoul(argv[14], NULL, 16);
579 param->blkdev_put_addr = strtoul(argv[15], NULL, 16);
580
581 debug("pgsize=%lu (%s)\n", param->pgsize, argv[1]);
582 debug("printk_addr=0x%lx (%s)\n", param->printk_addr, argv[2]);
583 debug("ro_addr=0x%lx (%s)\n", param->ro_addr, argv[3]);
584 debug("rw_addr=0x%lx (%s)\n", param->rw_addr, argv[4]);
585 debug("sym_get_addr=0x%lx (%s)\n", param->sym_get_addr, argv[5]);
586 debug("sym_get_size=%lu (%s)\n", param->sym_get_size, argv[6]);
587 debug("sym_put_addr=0x%lx (%s)\n", param->sym_put_addr, argv[7]);
588 debug("sym_put_size=%lu (%s)\n", param->sym_put_size, argv[8]);
589 debug("reg_kprobe_addr=0x%lx (%s)\n", param->reg_kprobe_addr, argv[9]);
590 debug("unreg_kprobe_addr=0x%lx (%s)\n", param->unreg_kprobe_addr, argv[10]);
591 debug("kv_major=%lu (%s)\n", param->kv_major, argv[11]);
592 debug("ibt=0x%lx (%s)\n", param->ibt, argv[12]);
593 debug("kv_minor=%lu (%s)\n", param->kv_minor, argv[13]);
594 debug("blkdev_get_addr=0x%lx (%s)\n", param->blkdev_get_addr, argv[14]);
595 debug("blkdev_put_addr=0x%lx (%s)\n", param->blkdev_put_addr, argv[15]);
596
597 break;
598 }
599 }
600
601 if (i >= size)
602 {
603 debug("### param magic not found \n");
604 }
605
606 vtoykmod_write_file(argv[0], buf, size);
607
608 free(buf);
609 return 0;
610 }
611
612 #ifdef VTOY_X86_64
613 static int vtoykmod_check_ibt(void)
614 {
615 uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
616
617 __cpuid_count(7, 0, eax, ebx, ecx, edx);
618
619 if (edx & (1 << 20))
620 {
621 return 0;
622 }
623 return 1;
624 }
625 #else
626 static int vtoykmod_check_ibt(void)
627 {
628 return 1;
629 }
630 #endif
631
632 int vtoykmod_main(int argc, char **argv)
633 {
634 int i;
635 int kvMajor = 0;
636 int kvMinor = 0;
637
638 for (i = 0; i < argc; i++)
639 {
640 if (argv[i][0] == '-' && argv[i][1] == 'v')
641 {
642 verbose = 1;
643 break;
644 }
645 }
646
647 if (verbose)
648 {
649 printf("==== Dump Argv ====\n");
650 for (i = 0; i < argc; i++)
651 {
652 printf("<%s> ", argv[i]);
653 }
654 printf("\n");
655 }
656
657 if (argv[1][0] == '-' && argv[1][1] == 'f')
658 {
659 return vtoykmod_fill_param(argv + 2);
660 }
661 else if (argv[1][0] == '-' && argv[1][1] == 'u')
662 {
663 kvMajor = (int)strtol(argv[2], NULL, 10);
664 kvMinor = (int)strtol(argv[3], NULL, 10);
665 return vtoykmod_update(kvMajor, kvMinor, argv[4], argv[5]);
666 }
667 else if (argv[1][0] == '-' && argv[1][1] == 'I')
668 {
669 return vtoykmod_check_ibt();
670 }
671
672 return 0;
673 }
674
675 // wrapper main
676 #ifndef BUILD_VTOY_TOOL
677 int main(int argc, char **argv)
678 {
679 return vtoykmod_main(argc, argv);
680 }
681 #endif
682
https://github.com/ventoy/Ventoy