Lines Matching refs:image
52 //! Remaps the image ID of \a image after fork.
54 update_image_id(image_t* image)
60 for (uint32 i = 0; i < image->num_regions; i++) {
61 if (image->regions[i].vmstart == (addr_t)info.text) {
62 image->id = info.id;
68 FATAL("Could not update image ID %" B_PRId32 " after fork()!\n", image->id);
74 enqueue_image(image_queue_t* queue, image_t* image)
76 image->next = NULL;
78 image->prev = queue->tail;
80 queue->tail->next = image;
82 queue->tail = image;
84 queue->head = image;
89 dequeue_image(image_queue_t* queue, image_t* image)
91 if (image->next)
92 image->next->prev = image->prev;
94 queue->tail = image->prev;
96 if (image->prev)
97 image->prev->next = image->next;
99 queue->head = image->next;
101 image->prev = NULL;
102 image->next = NULL;
110 for (image_t* image = queue->head; image; image = image->next) {
111 const char* imageName = isPath ? image->path : image->name;
112 int length = isPath ? sizeof(image->path) : sizeof(image->name);
115 && (typeMask & IMAGE_TYPE_TO_MASK(image->type)) != 0) {
116 return image;
125 update_image_flags_recursively(image_t* image, uint32 flagsToSet,
131 queue[count++] = image;
132 image->flags |= RFLAG_VISITED;
135 // pop next image
136 image = queue[index++];
139 for (uint32 i = 0; i < image->num_needed; i++) {
140 image_t* needed = image->needed[i];
157 topological_sort(image_t* image, uint32 slot, image_t** initList,
160 if (image->flags & sortFlag)
163 image->flags |= sortFlag; /* make sure we don't visit this one */
164 for (uint32 i = 0; i < image->num_needed; i++)
165 slot = topological_sort(image->needed[i], slot, initList, sortFlag);
167 initList[slot] = image;
172 /*! Finds the load address and address specifier of the given image region.
175 get_image_region_load_address(image_t* image, uint32 index, long lastDelta,
179 // relocatable image... we can afford to place wherever
185 loadAddress = image->regions[index].vmstart + lastDelta;
190 loadAddress = image->regions[index].vmstart;
205 image_t* image = (image_t*)malloc(allocSize);
206 if (image == NULL) {
207 FATAL("no memory for image %s\n", path);
211 memset(image, 0, allocSize);
213 strlcpy(image->path, path, sizeof(image->path));
215 // Make the last component of the supplied name the image name.
219 strlcpy(image->name, lastSlash + 1, sizeof(image->name));
221 strlcpy(image->name, name, sizeof(image->name));
223 image->ref_count = 1;
224 image->num_regions = regionCount;
226 return image;
231 delete_image_struct(image_t* image)
235 + (image->num_regions - 1) * sizeof(elf_region_t);
236 memset(image->needed, 0xa5, sizeof(image->needed[0]) * image->num_needed);
238 free(image->needed);
239 free(image->versions);
242 = image->defined_symbol_patchers) {
243 image->defined_symbol_patchers = patcher->next;
247 = image->undefined_symbol_patchers) {
248 image->undefined_symbol_patchers = patcher->next;
254 memset(image, 0xa5, size);
256 free(image);
261 delete_image(image_t* image)
263 if (image == NULL)
266 _kern_unregister_image(image->id);
269 delete_image_struct(image);
274 put_image(image_t* image)
276 // If all references to the image are gone, add it to the disposable list
279 if (atomic_add(&image->ref_count, -1) == 1) {
282 dequeue_image(&sLoadedImages, image);
283 enqueue_image(&sDisposableImages, image);
286 for (i = 0; i < image->num_needed; i++)
287 put_image(image->needed[i]);
293 map_image(int fd, char const* path, image_t* image, bool fixed)
310 for (uint32 i = 0; i < image->num_regions; i++) {
314 if (fixed && image->regions[i].vmstart == 0)
318 get_image_region_load_address(image, i,
319 i > 0 ? loadAddress - image->regions[i - 1].vmstart : 0,
326 length += TO_PAGE_SIZE(image->regions[i].vmsize
329 size_t size = TO_PAGE_SIZE(loadAddress + image->regions[i].vmsize)
345 for (uint32 i = 0; i < image->num_regions; i++) {
349 baseName, i, (image->regions[i].flags & RFLAG_RW) ? "rw" : "ro");
351 get_image_region_load_address(image, i,
352 i > 0 ? image->regions[i - 1].delta : 0, fixed, loadAddress,
355 // If the image position is arbitrary, we must let it point to the start
360 if ((image->regions[i].flags & RFLAG_ANON) != 0) {
361 image->regions[i].id = _kern_create_area(regionName,
363 image->regions[i].vmsize, B_NO_LOCK,
366 if (image->regions[i].id < 0) {
368 return image->regions[i].id;
379 | ((image->regions[i].flags & RFLAG_RW) != 0
381 image->regions[i].id = _kern_map_file(regionName,
383 image->regions[i].vmsize, protection, REGION_PRIVATE_MAP, false,
384 fd, PAGE_BASE(image->regions[i].fdstart));
386 if (image->regions[i].id < 0) {
388 return image->regions[i].id;
392 (void *)loadAddress, image->regions[i].vmsize,
393 image->regions[i].flags & RFLAG_RW ? "rw" : "read-only"));
396 if (image->regions[i].flags & RFLAG_RW) {
398 + PAGE_OFFSET(image->regions[i].start)
399 + image->regions[i].size;
400 addr_t toClear = image->regions[i].vmsize
401 - PAGE_OFFSET(image->regions[i].start)
402 - image->regions[i].size;
410 image->regions[i].delta = loadAddress - image->regions[i].vmstart;
411 image->regions[i].vmstart = loadAddress;
413 TLSBlockTemplates::Get().SetBaseAddress(image->dso_tls_id,
418 if (image->dynamic_ptr != 0)
419 image->dynamic_ptr += image->regions[0].delta;
426 unmap_image(image_t* image)
428 for (uint32 i = 0; i < image->num_regions; i++) {
429 _kern_delete_area(image->regions[i].id);
431 image->regions[i].id = -1;
439 If at least one image is in compatibility mode then we allow execution of
445 for (image_t* image = sLoadedImages.head; image != NULL;
446 image = image->next) {
447 for (uint32 i = 0; i < image->num_regions; i++) {
450 if ((image->regions[i].flags & RFLAG_REMAPPED) != 0)
454 if ((image->regions[i].flags & RFLAG_RW) == 0) {
455 result = _kern_set_area_protection(image->regions[i].id,
457 } else if (image->abi < B_HAIKU_ABI_GCC_2_HAIKU) {
458 result = _kern_set_area_protection(image->regions[i].id,
463 image->regions[i].flags |= RFLAG_REMAPPED;
470 register_image(image_t* image, int fd, const char* path)
477 info.basic_info.type = image->type;
480 info.basic_info.init_routine = (void (*)())image->init_routine;
481 info.basic_info.term_routine = (void (*)())image->term_routine;
492 // segments for the image info.
497 for (uint32 i= 0; i < image->num_regions; i++) {
498 addr_t base = image->regions[i].vmstart;
499 addr_t end = base + image->regions[i].vmsize;
500 if (image->regions[i].flags & RFLAG_RW) {
526 info.basic_info.api_version = image->api_version;
527 info.basic_info.abi = image->abi;
528 info.text_delta = image->regions[0].delta;
529 info.symbol_table = image->syms;
530 info.symbol_hash = image->symhash;
531 info.string_table = image->strtab;
532 image->id = _kern_register_image(&info, sizeof(info));
536 //! After fork, we lazily rebuild the image IDs of all loaded images.
540 for (image_t* image = sLoadedImages.head; image; image = image->next) {
541 status_t status = update_image_id(image);
545 for (image_t* image = sDisposableImages.head; image; image = image->next) {
546 status_t status = update_image_id(image);
578 enqueue_loaded_image(image_t* image)
580 enqueue_image(&sLoadedImages, image);
586 dequeue_loaded_image(image_t* image)
588 dequeue_image(&sLoadedImages, image);
594 dequeue_disposable_image(image_t* image)
596 dequeue_image(&sDisposableImages, image);
612 // After fork, we lazily rebuild the image IDs of all loaded images
616 for (image_t* image = sLoadedImages.head; image; image = image->next) {
617 if (image->id == id)
618 return image;
624 for (image_t* image = sDisposableImages.head; image; image = image->next) {
625 if (image->id == id)
626 return image;
636 for (image_t* image = sLoadedImages.head; image; image = image->next) {
637 for (uint32 i = 0; i < image->num_regions; i++) {
638 elf_region_t& region = image->regions[i];
641 return image;
650 set_image_flags_recursively(image_t* image, uint32 flags)
652 update_image_flags_recursively(image, flags, 0);
657 clear_image_flags_recursively(image_t* image, uint32 flags)
659 update_image_flags_recursively(image, 0, flags);
663 /*! Returns a topologically sorted image list.
665 If \a image is non-NULL, an array containing the image and all its
666 transitive dependencies is returned. If \a image is NULL, all loaded images
670 \param image The image specifying the tree of images that shall be sorted.
674 \param sortFlags The image flag that shall be used for sorting. Images that
682 get_sorted_image_list(image_t* image, image_t*** _list, uint32 sortFlag)
697 if (image != NULL)
698 return topological_sort(image, 0, list, sortFlag);
700 // no image given -- sort all loaded images
702 image = sLoadedImages.head;
703 while (image != NULL) {
704 count = topological_sort(image, count, list, sortFlag);
705 image = image->next;