Lines Matching refs:image
103 static elf_sym *elf_find_symbol(struct elf_image_info *image, const char *name,
108 unregister_elf_image(struct elf_image_info *image)
110 unregister_image(team_get_kernel_team(), image->id);
111 sImagesHash->Remove(image);
116 register_elf_image(struct elf_image_info *image)
121 imageInfo.basic_info.id = image->id;
123 strlcpy(imageInfo.basic_info.name, image->name,
126 imageInfo.basic_info.text = (void *)image->text_region.start;
127 imageInfo.basic_info.text_size = image->text_region.size;
128 imageInfo.basic_info.data = (void *)image->data_region.start;
129 imageInfo.basic_info.data_size = image->data_region.size;
131 if (image->text_region.id >= 0) {
136 elf_sym* symbol = elf_find_symbol(image,
142 addr_t symbolAddress = symbol->st_value + image->text_region.delta;
143 if (symbolAddress >= image->text_region.start
144 && symbolAddress - image->text_region.start + sizeof(uint32)
145 <= image->text_region.size) {
152 symbol = elf_find_symbol(image,
158 addr_t symbolAddress = symbol->st_value + image->text_region.delta;
159 if (symbolAddress >= image->text_region.start
160 && symbolAddress - image->text_region.start + sizeof(uint32)
161 <= image->text_region.size) {
166 // in-memory image -- use the current values
171 image->id = register_image(team_get_kernel_team(), &imageInfo,
173 sImagesHash->Insert(image);
177 /*! Note, you must lock the image mutex when you call this function. */
188 // get image that may contain the address
191 struct elf_image_info* image = iterator.Next();
192 if ((address >= image->text_region.start && address
193 <= (image->text_region.start + image->text_region.size))
194 || (address >= image->data_region.start
196 <= (image->data_region.start + image->data_region.size)))
197 return image;
233 kprintf("There is no image loaded at this address!\n");
253 struct elf_image_info* image = iterator.Next();
254 if (image->vnode == vnode)
255 return image;
268 struct elf_image_info *image
270 if (image == NULL)
273 memset(image, 0, sizeof(struct elf_image_info));
275 image->text_region.id = -1;
276 image->data_region.id = -1;
277 image->ref_count = 1;
279 return image;
284 delete_elf_image(struct elf_image_info *image)
286 if (image->text_region.id >= 0)
287 delete_area(image->text_region.id);
289 if (image->data_region.id >= 0)
290 delete_area(image->data_region.id);
292 if (image->vnode)
293 vfs_put_vnode(image->vnode);
295 free(image->versions);
296 free(image->debug_symbols);
297 free((void*)image->debug_string_table);
298 free(image->elf_header);
299 free(image->name);
300 free(image);
364 struct elf_image_info *image = NULL;
371 image = iterator.Next();
372 if (image->num_debug_symbols > 0) {
374 for (uint32 i = 0; i < image->num_debug_symbols; i++) {
375 elf_sym *symbol = &image->debug_symbols[i];
376 const char *name = image->debug_string_table + symbol->st_name;
380 = (void*)(symbol->st_value + image->text_region.delta);
382 image->name, name);
387 for (uint32 i = 0; i < HASHTABSIZE(image); i++) {
388 for (uint32 j = HASHBUCKETS(image)[i]; j != STN_UNDEF;
389 j = HASHCHAINS(image)[j]) {
390 elf_sym *symbol = &image->syms[j];
391 const char *name = SYMNAME(image, symbol);
395 + image->text_region.delta);
397 symbol->st_size, image->name, name);
414 struct elf_image_info *image = NULL;
423 // find image at address
431 image = current;
436 if (image == NULL) {
437 kprintf("No image covers %#" B_PRIxADDR " in the kernel!\n",
441 image = sImagesHash->Lookup(num);
442 if (image == NULL) {
443 kprintf("image %#" B_PRIxADDR " doesn't exist in the "
448 // look for image by name
453 image = current;
458 if (image == NULL)
459 kprintf("No image \"%s\" found in kernel!\n", argv[1]);
466 if (image == NULL)
471 kprintf("Symbols of image %" B_PRId32 " \"%s\":\n", image->id, image->name);
474 if (image->num_debug_symbols > 0) {
476 for (i = 0; i < image->num_debug_symbols; i++) {
477 elf_sym *symbol = &image->debug_symbols[i];
480 >= image->text_region.size + image->data_region.size)
484 symbol->st_value + image->text_region.delta,
486 symbol->st_size, image->debug_string_table + symbol->st_name);
492 for (i = 0; i < HASHTABSIZE(image); i++) {
493 for (j = HASHBUCKETS(image)[i]; j != STN_UNDEF;
494 j = HASHCHAINS(image)[j]) {
495 elf_sym *symbol = &image->syms[j];
498 >= image->text_region.size + image->data_region.size)
502 symbol->st_value + image->text_region.delta,
505 symbol->st_size, SYMNAME(image, symbol));
525 dump_image_info(struct elf_image_info *image)
527 kprintf("elf_image_info at %p:\n", image);
528 kprintf(" next %p\n", image->next);
529 kprintf(" id %" B_PRId32 "\n", image->id);
530 dump_elf_region(&image->text_region, "text");
531 dump_elf_region(&image->data_region, "data");
532 kprintf(" dynamic_section %#" B_PRIxADDR "\n", image->dynamic_section);
533 kprintf(" needed %p\n", image->needed);
534 kprintf(" symhash %p\n", image->symhash);
535 kprintf(" syms %p\n", image->syms);
536 kprintf(" strtab %p\n", image->strtab);
537 kprintf(" rel %p\n", image->rel);
538 kprintf(" rel_len %#x\n", image->rel_len);
539 kprintf(" rela %p\n", image->rela);
540 kprintf(" rela_len %#x\n", image->rela_len);
541 kprintf(" pltrel %p\n", image->pltrel);
542 kprintf(" pltrel_len %#x\n", image->pltrel_len);
545 image->debug_symbols, image->num_debug_symbols);
552 struct elf_image_info *image;
562 image = sImagesHash->Lookup(num);
563 if (image == NULL) {
564 kprintf("image %#" B_PRIxADDR " doesn't exist in the kernel!\n",
567 dump_image_info(image);
577 image = iterator.Next();
578 kprintf("%p (%" B_PRId32 ") %s\n", image, image->id, image->name);
587 void dump_symbol(struct elf_image_info *image, elf_sym *sym)
590 kprintf("symbol at %p, in image %p\n", sym, image);
592 kprintf(" name index %d, '%s'\n", sym->st_name, SYMNAME(image, sym));
606 elf_find_symbol(struct elf_image_info *image, const char *name,
609 if (image->dynamic_section == 0 || HASHTABSIZE(image) == 0)
615 uint32 hash = elf_hash(name) % HASHTABSIZE(image);
616 for (uint32 i = HASHBUCKETS(image)[hash]; i != STN_UNDEF;
617 i = HASHCHAINS(image)[i]) {
618 elf_sym* symbol = &image->syms[i];
623 || strcmp(SYMNAME(image, symbol), name) != 0) {
629 // Handle the simple cases -- the image doesn't have version
631 if (image->symbol_versions == NULL) {
646 // The image has version information. Let's see what we've got.
647 uint32 versionID = image->symbol_versions[i];
649 elf_version_info& version = image->versions[versionIndex];
677 // No specific version requested, but the image has version
714 elf_parse_dynamic_section(struct elf_image_info *image)
721 image->symhash = 0;
722 image->syms = 0;
723 image->strtab = 0;
725 d = (elf_dyn *)image->dynamic_section;
732 neededOffset = d[i].d_un.d_ptr + image->text_region.delta;
735 image->symhash = (uint32 *)(d[i].d_un.d_ptr
736 + image->text_region.delta);
739 image->strtab = (char *)(d[i].d_un.d_ptr
740 + image->text_region.delta);
743 image->syms = (elf_sym *)(d[i].d_un.d_ptr
744 + image->text_region.delta);
747 image->rel = (elf_rel *)(d[i].d_un.d_ptr
748 + image->text_region.delta);
751 image->rel_len = d[i].d_un.d_val;
754 image->rela = (elf_rela *)(d[i].d_un.d_ptr
755 + image->text_region.delta);
758 image->rela_len = d[i].d_un.d_val;
761 image->pltrel = (elf_rel *)(d[i].d_un.d_ptr
762 + image->text_region.delta);
765 image->pltrel_len = d[i].d_un.d_val;
768 image->pltrel_type = d[i].d_un.d_val;
771 image->symbol_versions = (elf_versym*)
772 (d[i].d_un.d_ptr + image->text_region.delta);
775 image->version_definitions = (elf_verdef*)
776 (d[i].d_un.d_ptr + image->text_region.delta);
779 image->num_version_definitions = d[i].d_un.d_val;
782 image->needed_versions = (elf_verneed*)
783 (d[i].d_un.d_ptr + image->text_region.delta);
786 image->num_needed_versions = d[i].d_un.d_val;
789 image->symbolic = true;
795 image->symbolic = true;
805 if (!image->symhash || !image->syms || !image->strtab)
811 image->needed = STRING(image, neededOffset);
822 elf_image_info* image, const elf_version_info& neededVersion, bool weak)
824 // If the image doesn't have version definitions, we print a warning and
827 if (image->version_definitions == NULL) {
829 image->name, dependentImage->name);
834 BytePointer<elf_verdef> definition(image->version_definitions);
835 for (uint32 i = 0; i < image->num_version_definitions; i++) {
837 elf_version_info& info = image->versions[versionIndex];
849 dprintf("%s: version \"%s\" not found (required by %s)\n", image->name,
859 init_image_version_infos(elf_image_info* image)
866 if (image->version_definitions != NULL) {
867 BytePointer<elf_verdef> definition(image->version_definitions);
868 for (uint32 i = 0; i < image->num_version_definitions; i++) {
883 if (image->needed_versions != NULL) {
884 BytePointer<elf_verneed> needed(image->needed_versions);
885 for (uint32 i = 0; i < image->num_needed_versions; i++) {
909 image->versions
911 if (image->versions == NULL) {
915 image->num_versions = maxIndex + 1;
920 if (image->version_definitions != NULL) {
921 BytePointer<elf_verdef> definition(image->version_definitions);
922 for (uint32 i = 0; i < image->num_version_definitions; i++) {
929 elf_version_info& info = image->versions[versionIndex];
931 info.name = STRING(image, verdaux->vda_name);
940 if (image->needed_versions != NULL) {
941 BytePointer<elf_verneed> needed(image->needed_versions);
942 for (uint32 i = 0; i < image->num_needed_versions; i++) {
943 const char* fileName = STRING(image, needed->vn_file);
948 elf_version_info& info = image->versions[versionIndex];
950 info.name = STRING(image, vernaux->vna_name);
965 check_needed_image_versions(elf_image_info* image)
967 if (image->needed_versions == NULL)
970 BytePointer<elf_verneed> needed(image->needed_versions);
971 for (uint32 i = 0; i < image->num_needed_versions; i++) {
977 elf_version_info& info = image->versions[versionIndex];
979 status_t error = assert_defined_image_version(image, dependency,
1001 elf_resolve_symbol(struct elf_image_info *image, elf_sym *symbol,
1006 *_symbolAddress = symbol->st_value + image->text_region.delta;
1010 // Non-local symbols we try to resolve to the kernel image first. Unless
1011 // the image is linked symbolically, then vice versa.
1013 elf_image_info* secondImage = image;
1014 if (image->symbolic)
1017 const char *symbolName = SYMNAME(image, symbol);
1021 if (image->symbol_versions != NULL) {
1022 uint32 index = symbol - image->syms;
1023 uint32 versionIndex = VER_NDX(image->symbol_versions[index]);
1025 versionInfo = image->versions + versionIndex;
1035 // image.
1055 dprintf("\"%s\": could not resolve symbol '%s'\n", image->name,
1062 dprintf("elf_resolve_symbol: found symbol '%s' in image '%s' "
1063 "(requested by image '%s') but wrong type (%d vs. %d)\n",
1064 symbolName, foundImage->name, image->name,
1076 elf_relocate(struct elf_image_info* image, struct elf_image_info* resolveImage)
1080 TRACE(("elf_relocate(%p (\"%s\"))\n", image, image->name));
1083 if (image->rel) {
1084 TRACE(("total %i rel relocs\n", image->rel_len / (int)sizeof(elf_rel)));
1086 status = arch_elf_relocate_rel(image, resolveImage, image->rel,
1087 image->rel_len);
1092 if (image->pltrel) {
1093 if (image->pltrel_type == DT_REL) {
1095 image->pltrel_len / (int)sizeof(elf_rel)));
1096 status = arch_elf_relocate_rel(image, resolveImage, image->pltrel,
1097 image->pltrel_len);
1100 image->pltrel_len / (int)sizeof(elf_rela)));
1101 status = arch_elf_relocate_rela(image, resolveImage,
1102 (elf_rela *)image->pltrel, image->pltrel_len);
1108 if (image->rela) {
1110 image->rela_len / (int)sizeof(elf_rela)));
1112 status = arch_elf_relocate_rela(image, resolveImage, image->rela,
1113 image->rela_len);
1145 unload_elf_image(struct elf_image_info *image)
1147 if (atomic_add(&image->ref_count, -1) > 1)
1150 TRACE(("unload image %" B_PRId32 ", %s\n", image->id, image->name));
1152 unregister_elf_image(image);
1153 delete_elf_image(image);
1158 load_elf_symbol_table(int fd, struct elf_image_info *image)
1160 elf_ehdr *elfHeader = image->elf_header;
1241 // insert tables into image
1242 image->debug_symbols = symbolTable;
1243 image->num_debug_symbols = numSymbols;
1244 image->debug_string_table = stringTable;
1269 elf_image_info *image = create_image_struct();
1270 if (image == NULL)
1273 image->name = strdup(preloadedImage->name);
1274 image->dynamic_section = preloadedImage->dynamic_section.start;
1276 image->text_region.id = preloadedImage->text_region.id;
1277 image->text_region.start = preloadedImage->text_region.start;
1278 image->text_region.size = preloadedImage->text_region.size;
1279 image->text_region.delta = preloadedImage->text_region.delta;
1280 image->data_region.id = preloadedImage->data_region.id;
1281 image->data_region.start = preloadedImage->data_region.start;
1282 image->data_region.size = preloadedImage->data_region.size;
1283 image->data_region.delta = preloadedImage->data_region.delta;
1285 status = elf_parse_dynamic_section(image);
1289 status = init_image_version_infos(image);
1294 status = check_needed_image_versions(image);
1298 status = elf_relocate(image, sKernelImage);
1302 sKernelImage = image;
1308 image->debug_symbols = (elf_sym*)malloc(debugSymbolsSize);
1309 if (image->debug_symbols != NULL) {
1310 memcpy(image->debug_symbols, preloadedImage->debug_symbols,
1314 image->num_debug_symbols = preloadedImage->num_debug_symbols;
1318 image->debug_string_table = (char*)malloc(
1320 if (image->debug_string_table != NULL) {
1321 memcpy((void*)image->debug_string_table,
1327 register_elf_image(image);
1328 preloadedImage->id = image->id;
1332 set_area_protection(image->text_region.id,
1338 delete_elf_image(image);
1390 // get the image for the address
1391 image_t image;
1392 status_t error = _FindImageAtAddress(address, image);
1410 strlcpy(fImageName, image.name, sizeof(fImageName));
1414 if (!_Read(image.symhash, hashTabSize))
1418 const uint32* hashBuckets = image.symhash + 2;
1419 const uint32* hashChains = image.symhash + 2 + hashTabSize;
1421 const elf_region_t& textRegion = image.regions[0];
1423 // search the image for the symbol
1441 if (!_Read(image.syms + j, symbol))
1484 if (_ReadString(image, symbolFound.st_name, fSymbolName,
1507 status_t _FindImageAtAddress(addr_t address, image_t& image)
1515 if (!_Read(imageAddress, image))
1518 if (image.regions[0].vmstart <= address
1519 && address < image.regions[0].vmstart + image.regions[0].size) {
1523 imageAddress = image.next;
1529 bool _ReadString(const image_t& image, uint32 offset, char* buffer,
1532 const char* address = image.strtab + offset;
1580 struct elf_image_info *image;
1588 image = find_image(id);
1589 if (image == NULL) {
1594 symbol = elf_find_symbol(image, name, NULL, true);
1603 symbol->st_value + image->text_region.delta,
1604 symbol->st_value, image->text_region.delta));
1606 *_symbol = (void *)(symbol->st_value + image->text_region.delta);
1625 struct elf_image_info *image;
1639 image = find_image_at_address(address);
1640 // get image that may contain the address
1642 if (image != NULL) {
1647 TRACE((" image %p, base = %p, size = %p\n", image,
1648 (void *)image->text_region.start, (void *)image->text_region.size));
1650 if (image->debug_symbols != NULL) {
1655 for (i = 0; i < image->num_debug_symbols; i++) {
1656 elf_sym *symbol = &image->debug_symbols[i];
1659 >= image->text_region.size + image->data_region.size)
1663 = address - (symbol->st_value + image->text_region.delta);
1670 symbolName = image->debug_string_table + symbol->st_name;
1681 for (i = 0; i < HASHTABSIZE(image); i++) {
1682 for (j = HASHBUCKETS(image)[i]; j != STN_UNDEF;
1683 j = HASHCHAINS(image)[j]) {
1684 elf_sym *symbol = &image->syms[j];
1687 || symbol->st_size >= image->text_region.size
1688 + image->data_region.size)
1692 + image->text_region.delta);
1699 symbolName = SYMNAME(image, symbol);
1714 *_imageName = image->name;
1716 *_baseAddress = symbolFound->st_value + image->text_region.delta;
1721 } else if (image != NULL) {
1727 *_imageName = image->name;
1729 *_baseAddress = image->text_region.start;
1735 TRACE(("image not found!\n"));
1776 struct elf_image_info *image = NULL;
1780 image = iterator.Next();
1781 if (image->num_debug_symbols > 0) {
1783 for (uint32 i = 0; i < image->num_debug_symbols; i++) {
1784 elf_sym *symbol = &image->debug_symbols[i];
1785 const char *name = image->debug_string_table + symbol->st_name;
1788 return symbol->st_value + image->text_region.delta;
1792 for (uint32 i = 0; i < HASHTABSIZE(image); i++) {
1793 for (uint32 j = HASHBUCKETS(image)[i]; j != STN_UNDEF;
1794 j = HASHCHAINS(image)[j]) {
1795 elf_sym *symbol = &image->syms[j];
1796 const char *name = SYMNAME(image, symbol);
1799 return symbol->st_value + image->text_region.delta;
1865 struct elf_image_info* image;
1866 image = create_image_struct();
1867 if (image == NULL)
1869 CObjectDeleter<elf_image_info, void, delete_elf_image> imageDeleter(image);
1872 ElfHeaderUnsetter(elf_image_info* image)
1873 : fImage(image)
1882 } headerUnsetter(image);
1883 image->elf_header = &elfHeader;
1946 image->dynamic_section = programHeaders[i].p_vaddr;
1982 image->data_region.start = (addr_t)regionAddress;
1983 image->data_region.size = memUpperBound;
2039 image->text_region.start = (addr_t)regionAddress;
2040 image->text_region.size = segmentSize;
2049 image->data_region.delta = delta;
2050 image->text_region.delta = delta;
2053 image->dynamic_section += image->text_region.delta;
2056 status = elf_parse_dynamic_section(image);
2062 status = elf_relocate(image, image);
2090 // register the loaded image
2103 imageInfo.symbol_table = image->syms;
2104 imageInfo.symbol_hash = image->symhash;
2105 imageInfo.string_table = image->strtab;
2127 struct elf_image_info *image;
2154 // Prevent someone else from trying to load this image
2158 image = find_image_by_vnode(vnode);
2159 if (image) {
2160 atomic_add(&image->ref_count, 1);
2184 image = create_image_struct();
2185 if (!image) {
2189 image->vnode = vnode;
2190 image->elf_header = elfHeader;
2191 image->name = strdup(path);
2255 image->data_region.size = 0;
2256 image->text_region.size = 0;
2268 image->dynamic_section = programHeaders[i].p_vaddr;
2303 if (image->data_region.size != 0) {
2307 region = &image->data_region;
2312 if (image->text_region.size != 0) {
2316 region = &image->text_region;
2357 image->data_region.delta += image->data_region.start;
2358 image->text_region.delta += image->text_region.start;
2361 image->dynamic_section += image->text_region.delta;
2363 status = elf_parse_dynamic_section(image);
2367 status = init_image_version_infos(image);
2371 status = check_needed_image_versions(image);
2375 status = elf_relocate(image, sKernelImage);
2381 // special image with concatenated .text and .data, when it
2383 set_area_protection(image->text_region.id,
2393 load_elf_symbol_table(fd, image);
2397 register_elf_image(image);
2404 return image->id;
2413 delete_elf_image(image);
2437 elf_image_info *image = find_image(id);
2438 if (image == NULL)
2441 unload_elf_image(image);
2484 // allocate the image
2485 elf_image_info* image = create_image_struct();
2486 if (image == NULL)
2488 MemoryDeleter imageDeleter(image);
2503 image->debug_symbols = symbolTable;
2504 image->num_debug_symbols = 0;
2505 image->debug_string_table = stringTable;
2507 // dup image name
2508 image->name = strdup(imageName);
2509 if (image->name == NULL)
2513 image->text_region.id = -1;
2514 image->text_region.start = text;
2515 image->text_region.size = textSize;
2516 image->text_region.delta = 0;
2518 image->data_region.id = -1;
2519 image->data_region.start = data;
2520 image->data_region.size = dataSize;
2521 image->data_region.delta = 0;
2524 register_elf_image(image);
2525 image_id imageID = image->id;
2543 // get the image
2544 struct elf_image_info* image = find_image(id);
2545 if (image == NULL)
2550 if (image->num_debug_symbols > 0) {
2551 for (int32 i = image->num_debug_symbols - 1; i >= 0; i--) {
2552 int32 nameIndex = image->debug_symbols[i].st_name;
2555 + strlen(image->debug_string_table + nameIndex) + 1;
2562 char* stringTable = (char*)image->debug_string_table;
2568 stringTable = (char*)realloc((char*)image->debug_string_table,
2572 image->debug_string_table = stringTable;
2577 int32 symbolCount = image->num_debug_symbols + 1;
2579 (elf_sym*)image->debug_symbols, sizeof(elf_sym) * symbolCount);
2582 image->debug_symbols = symbolTable;
2593 image->num_debug_symbols++;
2599 /*! Reads the symbol and string table for the kernel image with the given ID.
2641 // find the image
2643 struct elf_image_info* image = find_image(id);
2644 if (image == NULL)
2648 addr_t imageDelta = image->text_region.delta;
2653 if (image->debug_symbols != NULL) {
2654 symbols = image->debug_symbols;
2655 symbolCount = image->num_debug_symbols;
2656 strings = image->debug_string_table;
2658 symbols = image->syms;
2659 symbolCount = image->symhash[1];
2660 strings = image->strtab;
2721 struct preloaded_image* image;
2739 // Build a image structure for the kernel, which has already been loaded.
2741 image = args->kernel_image;
2742 if (insert_preloaded_image(static_cast<preloaded_elf_image *>(image),
2744 panic("could not create kernel image.\n");
2746 // Build image structures for all preloaded images.
2747 for (image = args->preloaded_images; image != NULL; image = image->next)
2748 insert_preloaded_image(static_cast<preloaded_elf_image *>(image),
2753 add_debugger_command("symbols", &dump_symbols, "dump symbols for image");
2755 add_debugger_command_etc("image", &dump_image, "dump image info",
2756 "Prints info about the specified image.\n"
2757 " <image> - pointer to the semaphore structure, or ID\n"
2758 " of the image to print info for.\n", 0);
2768 /*! Reads the symbol and string table for the kernel image with the given ID.