1 /* 2 * libkmod - interface to kernel module operations 3 * 4 * Copyright (C) 2011-2013 ProFUSION embedded systems 5 * 6 * This library is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2.1 of the License, or (at your option) any later version. 10 * 11 * This library is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with this library; if not, see <http://www.gnu.org/licenses/>. 18 */ 19 20 #include <assert.h> 21 #include <elf.h> 22 #include <errno.h> 23 #include <stdlib.h> 24 #include <string.h> 25 26 #include <shared/util.h> 27 28 #include "libkmod.h" 29 #include "libkmod-internal.h" 30 31 enum kmod_elf_class { 32 KMOD_ELF_32 = (1 << 1), 33 KMOD_ELF_64 = (1 << 2), 34 KMOD_ELF_LSB = (1 << 3), 35 KMOD_ELF_MSB = (1 << 4) 36 }; 37 38 /* as defined in module-init-tools */ 39 struct kmod_modversion32 { 40 uint32_t crc; 41 char name[64 - sizeof(uint32_t)]; 42 }; 43 44 struct kmod_modversion64 { 45 uint64_t crc; 46 char name[64 - sizeof(uint64_t)]; 47 }; 48 49 struct kmod_elf { 50 const uint8_t *memory; 51 uint8_t *changed; 52 uint64_t size; 53 enum kmod_elf_class class; 54 struct kmod_elf_header { 55 struct { 56 uint64_t offset; 57 uint16_t count; 58 uint16_t entry_size; 59 } section; 60 struct { 61 uint16_t section; /* index of the strings section */ 62 uint64_t size; 63 uint64_t offset; 64 uint32_t nameoff; /* offset in strings itself */ 65 } strings; 66 uint16_t machine; 67 } header; 68 }; 69 70 //#define ENABLE_ELFDBG 1 71 72 #if defined(ENABLE_LOGGING) && defined(ENABLE_ELFDBG) 73 #define ELFDBG(elf, ...) \ 74 _elf_dbg(elf, __FILE__, __LINE__, __func__, __VA_ARGS__); 75 76 static inline void _elf_dbg(const struct kmod_elf *elf, const char *fname, unsigned line, const char *func, const char *fmt, ...) 77 { 78 va_list args; 79 80 fprintf(stderr, "ELFDBG-%d%c: %s:%u %s() ", 81 (elf->class & KMOD_ELF_32) ? 32 : 64, 82 (elf->class & KMOD_ELF_MSB) ? 'M' : 'L', 83 fname, line, func); 84 va_start(args, fmt); 85 vfprintf(stderr, fmt, args); 86 va_end(args); 87 } 88 #else 89 #define ELFDBG(elf, ...) 90 #endif 91 92 93 static int elf_identify(const void *memory, uint64_t size) 94 { 95 const uint8_t *p = memory; 96 int class = 0; 97 98 if (size <= EI_NIDENT || memcmp(p, ELFMAG, SELFMAG) != 0) 99 return -ENOEXEC; 100 101 switch (p[EI_CLASS]) { 102 case ELFCLASS32: 103 if (size <= sizeof(Elf32_Ehdr)) 104 return -EINVAL; 105 class |= KMOD_ELF_32; 106 break; 107 case ELFCLASS64: 108 if (size <= sizeof(Elf64_Ehdr)) 109 return -EINVAL; 110 class |= KMOD_ELF_64; 111 break; 112 default: 113 return -EINVAL; 114 } 115 116 switch (p[EI_DATA]) { 117 case ELFDATA2LSB: 118 class |= KMOD_ELF_LSB; 119 break; 120 case ELFDATA2MSB: 121 class |= KMOD_ELF_MSB; 122 break; 123 default: 124 return -EINVAL; 125 } 126 127 return class; 128 } 129 130 static inline uint64_t elf_get_uint(const struct kmod_elf *elf, uint64_t offset, uint16_t size) 131 { 132 const uint8_t *p; 133 uint64_t ret = 0; 134 size_t i; 135 136 assert(size <= sizeof(uint64_t)); 137 assert(offset + size <= elf->size); 138 if (offset + size > elf->size) { 139 ELFDBG(elf, "out of bounds: %"PRIu64" + %"PRIu16" = %"PRIu64"> %"PRIu64" (ELF size)\n", 140 offset, size, offset + size, elf->size); 141 return (uint64_t)-1; 142 } 143 144 p = elf->memory + offset; 145 if (elf->class & KMOD_ELF_MSB) { 146 for (i = 0; i < size; i++) 147 ret = (ret << 8) | p[i]; 148 } else { 149 for (i = 1; i <= size; i++) 150 ret = (ret << 8) | p[size - i]; 151 } 152 153 ELFDBG(elf, "size=%"PRIu16" offset=%"PRIu64" value=%"PRIu64"\n", 154 size, offset, ret); 155 156 return ret; 157 } 158 159 static inline int elf_set_uint(struct kmod_elf *elf, uint64_t offset, uint64_t size, uint64_t value) 160 { 161 uint8_t *p; 162 size_t i; 163 164 ELFDBG(elf, "size=%"PRIu16" offset=%"PRIu64" value=%"PRIu64" write memory=%p\n", 165 size, offset, value, elf->changed); 166 167 assert(size <= sizeof(uint64_t)); 168 assert(offset + size <= elf->size); 169 if (offset + size > elf->size) { 170 ELFDBG(elf, "out of bounds: %"PRIu64" + %"PRIu16" = %"PRIu64"> %"PRIu64" (ELF size)\n", 171 offset, size, offset + size, elf->size); 172 return -1; 173 } 174 175 if (elf->changed == NULL) { 176 elf->changed = malloc(elf->size); 177 if (elf->changed == NULL) 178 return -errno; 179 memcpy(elf->changed, elf->memory, elf->size); 180 elf->memory = elf->changed; 181 ELFDBG(elf, "copied memory to allow writing.\n"); 182 } 183 184 p = elf->changed + offset; 185 if (elf->class & KMOD_ELF_MSB) { 186 for (i = 1; i <= size; i++) { 187 p[size - i] = value & 0xff; 188 value = (value & 0xffffffffffffff00) >> 8; 189 } 190 } else { 191 for (i = 0; i < size; i++) { 192 p[i] = value & 0xff; 193 value = (value & 0xffffffffffffff00) >> 8; 194 } 195 } 196 197 return 0; 198 } 199 200 static inline const void *elf_get_mem(const struct kmod_elf *elf, uint64_t offset) 201 { 202 assert(offset < elf->size); 203 if (offset >= elf->size) { 204 ELFDBG(elf, "out-of-bounds: %"PRIu64" >= %"PRIu64" (ELF size)\n", 205 offset, elf->size); 206 return NULL; 207 } 208 return elf->memory + offset; 209 } 210 211 static inline const void *elf_get_section_header(const struct kmod_elf *elf, uint16_t idx) 212 { 213 assert(idx != SHN_UNDEF); 214 assert(idx < elf->header.section.count); 215 if (idx == SHN_UNDEF || idx >= elf->header.section.count) { 216 ELFDBG(elf, "invalid section number: %"PRIu16", last=%"PRIu16"\n", 217 idx, elf->header.section.count); 218 return NULL; 219 } 220 return elf_get_mem(elf, elf->header.section.offset + 221 (uint64_t)(idx * elf->header.section.entry_size)); 222 } 223 224 static inline int elf_get_section_info(const struct kmod_elf *elf, uint16_t idx, uint64_t *offset, uint64_t *size, uint32_t *nameoff) 225 { 226 const uint8_t *p = elf_get_section_header(elf, idx); 227 uint64_t min_size, off = p - elf->memory; 228 229 if (p == NULL) { 230 ELFDBG(elf, "no section at %"PRIu16"\n", idx); 231 *offset = 0; 232 *size = 0; 233 *nameoff = 0; 234 return -EINVAL; 235 } 236 237 #define READV(field) \ 238 elf_get_uint(elf, off + offsetof(typeof(*hdr), field), sizeof(hdr->field)) 239 240 if (elf->class & KMOD_ELF_32) { 241 const Elf32_Shdr *hdr _unused_ = (const Elf32_Shdr *)p; 242 *size = READV(sh_size); 243 *offset = READV(sh_offset); 244 *nameoff = READV(sh_name); 245 } else { 246 const Elf64_Shdr *hdr _unused_ = (const Elf64_Shdr *)p; 247 *size = READV(sh_size); 248 *offset = READV(sh_offset); 249 *nameoff = READV(sh_name); 250 } 251 #undef READV 252 253 if (addu64_overflow(*offset, *size, &min_size) 254 || min_size > elf->size) { 255 ELFDBG(elf, "out-of-bounds: %"PRIu64" >= %"PRIu64" (ELF size)\n", 256 min_size, elf->size); 257 return -EINVAL; 258 } 259 260 ELFDBG(elf, "section=%"PRIu16" is: offset=%"PRIu64" size=%"PRIu64" nameoff=%"PRIu32"\n", 261 idx, *offset, *size, *nameoff); 262 263 return 0; 264 } 265 266 static const char *elf_get_strings_section(const struct kmod_elf *elf, uint64_t *size) 267 { 268 *size = elf->header.strings.size; 269 return elf_get_mem(elf, elf->header.strings.offset); 270 } 271 272 struct kmod_elf *kmod_elf_new(const void *memory, off_t size) 273 { 274 struct kmod_elf *elf; 275 uint64_t min_size; 276 size_t shdrs_size, shdr_size; 277 int class; 278 279 assert_cc(sizeof(uint16_t) == sizeof(Elf32_Half)); 280 assert_cc(sizeof(uint16_t) == sizeof(Elf64_Half)); 281 assert_cc(sizeof(uint32_t) == sizeof(Elf32_Word)); 282 assert_cc(sizeof(uint32_t) == sizeof(Elf64_Word)); 283 284 class = elf_identify(memory, size); 285 if (class < 0) { 286 errno = -class; 287 return NULL; 288 } 289 290 elf = malloc(sizeof(struct kmod_elf)); 291 if (elf == NULL) { 292 return NULL; 293 } 294 295 elf->memory = memory; 296 elf->changed = NULL; 297 elf->size = size; 298 elf->class = class; 299 300 #define READV(field) \ 301 elf_get_uint(elf, offsetof(typeof(*hdr), field), sizeof(hdr->field)) 302 303 #define LOAD_HEADER \ 304 elf->header.section.offset = READV(e_shoff); \ 305 elf->header.section.count = READV(e_shnum); \ 306 elf->header.section.entry_size = READV(e_shentsize); \ 307 elf->header.strings.section = READV(e_shstrndx); \ 308 elf->header.machine = READV(e_machine) 309 if (elf->class & KMOD_ELF_32) { 310 const Elf32_Ehdr *hdr _unused_ = elf_get_mem(elf, 0); 311 LOAD_HEADER; 312 shdr_size = sizeof(Elf32_Shdr); 313 } else { 314 const Elf64_Ehdr *hdr _unused_ = elf_get_mem(elf, 0); 315 LOAD_HEADER; 316 shdr_size = sizeof(Elf64_Shdr); 317 } 318 #undef LOAD_HEADER 319 #undef READV 320 321 ELFDBG(elf, "section: offset=%"PRIu64" count=%"PRIu16" entry_size=%"PRIu16" strings index=%"PRIu16"\n", 322 elf->header.section.offset, 323 elf->header.section.count, 324 elf->header.section.entry_size, 325 elf->header.strings.section); 326 327 if (elf->header.section.entry_size != shdr_size) { 328 ELFDBG(elf, "unexpected section entry size: %"PRIu16", expected %"PRIu16"\n", 329 elf->header.section.entry_size, shdr_size); 330 goto invalid; 331 } 332 shdrs_size = shdr_size * elf->header.section.count; 333 if (addu64_overflow(shdrs_size, elf->header.section.offset, &min_size) 334 || min_size > elf->size) { 335 ELFDBG(elf, "file is too short to hold sections\n"); 336 goto invalid; 337 } 338 339 if (elf_get_section_info(elf, elf->header.strings.section, 340 &elf->header.strings.offset, 341 &elf->header.strings.size, 342 &elf->header.strings.nameoff) < 0) { 343 ELFDBG(elf, "could not get strings section\n"); 344 goto invalid; 345 } else { 346 uint64_t slen; 347 const char *s = elf_get_strings_section(elf, &slen); 348 if (slen == 0 || s[slen - 1] != '\0') { 349 ELFDBG(elf, "strings section does not ends with \\0\n"); 350 goto invalid; 351 } 352 } 353 354 return elf; 355 356 invalid: 357 free(elf); 358 errno = EINVAL; 359 return NULL; 360 } 361 362 void kmod_elf_unref(struct kmod_elf *elf) 363 { 364 free(elf->changed); 365 free(elf); 366 } 367 368 const void *kmod_elf_get_memory(const struct kmod_elf *elf) 369 { 370 return elf->memory; 371 } 372 373 static int elf_find_section(const struct kmod_elf *elf, const char *section) 374 { 375 uint64_t nameslen; 376 const char *names = elf_get_strings_section(elf, &nameslen); 377 uint16_t i; 378 379 for (i = 1; i < elf->header.section.count; i++) { 380 uint64_t off, size; 381 uint32_t nameoff; 382 const char *n; 383 int err = elf_get_section_info(elf, i, &off, &size, &nameoff); 384 if (err < 0) 385 continue; 386 if (nameoff >= nameslen) 387 continue; 388 n = names + nameoff; 389 if (!streq(section, n)) 390 continue; 391 392 return i; 393 } 394 395 return -ENOENT; 396 } 397 398 int kmod_elf_get_section(const struct kmod_elf *elf, const char *section, const void **buf, uint64_t *buf_size) 399 { 400 uint64_t nameslen; 401 const char *names = elf_get_strings_section(elf, &nameslen); 402 uint16_t i; 403 404 *buf = NULL; 405 *buf_size = 0; 406 407 for (i = 1; i < elf->header.section.count; i++) { 408 uint64_t off, size; 409 uint32_t nameoff; 410 const char *n; 411 int err = elf_get_section_info(elf, i, &off, &size, &nameoff); 412 if (err < 0) 413 continue; 414 if (nameoff >= nameslen) 415 continue; 416 n = names + nameoff; 417 if (!streq(section, n)) 418 continue; 419 420 *buf = elf_get_mem(elf, off); 421 *buf_size = size; 422 return 0; 423 } 424 425 return -ENOENT; 426 } 427 428 /* array will be allocated with strings in a single malloc, just free *array */ 429 int kmod_elf_get_strings(const struct kmod_elf *elf, const char *section, char ***array) 430 { 431 size_t i, j, count; 432 uint64_t size; 433 const void *buf; 434 const char *strings; 435 char *s, **a; 436 int err; 437 438 *array = NULL; 439 440 err = kmod_elf_get_section(elf, section, &buf, &size); 441 if (err < 0) 442 return err; 443 444 strings = buf; 445 if (strings == NULL || size == 0) 446 return 0; 447 448 /* skip zero padding */ 449 while (strings[0] == '\0' && size > 1) { 450 strings++; 451 size--; 452 } 453 454 if (size <= 1) 455 return 0; 456 457 for (i = 0, count = 0; i < size; ) { 458 if (strings[i] != '\0') { 459 i++; 460 continue; 461 } 462 463 while (strings[i] == '\0' && i < size) 464 i++; 465 466 count++; 467 } 468 469 if (strings[i - 1] != '\0') 470 count++; 471 472 *array = a = malloc(size + 1 + sizeof(char *) * (count + 1)); 473 if (*array == NULL) 474 return -errno; 475 476 s = (char *)(a + count + 1); 477 memcpy(s, strings, size); 478 479 /* make sure the last string is NULL-terminated */ 480 s[size] = '\0'; 481 a[count] = NULL; 482 a[0] = s; 483 484 for (i = 0, j = 1; j < count && i < size; ) { 485 if (s[i] != '\0') { 486 i++; 487 continue; 488 } 489 490 while (strings[i] == '\0' && i < size) 491 i++; 492 493 a[j] = &s[i]; 494 j++; 495 } 496 497 return count; 498 } 499 500 /* array will be allocated with strings in a single malloc, just free *array */ 501 int kmod_elf_get_modversions(const struct kmod_elf *elf, struct kmod_modversion **array) 502 { 503 size_t off, offcrc, slen; 504 uint64_t size; 505 struct kmod_modversion *a; 506 const void *buf; 507 char *itr; 508 int i, count, err; 509 #define MODVERSION_SEC_SIZE (sizeof(struct kmod_modversion64)) 510 511 assert_cc(sizeof(struct kmod_modversion64) == 512 sizeof(struct kmod_modversion32)); 513 514 if (elf->class & KMOD_ELF_32) 515 offcrc = sizeof(uint32_t); 516 else 517 offcrc = sizeof(uint64_t); 518 519 *array = NULL; 520 521 err = kmod_elf_get_section(elf, "__versions", &buf, &size); 522 if (err < 0) 523 return err; 524 525 if (buf == NULL || size == 0) 526 return 0; 527 528 if (size % MODVERSION_SEC_SIZE != 0) 529 return -EINVAL; 530 531 count = size / MODVERSION_SEC_SIZE; 532 533 off = (const uint8_t *)buf - elf->memory; 534 slen = 0; 535 536 for (i = 0; i < count; i++, off += MODVERSION_SEC_SIZE) { 537 const char *symbol = elf_get_mem(elf, off + offcrc); 538 539 if (symbol[0] == '.') 540 symbol++; 541 542 slen += strlen(symbol) + 1; 543 } 544 545 *array = a = malloc(sizeof(struct kmod_modversion) * count + slen); 546 if (*array == NULL) 547 return -errno; 548 549 itr = (char *)(a + count); 550 off = (const uint8_t *)buf - elf->memory; 551 552 for (i = 0; i < count; i++, off += MODVERSION_SEC_SIZE) { 553 uint64_t crc = elf_get_uint(elf, off, offcrc); 554 const char *symbol = elf_get_mem(elf, off + offcrc); 555 size_t symbollen; 556 557 if (symbol[0] == '.') 558 symbol++; 559 560 a[i].crc = crc; 561 a[i].bind = KMOD_SYMBOL_UNDEF; 562 a[i].symbol = itr; 563 symbollen = strlen(symbol) + 1; 564 memcpy(itr, symbol, symbollen); 565 itr += symbollen; 566 } 567 568 return count; 569 } 570 571 int kmod_elf_strip_section(struct kmod_elf *elf, const char *section) 572 { 573 uint64_t off, size; 574 const void *buf; 575 int idx = elf_find_section(elf, section); 576 uint64_t val; 577 578 if (idx < 0) 579 return idx; 580 581 buf = elf_get_section_header(elf, idx); 582 off = (const uint8_t *)buf - elf->memory; 583 584 if (elf->class & KMOD_ELF_32) { 585 off += offsetof(Elf32_Shdr, sh_flags); 586 size = sizeof(((Elf32_Shdr *)buf)->sh_flags); 587 } else { 588 off += offsetof(Elf64_Shdr, sh_flags); 589 size = sizeof(((Elf64_Shdr *)buf)->sh_flags); 590 } 591 592 val = elf_get_uint(elf, off, size); 593 val &= ~(uint64_t)SHF_ALLOC; 594 595 return elf_set_uint(elf, off, size, val); 596 } 597 598 int kmod_elf_strip_vermagic(struct kmod_elf *elf) 599 { 600 uint64_t i, size; 601 const void *buf; 602 const char *strings; 603 int err; 604 605 err = kmod_elf_get_section(elf, ".modinfo", &buf, &size); 606 if (err < 0) 607 return err; 608 strings = buf; 609 if (strings == NULL || size == 0) 610 return 0; 611 612 /* skip zero padding */ 613 while (strings[0] == '\0' && size > 1) { 614 strings++; 615 size--; 616 } 617 if (size <= 1) 618 return 0; 619 620 for (i = 0; i < size; i++) { 621 const char *s; 622 size_t off, len; 623 624 if (strings[i] == '\0') 625 continue; 626 if (i + 1 >= size) 627 continue; 628 629 s = strings + i; 630 len = sizeof("vermagic=") - 1; 631 if (i + len >= size) 632 continue; 633 if (strncmp(s, "vermagic=", len) != 0) { 634 i += strlen(s); 635 continue; 636 } 637 off = (const uint8_t *)s - elf->memory; 638 639 if (elf->changed == NULL) { 640 elf->changed = malloc(elf->size); 641 if (elf->changed == NULL) 642 return -errno; 643 memcpy(elf->changed, elf->memory, elf->size); 644 elf->memory = elf->changed; 645 ELFDBG(elf, "copied memory to allow writing.\n"); 646 } 647 648 len = strlen(s); 649 ELFDBG(elf, "clear .modinfo vermagic \"%s\" (%zd bytes)\n", 650 s, len); 651 memset(elf->changed + off, '\0', len); 652 return 0; 653 } 654 655 ELFDBG(elf, "no vermagic found in .modinfo\n"); 656 return -ENOENT; 657 } 658 659 660 static int kmod_elf_get_symbols_symtab(const struct kmod_elf *elf, struct kmod_modversion **array) 661 { 662 uint64_t i, last, size; 663 const void *buf; 664 const char *strings; 665 char *itr; 666 struct kmod_modversion *a; 667 int count, err; 668 669 *array = NULL; 670 671 err = kmod_elf_get_section(elf, "__ksymtab_strings", &buf, &size); 672 if (err < 0) 673 return err; 674 strings = buf; 675 if (strings == NULL || size == 0) 676 return 0; 677 678 /* skip zero padding */ 679 while (strings[0] == '\0' && size > 1) { 680 strings++; 681 size--; 682 } 683 if (size <= 1) 684 return 0; 685 686 last = 0; 687 for (i = 0, count = 0; i < size; i++) { 688 if (strings[i] == '\0') { 689 if (last == i) { 690 last = i + 1; 691 continue; 692 } 693 count++; 694 last = i + 1; 695 } 696 } 697 if (strings[i - 1] != '\0') 698 count++; 699 700 *array = a = malloc(size + 1 + sizeof(struct kmod_modversion) * count); 701 if (*array == NULL) 702 return -errno; 703 704 itr = (char *)(a + count); 705 last = 0; 706 for (i = 0, count = 0; i < size; i++) { 707 if (strings[i] == '\0') { 708 size_t slen = i - last; 709 if (last == i) { 710 last = i + 1; 711 continue; 712 } 713 a[count].crc = 0; 714 a[count].bind = KMOD_SYMBOL_GLOBAL; 715 a[count].symbol = itr; 716 memcpy(itr, strings + last, slen); 717 itr[slen] = '\0'; 718 itr += slen + 1; 719 count++; 720 last = i + 1; 721 } 722 } 723 if (strings[i - 1] != '\0') { 724 size_t slen = i - last; 725 a[count].crc = 0; 726 a[count].bind = KMOD_SYMBOL_GLOBAL; 727 a[count].symbol = itr; 728 memcpy(itr, strings + last, slen); 729 itr[slen] = '\0'; 730 count++; 731 } 732 733 return count; 734 } 735 736 static inline uint8_t kmod_symbol_bind_from_elf(uint8_t elf_value) 737 { 738 switch (elf_value) { 739 case STB_LOCAL: 740 return KMOD_SYMBOL_LOCAL; 741 case STB_GLOBAL: 742 return KMOD_SYMBOL_GLOBAL; 743 case STB_WEAK: 744 return KMOD_SYMBOL_WEAK; 745 default: 746 return KMOD_SYMBOL_NONE; 747 } 748 } 749 750 static uint64_t kmod_elf_resolve_crc(const struct kmod_elf *elf, uint64_t crc, uint16_t shndx) 751 { 752 int err; 753 uint64_t off, size; 754 uint32_t nameoff; 755 756 if (shndx == SHN_ABS || shndx == SHN_UNDEF) 757 return crc; 758 759 err = elf_get_section_info(elf, shndx, &off, &size, &nameoff); 760 if (err < 0) { 761 ELFDBG("Cound not find section index %"PRIu16" for crc", shndx); 762 return (uint64_t)-1; 763 } 764 765 if (crc > (size - sizeof(uint32_t))) { 766 ELFDBG("CRC offset %"PRIu64" is too big, section %"PRIu16" size is %"PRIu64"\n", 767 crc, shndx, size); 768 return (uint64_t)-1; 769 } 770 771 crc = elf_get_uint(elf, off + crc, sizeof(uint32_t)); 772 return crc; 773 } 774 775 /* array will be allocated with strings in a single malloc, just free *array */ 776 int kmod_elf_get_symbols(const struct kmod_elf *elf, struct kmod_modversion **array) 777 { 778 static const char crc_str[] = "__crc_"; 779 static const size_t crc_strlen = sizeof(crc_str) - 1; 780 uint64_t strtablen, symtablen, str_off, sym_off; 781 const void *strtab, *symtab; 782 struct kmod_modversion *a; 783 char *itr; 784 size_t slen, symlen; 785 int i, count, symcount, err; 786 787 err = kmod_elf_get_section(elf, ".strtab", &strtab, &strtablen); 788 if (err < 0) { 789 ELFDBG(elf, "no .strtab found.\n"); 790 goto fallback; 791 } 792 793 err = kmod_elf_get_section(elf, ".symtab", &symtab, &symtablen); 794 if (err < 0) { 795 ELFDBG(elf, "no .symtab found.\n"); 796 goto fallback; 797 } 798 799 if (elf->class & KMOD_ELF_32) 800 symlen = sizeof(Elf32_Sym); 801 else 802 symlen = sizeof(Elf64_Sym); 803 804 if (symtablen % symlen != 0) { 805 ELFDBG(elf, "unexpected .symtab of length %"PRIu64", not multiple of %"PRIu64" as expected.\n", symtablen, symlen); 806 goto fallback; 807 } 808 809 symcount = symtablen / symlen; 810 count = 0; 811 slen = 0; 812 str_off = (const uint8_t *)strtab - elf->memory; 813 sym_off = (const uint8_t *)symtab - elf->memory + symlen; 814 for (i = 1; i < symcount; i++, sym_off += symlen) { 815 const char *name; 816 uint32_t name_off; 817 818 #define READV(field) \ 819 elf_get_uint(elf, sym_off + offsetof(typeof(*s), field),\ 820 sizeof(s->field)) 821 if (elf->class & KMOD_ELF_32) { 822 Elf32_Sym *s; 823 name_off = READV(st_name); 824 } else { 825 Elf64_Sym *s; 826 name_off = READV(st_name); 827 } 828 #undef READV 829 if (name_off >= strtablen) { 830 ELFDBG(elf, ".strtab is %"PRIu64" bytes, but .symtab entry %d wants to access offset %"PRIu32".\n", strtablen, i, name_off); 831 goto fallback; 832 } 833 834 name = elf_get_mem(elf, str_off + name_off); 835 836 if (strncmp(name, crc_str, crc_strlen) != 0) 837 continue; 838 slen += strlen(name + crc_strlen) + 1; 839 count++; 840 } 841 842 if (count == 0) 843 goto fallback; 844 845 *array = a = malloc(sizeof(struct kmod_modversion) * count + slen); 846 if (*array == NULL) 847 return -errno; 848 849 itr = (char *)(a + count); 850 count = 0; 851 str_off = (const uint8_t *)strtab - elf->memory; 852 sym_off = (const uint8_t *)symtab - elf->memory + symlen; 853 for (i = 1; i < symcount; i++, sym_off += symlen) { 854 const char *name; 855 uint32_t name_off; 856 uint64_t crc; 857 uint8_t info, bind; 858 uint16_t shndx; 859 860 #define READV(field) \ 861 elf_get_uint(elf, sym_off + offsetof(typeof(*s), field),\ 862 sizeof(s->field)) 863 if (elf->class & KMOD_ELF_32) { 864 Elf32_Sym *s; 865 name_off = READV(st_name); 866 crc = READV(st_value); 867 info = READV(st_info); 868 shndx = READV(st_shndx); 869 } else { 870 Elf64_Sym *s; 871 name_off = READV(st_name); 872 crc = READV(st_value); 873 info = READV(st_info); 874 shndx = READV(st_shndx); 875 } 876 #undef READV 877 name = elf_get_mem(elf, str_off + name_off); 878 if (strncmp(name, crc_str, crc_strlen) != 0) 879 continue; 880 name += crc_strlen; 881 882 if (elf->class & KMOD_ELF_32) 883 bind = ELF32_ST_BIND(info); 884 else 885 bind = ELF64_ST_BIND(info); 886 887 a[count].crc = kmod_elf_resolve_crc(elf, crc, shndx); 888 a[count].bind = kmod_symbol_bind_from_elf(bind); 889 a[count].symbol = itr; 890 slen = strlen(name); 891 memcpy(itr, name, slen); 892 itr[slen] = '\0'; 893 itr += slen + 1; 894 count++; 895 } 896 return count; 897 898 fallback: 899 ELFDBG(elf, "Falling back to __ksymtab_strings!\n"); 900 return kmod_elf_get_symbols_symtab(elf, array); 901 } 902 903 static int kmod_elf_crc_find(const struct kmod_elf *elf, const void *versions, uint64_t versionslen, const char *name, uint64_t *crc) 904 { 905 size_t verlen, crclen, off; 906 uint64_t i; 907 908 if (elf->class & KMOD_ELF_32) { 909 struct kmod_modversion32 *mv; 910 verlen = sizeof(*mv); 911 crclen = sizeof(mv->crc); 912 } else { 913 struct kmod_modversion64 *mv; 914 verlen = sizeof(*mv); 915 crclen = sizeof(mv->crc); 916 } 917 918 off = (const uint8_t *)versions - elf->memory; 919 for (i = 0; i < versionslen; i += verlen) { 920 const char *symbol = elf_get_mem(elf, off + i + crclen); 921 if (!streq(name, symbol)) 922 continue; 923 *crc = elf_get_uint(elf, off + i, crclen); 924 return i / verlen; 925 } 926 927 ELFDBG(elf, "could not find crc for symbol '%s'\n", name); 928 *crc = 0; 929 return -1; 930 } 931 932 /* from module-init-tools:elfops_core.c */ 933 #ifndef STT_REGISTER 934 #define STT_REGISTER 13 /* Global register reserved to app. */ 935 #endif 936 937 /* array will be allocated with strings in a single malloc, just free *array */ 938 int kmod_elf_get_dependency_symbols(const struct kmod_elf *elf, struct kmod_modversion **array) 939 { 940 uint64_t versionslen, strtablen, symtablen, str_off, sym_off, ver_off; 941 const void *versions, *strtab, *symtab; 942 struct kmod_modversion *a; 943 char *itr; 944 size_t slen, verlen, symlen, crclen; 945 int i, count, symcount, vercount, err; 946 bool handle_register_symbols; 947 uint8_t *visited_versions; 948 uint64_t *symcrcs; 949 950 err = kmod_elf_get_section(elf, "__versions", &versions, &versionslen); 951 if (err < 0) { 952 versions = NULL; 953 versionslen = 0; 954 verlen = 0; 955 crclen = 0; 956 } else { 957 if (elf->class & KMOD_ELF_32) { 958 struct kmod_modversion32 *mv; 959 verlen = sizeof(*mv); 960 crclen = sizeof(mv->crc); 961 } else { 962 struct kmod_modversion64 *mv; 963 verlen = sizeof(*mv); 964 crclen = sizeof(mv->crc); 965 } 966 if (versionslen % verlen != 0) { 967 ELFDBG(elf, "unexpected __versions of length %"PRIu64", not multiple of %zd as expected.\n", versionslen, verlen); 968 versions = NULL; 969 versionslen = 0; 970 } 971 } 972 973 err = kmod_elf_get_section(elf, ".strtab", &strtab, &strtablen); 974 if (err < 0) { 975 ELFDBG(elf, "no .strtab found.\n"); 976 return -EINVAL; 977 } 978 979 err = kmod_elf_get_section(elf, ".symtab", &symtab, &symtablen); 980 if (err < 0) { 981 ELFDBG(elf, "no .symtab found.\n"); 982 return -EINVAL; 983 } 984 985 if (elf->class & KMOD_ELF_32) 986 symlen = sizeof(Elf32_Sym); 987 else 988 symlen = sizeof(Elf64_Sym); 989 990 if (symtablen % symlen != 0) { 991 ELFDBG(elf, "unexpected .symtab of length %"PRIu64", not multiple of %"PRIu64" as expected.\n", symtablen, symlen); 992 return -EINVAL; 993 } 994 995 if (versionslen == 0) { 996 vercount = 0; 997 visited_versions = NULL; 998 } else { 999 vercount = versionslen / verlen; 1000 visited_versions = calloc(vercount, sizeof(uint8_t)); 1001 if (visited_versions == NULL) 1002 return -ENOMEM; 1003 } 1004 1005 handle_register_symbols = (elf->header.machine == EM_SPARC || 1006 elf->header.machine == EM_SPARCV9); 1007 1008 symcount = symtablen / symlen; 1009 count = 0; 1010 slen = 0; 1011 str_off = (const uint8_t *)strtab - elf->memory; 1012 sym_off = (const uint8_t *)symtab - elf->memory + symlen; 1013 1014 symcrcs = calloc(symcount, sizeof(uint64_t)); 1015 if (symcrcs == NULL) { 1016 free(visited_versions); 1017 return -ENOMEM; 1018 } 1019 1020 for (i = 1; i < symcount; i++, sym_off += symlen) { 1021 const char *name; 1022 uint64_t crc; 1023 uint32_t name_off; 1024 uint16_t secidx; 1025 uint8_t info; 1026 int idx; 1027 1028 #define READV(field) \ 1029 elf_get_uint(elf, sym_off + offsetof(typeof(*s), field),\ 1030 sizeof(s->field)) 1031 if (elf->class & KMOD_ELF_32) { 1032 Elf32_Sym *s; 1033 name_off = READV(st_name); 1034 secidx = READV(st_shndx); 1035 info = READV(st_info); 1036 } else { 1037 Elf64_Sym *s; 1038 name_off = READV(st_name); 1039 secidx = READV(st_shndx); 1040 info = READV(st_info); 1041 } 1042 #undef READV 1043 if (secidx != SHN_UNDEF) 1044 continue; 1045 1046 if (handle_register_symbols) { 1047 uint8_t type; 1048 if (elf->class & KMOD_ELF_32) 1049 type = ELF32_ST_TYPE(info); 1050 else 1051 type = ELF64_ST_TYPE(info); 1052 1053 /* Not really undefined: sparc gcc 3.3 creates 1054 * U references when you have global asm 1055 * variables, to avoid anyone else misusing 1056 * them. 1057 */ 1058 if (type == STT_REGISTER) 1059 continue; 1060 } 1061 1062 if (name_off >= strtablen) { 1063 ELFDBG(elf, ".strtab is %"PRIu64" bytes, but .symtab entry %d wants to access offset %"PRIu32".\n", strtablen, i, name_off); 1064 free(visited_versions); 1065 free(symcrcs); 1066 return -EINVAL; 1067 } 1068 1069 name = elf_get_mem(elf, str_off + name_off); 1070 if (name[0] == '\0') { 1071 ELFDBG(elf, "empty symbol name at index %"PRIu64"\n", i); 1072 continue; 1073 } 1074 1075 slen += strlen(name) + 1; 1076 count++; 1077 1078 idx = kmod_elf_crc_find(elf, versions, versionslen, name, &crc); 1079 if (idx >= 0 && visited_versions != NULL) 1080 visited_versions[idx] = 1; 1081 symcrcs[i] = crc; 1082 } 1083 1084 if (visited_versions != NULL) { 1085 /* module_layout/struct_module are not visited, but needed */ 1086 ver_off = (const uint8_t *)versions - elf->memory; 1087 for (i = 0; i < vercount; i++) { 1088 if (visited_versions[i] == 0) { 1089 const char *name; 1090 name = elf_get_mem(elf, ver_off + i * verlen + crclen); 1091 slen += strlen(name) + 1; 1092 1093 count++; 1094 } 1095 } 1096 } 1097 1098 if (count == 0) { 1099 free(visited_versions); 1100 free(symcrcs); 1101 *array = NULL; 1102 return 0; 1103 } 1104 1105 *array = a = malloc(sizeof(struct kmod_modversion) * count + slen); 1106 if (*array == NULL) { 1107 free(visited_versions); 1108 free(symcrcs); 1109 return -errno; 1110 } 1111 1112 itr = (char *)(a + count); 1113 count = 0; 1114 str_off = (const uint8_t *)strtab - elf->memory; 1115 sym_off = (const uint8_t *)symtab - elf->memory + symlen; 1116 for (i = 1; i < symcount; i++, sym_off += symlen) { 1117 const char *name; 1118 uint64_t crc; 1119 uint32_t name_off; 1120 uint16_t secidx; 1121 uint8_t info, bind; 1122 1123 #define READV(field) \ 1124 elf_get_uint(elf, sym_off + offsetof(typeof(*s), field),\ 1125 sizeof(s->field)) 1126 if (elf->class & KMOD_ELF_32) { 1127 Elf32_Sym *s; 1128 name_off = READV(st_name); 1129 secidx = READV(st_shndx); 1130 info = READV(st_info); 1131 } else { 1132 Elf64_Sym *s; 1133 name_off = READV(st_name); 1134 secidx = READV(st_shndx); 1135 info = READV(st_info); 1136 } 1137 #undef READV 1138 if (secidx != SHN_UNDEF) 1139 continue; 1140 1141 if (handle_register_symbols) { 1142 uint8_t type; 1143 if (elf->class & KMOD_ELF_32) 1144 type = ELF32_ST_TYPE(info); 1145 else 1146 type = ELF64_ST_TYPE(info); 1147 1148 /* Not really undefined: sparc gcc 3.3 creates 1149 * U references when you have global asm 1150 * variables, to avoid anyone else misusing 1151 * them. 1152 */ 1153 if (type == STT_REGISTER) 1154 continue; 1155 } 1156 1157 name = elf_get_mem(elf, str_off + name_off); 1158 if (name[0] == '\0') { 1159 ELFDBG(elf, "empty symbol name at index %"PRIu64"\n", i); 1160 continue; 1161 } 1162 1163 if (elf->class & KMOD_ELF_32) 1164 bind = ELF32_ST_BIND(info); 1165 else 1166 bind = ELF64_ST_BIND(info); 1167 if (bind == STB_WEAK) 1168 bind = KMOD_SYMBOL_WEAK; 1169 else 1170 bind = KMOD_SYMBOL_UNDEF; 1171 1172 slen = strlen(name); 1173 crc = symcrcs[i]; 1174 1175 a[count].crc = crc; 1176 a[count].bind = bind; 1177 a[count].symbol = itr; 1178 memcpy(itr, name, slen); 1179 itr[slen] = '\0'; 1180 itr += slen + 1; 1181 1182 count++; 1183 } 1184 1185 free(symcrcs); 1186 1187 if (visited_versions == NULL) 1188 return count; 1189 1190 /* add unvisited (module_layout/struct_module) */ 1191 ver_off = (const uint8_t *)versions - elf->memory; 1192 for (i = 0; i < vercount; i++) { 1193 const char *name; 1194 uint64_t crc; 1195 1196 if (visited_versions[i] != 0) 1197 continue; 1198 1199 name = elf_get_mem(elf, ver_off + i * verlen + crclen); 1200 slen = strlen(name); 1201 crc = elf_get_uint(elf, ver_off + i * verlen, crclen); 1202 1203 a[count].crc = crc; 1204 a[count].bind = KMOD_SYMBOL_UNDEF; 1205 a[count].symbol = itr; 1206 memcpy(itr, name, slen); 1207 itr[slen] = '\0'; 1208 itr += slen + 1; 1209 1210 count++; 1211 } 1212 free(visited_versions); 1213 return count; 1214 } 1215
