Loading...
--- dyld/dyld-433.5/src/dyld_process_info.cpp
+++ dyld/dyld-852.2/src/dyld_process_info.cpp
@@ -22,6 +22,7 @@
* @APPLE_LICENSE_HEADER_END@
*/
+#include <dlfcn.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
@@ -32,26 +33,183 @@
#include <mach/mach_vm.h>
#include <mach/vm_region.h>
#include <libkern/OSAtomic.h>
-
-#include "dyld_process_info.h"
+#include <mach-o/dyld_process_info.h>
+#include <mach-o/dyld_images.h>
+
+#include "MachOFile.h"
#include "dyld_process_info_internal.h"
-#include "dyld_images.h"
-#include "dyld_priv.h"
+#include "Tracing.h"
+
+// this was in dyld_priv.h but it is no longer exported
+extern "C" {
+ const struct dyld_all_image_infos* _dyld_get_all_image_infos();
+}
+
+RemoteBuffer& RemoteBuffer::operator=(RemoteBuffer&& other) {
+ std::swap(_localAddress, other._localAddress);
+ std::swap(_size, other._size);
+ std::swap(_kr, other._kr);
+ return *this;
+}
+
+RemoteBuffer::RemoteBuffer() : _localAddress(0), _size(0), _kr(KERN_SUCCESS) {}
+RemoteBuffer::RemoteBuffer(std::tuple<mach_vm_address_t,vm_size_t,kern_return_t> T)
+ : _localAddress(std::get<0>(T)), _size(std::get<1>(T)), _kr(std::get<2>(T)) {}
+
+RemoteBuffer::RemoteBuffer(task_t task, mach_vm_address_t remote_address, size_t remote_size, bool allow_truncation)
+: RemoteBuffer(RemoteBuffer::create(task, remote_address, remote_size, allow_truncation)) {};
+
+std::pair<mach_vm_address_t, kern_return_t>
+RemoteBuffer::map(task_t task, mach_vm_address_t remote_address, vm_size_t size) {
+ static kern_return_t (*mvrn)(vm_map_t, mach_vm_address_t*, mach_vm_size_t, mach_vm_offset_t, int, vm_map_read_t, mach_vm_address_t,
+ boolean_t, vm_prot_t*, vm_prot_t*, vm_inherit_t) = nullptr;
+ vm_prot_t cur_protection = VM_PROT_NONE;
+ vm_prot_t max_protection = VM_PROT_READ;
+ if (size == 0) {
+ return std::make_pair(MACH_VM_MIN_ADDRESS, KERN_INVALID_ARGUMENT);
+ }
+ mach_vm_address_t localAddress = 0;
+#if TARGET_OS_SIMULATOR
+ static dispatch_once_t onceToken;
+ dispatch_once(&onceToken, ^{
+ mvrn = (kern_return_t (*)(vm_map_t, mach_vm_address_t*, mach_vm_size_t, mach_vm_offset_t, int, vm_map_read_t, mach_vm_address_t,
+ boolean_t, vm_prot_t*, vm_prot_t*, vm_inherit_t))dlsym(RTLD_DEFAULT, "mach_vm_remap_new");
+ if (mvrn == nullptr) {
+ // We are running on a system that does not support task_read ports, use the old call
+ mvrn = (kern_return_t (*)(vm_map_t, mach_vm_address_t*, mach_vm_size_t, mach_vm_offset_t, int, vm_map_read_t, mach_vm_address_t,
+ boolean_t, vm_prot_t*, vm_prot_t*, vm_inherit_t))dlsym(RTLD_DEFAULT, "mach_vm_remap");
+ }
+ });
+#else
+ mvrn = &mach_vm_remap_new;
+#endif
+ auto kr = mvrn(mach_task_self(),
+ &localAddress,
+ size,
+ 0, // mask
+ VM_FLAGS_ANYWHERE | VM_FLAGS_RESILIENT_CODESIGN | VM_FLAGS_RESILIENT_MEDIA,
+ task,
+ remote_address,
+ true,
+ &cur_protection,
+ &max_protection,
+ VM_INHERIT_NONE);
+ // The call is not succesfull return
+ if (kr != KERN_SUCCESS) {
+ return std::make_pair(MACH_VM_MIN_ADDRESS, kr);
+ }
+ // If it is not a shared buffer then copy it into a local buffer so our results are coherent in the event
+ // the page goes way due to storage removal, etc. We have to do this because even after we read the page the
+ // contents might go away of the object is paged out and then the backing region is disconnected (for example, if
+ // we are copying some memory in the middle of a mach-o that is on a USB drive that is disconnected after we perform
+ // the mapping). Once we copy them into a local buffer the memory will be handled by the default pager instead of
+ // potentially being backed by the mmap pager, and thus will be guaranteed not to mutate out from under us.
+ void* buffer = malloc(size);
+ if (buffer == nullptr) {
+ (void)vm_deallocate(mach_task_self(), (vm_address_t)localAddress, size);
+ return std::make_pair(MACH_VM_MIN_ADDRESS, KERN_NO_SPACE);
+ }
+ memcpy(buffer, (void *)localAddress, size);
+ (void)vm_deallocate(mach_task_self(), (vm_address_t)localAddress, size);
+ return std::make_pair((vm_address_t)buffer, KERN_SUCCESS);
+}
+
+std::tuple<mach_vm_address_t,vm_size_t,kern_return_t> RemoteBuffer::create(task_t task,
+ mach_vm_address_t remote_address,
+ size_t size,
+ bool allow_truncation) {
+ mach_vm_address_t localAddress;
+ kern_return_t kr;
+ // Try the initial map
+ std::tie(localAddress, kr) = map(task, remote_address, size);
+ if (kr == KERN_SUCCESS) return std::make_tuple(localAddress, size, kr);
+ // The first attempt failed, truncate if possible and try again. We only need to try once since the largest
+ // truncatable buffer we map is less than a single page. To be more general we would need to try repeatedly in a
+ // loop.
+ if (allow_truncation) {
+ size = PAGE_SIZE - remote_address%PAGE_SIZE;
+ std::tie(localAddress, kr) = map(task, remote_address, size);
+ if (kr == KERN_SUCCESS) return std::make_tuple(localAddress, size, kr);
+ }
+ // If we reach this then the mapping completely failed
+ return std::make_tuple(MACH_VM_MIN_ADDRESS, 0, kr);
+}
+
+RemoteBuffer::~RemoteBuffer() {
+ if (!_localAddress) { return; }
+ free((void*)_localAddress);
+}
+void *RemoteBuffer::getLocalAddress() const { return (void *)_localAddress; }
+size_t RemoteBuffer::getSize() const { return _size; }
+kern_return_t RemoteBuffer::getKernelReturn() const { return _kr; }
+
+void withRemoteBuffer(task_t task, mach_vm_address_t remote_address, size_t remote_size, bool allow_truncation, kern_return_t *kr, void (^block)(void *buffer, size_t size)) {
+ kern_return_t krSink = KERN_SUCCESS;
+ if (kr == nullptr) {
+ kr = &krSink;
+ }
+ RemoteBuffer buffer(task, remote_address, remote_size, allow_truncation);
+ *kr = buffer.getKernelReturn();
+ if (*kr == KERN_SUCCESS) {
+ block(buffer.getLocalAddress(), buffer.getSize());
+ }
+}
//
// Opaque object returned by _dyld_process_info_create()
//
+struct __attribute__((visibility("hidden"))) dyld_process_info_deleter { // deleter
+ // dyld_process_info_deleter() {};
+ // dyld_process_info_deleter(const dyld_process_info_deleter&) { }
+ // dyld_process_info_deleter(dyld_process_info_deleter&) {}
+ // dyld_process_info_deleter(dyld_process_info_deleter&&) {}
+ void operator()(dyld_process_info_base* p) const {
+ if (p) {
+ free(p);
+ }
+ };
+};
+
+static dyld_process_info_deleter deleter;
+typedef std::unique_ptr<dyld_process_info_base, dyld_process_info_deleter> dyld_process_info_ptr;
+
struct __attribute__((visibility("hidden"))) dyld_process_info_base {
- static dyld_process_info_base* make(task_t task, const dyld_all_image_infos_64& allImageInfo, const dyld_image_info_64 imageArray[], kern_return_t* kr);
- static dyld_process_info_base* makeSuspended(task_t task, kern_return_t* kr);
-
- uint32_t& retainCount() const { return _retainCount; }
- dyld_process_cache_info* cacheInfo() const { return (dyld_process_cache_info*)(((char*)this) + _cacheInfoOffset); }
- dyld_process_state_info* stateInfo() const { return (dyld_process_state_info*)(((char*)this) + _stateInfoOffset); }
- void forEachImage(void (^callback)(uint64_t machHeaderAddress, const uuid_t uuid, const char* path)) const;
- void forEachSegment(uint64_t machHeaderAddress, void (^callback)(uint64_t segmentAddress, uint64_t segmentSize, const char* segmentName)) const;
+ template<typename T1, typename T2>
+ static dyld_process_info_ptr make(task_t task, const T1& allImageInfo, uint64_t timestamp, kern_return_t* kr);
+ template<typename T>
+ static dyld_process_info_ptr makeSuspended(task_t task, const T& allImageInfo, kern_return_t* kr);
+
+ std::atomic<uint32_t>& retainCount() const { return _retainCount; }
+ dyld_process_cache_info* cacheInfo() const { return (dyld_process_cache_info*)(((char*)this) + _cacheInfoOffset); }
+ dyld_process_aot_cache_info* aotCacheInfo() const { return (dyld_process_aot_cache_info*)(((char*)this) + _aotCacheInfoOffset); }
+ dyld_process_state_info* stateInfo() const { return (dyld_process_state_info*)(((char*)this) + _stateInfoOffset); }
+ dyld_platform_t platform() const { return _platform; }
+
+ void forEachImage(void (^callback)(uint64_t machHeaderAddress, const uuid_t uuid, const char* path)) const;
+ void forEachAotImage(bool (^callback)(uint64_t x86Address, uint64_t aotAddress, uint64_t aotSize, uint8_t* aotImageKey, size_t aotImageKeySize)) const;
+ void forEachSegment(uint64_t machHeaderAddress, void (^callback)(uint64_t segmentAddress, uint64_t segmentSize, const char* segmentName)) const;
+
+ bool reserveSpace(size_t space) {
+ if (_freeSpace < space) { return false; }
+ _freeSpace -= space;
+ return true;
+ }
+
+ void retain()
+ {
+ _retainCount++;
+ }
+
+ void release()
+ {
+ uint32_t newCount = --_retainCount;
+
+ if ( newCount == 0 ) {
+ free(this);
+ }
+ }
private:
struct ImageInfo {
@@ -68,30 +226,40 @@
uint64_t size;
};
- dyld_process_info_base(unsigned imageCount, size_t totalSize);
+ dyld_process_info_base(dyld_platform_t platform, unsigned imageCount, unsigned aotImageCount, size_t totalSize);
void* operator new (size_t, void* buf) { return buf; }
static bool inCache(uint64_t addr) { return (addr > SHARED_REGION_BASE) && (addr < SHARED_REGION_BASE+SHARED_REGION_SIZE); }
- kern_return_t addImage(task_t task, bool sameCacheAsThisProcess, uint64_t imageAddress, uint64_t imagePath, const char* imagePathLocal);
+ bool addImage(task_t task, bool sameCacheAsThisProcess, uint64_t imageAddress, uint64_t imagePath, const char* imagePathLocal);
+
+ bool addAotImage(dyld_aot_image_info_64 aotImageInfo);
+
kern_return_t addDyldImage(task_t task, uint64_t dyldAddress, uint64_t dyldPathAddress, const char* localPath);
bool invalid() { return ((char*)_stringRevBumpPtr < (char*)_curSegment); }
- const char* copyPath(task_t task, uint64_t pathAddr, kern_return_t* kr);
- const char* addString(const char*);
+ const char* copyPath(task_t task, uint64_t pathAddr);
+ const char* addString(const char*, size_t);
const char* copySegmentName(const char*);
void addInfoFromLoadCommands(const mach_header* mh, uint64_t addressInTask, size_t size);
+ kern_return_t addInfoFromRemoteLoadCommands(task_t task, uint64_t remoteMH);
void inspectLocalImageLoadCommands(uint64_t imageAddress, void* func);
kern_return_t inspectRemoteImageLoadCommands(task_t task, uint64_t imageAddress, void* func);
- mutable uint32_t _retainCount;
+ mutable std::atomic<uint32_t> _retainCount;
const uint32_t _cacheInfoOffset;
+ const uint32_t _aotCacheInfoOffset;
const uint32_t _stateInfoOffset;
const uint32_t _imageInfosOffset;
+ const uint32_t _aotImageInfosOffset;
const uint32_t _segmentInfosOffset;
+ size_t _freeSpace;
+ dyld_platform_t _platform;
ImageInfo* const _firstImage;
ImageInfo* _curImage;
+ dyld_aot_image_info_64* const _firstAotImage;
+ dyld_aot_image_info_64* _curAotImage;
SegmentInfo* const _firstSegment;
SegmentInfo* _curSegment;
uint32_t _curSegmentIndex;
@@ -104,13 +272,18 @@
// char stringPool[]
};
-dyld_process_info_base::dyld_process_info_base(unsigned imageCount, size_t totalSize)
+dyld_process_info_base::dyld_process_info_base(dyld_platform_t platform, unsigned imageCount, unsigned aotImageCount, size_t totalSize)
: _retainCount(1), _cacheInfoOffset(sizeof(dyld_process_info_base)),
- _stateInfoOffset(sizeof(dyld_process_info_base) + sizeof(dyld_process_cache_info)),
- _imageInfosOffset(sizeof(dyld_process_info_base) + sizeof(dyld_process_cache_info) + sizeof(dyld_process_state_info)),
- _segmentInfosOffset(sizeof(dyld_process_info_base) + sizeof(dyld_process_cache_info) + sizeof(dyld_process_state_info) + imageCount*sizeof(ImageInfo)),
+ _aotCacheInfoOffset(sizeof(dyld_process_info_base) + sizeof(dyld_process_cache_info)),
+ _stateInfoOffset(sizeof(dyld_process_info_base) + sizeof(dyld_process_cache_info) + sizeof(dyld_process_aot_cache_info)),
+ _imageInfosOffset(sizeof(dyld_process_info_base) + sizeof(dyld_process_cache_info) + sizeof(dyld_process_aot_cache_info) + sizeof(dyld_process_state_info)),
+ _aotImageInfosOffset(sizeof(dyld_process_info_base) + sizeof(dyld_process_cache_info) + sizeof(dyld_process_aot_cache_info) + sizeof(dyld_process_state_info) + imageCount*sizeof(ImageInfo)),
+ _segmentInfosOffset(sizeof(dyld_process_info_base) + sizeof(dyld_process_cache_info) + sizeof(dyld_process_aot_cache_info) + sizeof(dyld_process_state_info) + imageCount*sizeof(ImageInfo) + aotImageCount*sizeof(dyld_aot_image_info_64)),
+ _freeSpace(totalSize), _platform(platform),
_firstImage((ImageInfo*)(((uint8_t*)this) + _imageInfosOffset)),
_curImage((ImageInfo*)(((uint8_t*)this) + _imageInfosOffset)),
+ _firstAotImage((dyld_aot_image_info_64*)(((uint8_t*)this) + _aotImageInfosOffset)),
+ _curAotImage((dyld_aot_image_info_64*)(((uint8_t*)this) + _aotImageInfosOffset)),
_firstSegment((SegmentInfo*)(((uint8_t*)this) + _segmentInfosOffset)),
_curSegment((SegmentInfo*)(((uint8_t*)this) + _segmentInfosOffset)),
_curSegmentIndex(0),
@@ -118,153 +291,256 @@
{
}
-
-dyld_process_info_base* dyld_process_info_base::make(task_t task, const dyld_all_image_infos_64& allImageInfo, const dyld_image_info_64 imageArray[], kern_return_t* kr)
-{
- // figure out how many path strings will need to be copied and their size
- const dyld_all_image_infos* myInfo = _dyld_get_all_image_infos();
- bool sameCacheAsThisProcess = ((memcmp(myInfo->sharedCacheUUID, allImageInfo.sharedCacheUUID, 16) == 0) && (myInfo->sharedCacheSlide == allImageInfo.sharedCacheSlide));
- unsigned countOfPathsNeedingCopying = 0;
- if ( sameCacheAsThisProcess ) {
- for (int i=0; i < allImageInfo.infoArrayCount; ++i) {
- if ( !inCache(imageArray[i].imageFilePath) )
- ++countOfPathsNeedingCopying;
- }
- }
- else {
- countOfPathsNeedingCopying = allImageInfo.infoArrayCount+1;
- }
- unsigned imageCountWithDyld = allImageInfo.infoArrayCount+1;
-
- // allocate result object
- size_t allocationSize = sizeof(dyld_process_info_base)
- + sizeof(dyld_process_cache_info)
- + sizeof(dyld_process_state_info)
- + sizeof(ImageInfo)*(imageCountWithDyld)
- + sizeof(SegmentInfo)*imageCountWithDyld*5
- + countOfPathsNeedingCopying*PATH_MAX;
- void* storage = malloc(allocationSize);
- dyld_process_info_base* obj = new (storage) dyld_process_info_base(imageCountWithDyld, allocationSize); // placement new()
-
- // fill in base info
- dyld_process_cache_info* cacheInfo = obj->cacheInfo();
- memcpy(cacheInfo->cacheUUID, allImageInfo.sharedCacheUUID, 16);
- cacheInfo->cacheBaseAddress = allImageInfo.sharedCacheBaseAddress;
- cacheInfo->privateCache = allImageInfo.processDetachedFromSharedRegion;
- // if no cache is used, allImageInfo has all zeros for cache UUID
- cacheInfo->noCache = true;
- for (int i=0; i < 16; ++i) {
- if ( cacheInfo->cacheUUID[i] != 0 ) {
- cacheInfo->noCache = false;
- }
- }
-
- dyld_process_state_info* stateInfo = obj->stateInfo();
- stateInfo->timestamp = allImageInfo.infoArrayChangeTimestamp;
- stateInfo->imageCount = imageCountWithDyld;
- stateInfo->initialImageCount = (uint32_t)(allImageInfo.initialImageCount+1);
- if ( allImageInfo.infoArray != 0 )
+template<typename T1, typename T2>
+dyld_process_info_ptr dyld_process_info_base::make(task_t task, const T1& allImageInfo, uint64_t timestamp, kern_return_t* kr)
+{
+ __block dyld_process_info_ptr result = nullptr;
+
+ // bail out of dyld is too old
+ if ( allImageInfo.version < 15 ) {
+ *kr = KERN_FAILURE;
+ return nullptr;
+ }
+
+ // Check if the process is suspended
+ if (allImageInfo.infoArrayChangeTimestamp == 0) {
+ result = dyld_process_info_base::makeSuspended<T1>(task, allImageInfo, kr);
+ // If we have a result return it, otherwise rescan
+ if (result) {
+ // If it returned the process is suspended and there is nothing more to do
+ return std::move(result);
+ }
+ usleep(1000 * 50); // 50ms
+ // Not exactly correct, but conveys that operation may succeed in the future
+ *kr = KERN_RESOURCE_SHORTAGE;
+ return nullptr;
+ }
+
+ // Test to see if there are no changes and we can exit early
+ if (timestamp != 0 && timestamp == allImageInfo.infoArrayChangeTimestamp) {
+ *kr = KERN_SUCCESS;
+ return nullptr;
+ }
+
+ uint64_t currentTimestamp = allImageInfo.infoArrayChangeTimestamp;
+ mach_vm_address_t infoArray = allImageInfo.infoArray;
+ if (infoArray == 0) {
+ usleep(1000 * 50); // 50ms
+ // Not exactly correct, but conveys that operation may succeed in the future
+ *kr = KERN_RESOURCE_SHORTAGE;
+ return nullptr;
+ };
+
+ // For the moment we are going to truncate any image list longer than 8192 because some programs do
+ // terrible things that corrupt their own image lists and we need to stop clients from crashing
+ // reading them. We can try to do something more advanced in the future. rdar://27446361
+ uint32_t imageCount = allImageInfo.infoArrayCount;
+ imageCount = MIN(imageCount, 8192);
+ size_t imageArraySize = imageCount * sizeof(T2);
+
+ withRemoteBuffer(task, infoArray, imageArraySize, false, kr, ^(void *buffer, size_t size) {
+ // figure out how many path strings will need to be copied and their size
+ T2* imageArray = (T2 *)buffer;
+ const dyld_all_image_infos* myInfo = _dyld_get_all_image_infos();
+ bool sameCacheAsThisProcess = !allImageInfo.processDetachedFromSharedRegion
+ && !myInfo->processDetachedFromSharedRegion
+ && ((memcmp(myInfo->sharedCacheUUID, &allImageInfo.sharedCacheUUID[0], 16) == 0)
+ && (myInfo->sharedCacheSlide == allImageInfo.sharedCacheSlide));
+ unsigned countOfPathsNeedingCopying = 0;
+ if ( sameCacheAsThisProcess ) {
+ for (uint32_t i=0; i < imageCount; ++i) {
+ if ( !inCache(imageArray[i].imageFilePath) )
+ ++countOfPathsNeedingCopying;
+ }
+ }
+ else {
+ countOfPathsNeedingCopying = imageCount+1;
+ }
+ unsigned imageCountWithDyld = imageCount+1;
+
+ // allocate result object
+ size_t allocationSize = sizeof(dyld_process_info_base)
+ + sizeof(dyld_process_cache_info)
+ + sizeof(dyld_process_aot_cache_info)
+ + sizeof(dyld_process_state_info)
+ + sizeof(ImageInfo)*(imageCountWithDyld)
+ + sizeof(dyld_aot_image_info_64)*(allImageInfo.aotInfoCount) // add the size necessary for aot info to this buffer
+ + sizeof(SegmentInfo)*imageCountWithDyld*10
+ + countOfPathsNeedingCopying*PATH_MAX;
+ void* storage = malloc(allocationSize);
+ if (storage == nullptr) {
+ *kr = KERN_NO_SPACE;
+ result = nullptr;
+ return;
+ }
+ auto info = dyld_process_info_ptr(new (storage) dyld_process_info_base(allImageInfo.platform, imageCountWithDyld, allImageInfo.aotInfoCount, allocationSize), deleter);
+ (void)info->reserveSpace(sizeof(dyld_process_info_base)+sizeof(dyld_process_cache_info)+sizeof(dyld_process_state_info)+sizeof(dyld_process_aot_cache_info));
+ (void)info->reserveSpace(sizeof(ImageInfo)*imageCountWithDyld);
+
+ // fill in base info
+ dyld_process_cache_info* cacheInfo = info->cacheInfo();
+ memcpy(cacheInfo->cacheUUID, &allImageInfo.sharedCacheUUID[0], 16);
+ cacheInfo->cacheBaseAddress = allImageInfo.sharedCacheBaseAddress;
+ cacheInfo->privateCache = allImageInfo.processDetachedFromSharedRegion;
+ // if no cache is used, allImageInfo has all zeros for cache UUID
+ cacheInfo->noCache = true;
+ for (int i=0; i < 16; ++i) {
+ if ( cacheInfo->cacheUUID[i] != 0 ) {
+ cacheInfo->noCache = false;
+ }
+ }
+
+ // fill in aot shared cache info
+ dyld_process_aot_cache_info* aotCacheInfo = info->aotCacheInfo();
+ memcpy(aotCacheInfo->cacheUUID, &allImageInfo.aotSharedCacheUUID[0], 16);
+ aotCacheInfo->cacheBaseAddress = allImageInfo.aotSharedCacheBaseAddress;
+
+ dyld_process_state_info* stateInfo = info->stateInfo();
+ stateInfo->timestamp = currentTimestamp;
+ stateInfo->imageCount = imageCountWithDyld;
+ stateInfo->initialImageCount = (uint32_t)(allImageInfo.initialImageCount+1);
stateInfo->dyldState = dyld_process_state_dyld_initialized;
- if ( allImageInfo.libSystemInitialized != 0 ) {
- stateInfo->dyldState = dyld_process_state_libSystem_initialized;
- if ( allImageInfo.initialImageCount != allImageInfo.infoArrayCount )
- stateInfo->dyldState = dyld_process_state_program_running;
- }
- if ( allImageInfo.errorMessage != 0 )
- stateInfo->dyldState = allImageInfo.terminationFlags ? dyld_process_state_terminated_before_inits : dyld_process_state_dyld_terminated;
-
- // fill in info for dyld
- if ( allImageInfo.dyldPath != 0 ) {
- if ( kern_return_t r = obj->addDyldImage(task, allImageInfo.dyldImageLoadAddress, allImageInfo.dyldPath, NULL) ) {
- if ( kr != NULL )
- *kr = r;
- goto fail;
- }
- }
-
- // fill in info for each image
- for (uint32_t i=0; i < allImageInfo.infoArrayCount; ++i) {
- if ( kern_return_t r = obj->addImage(task, sameCacheAsThisProcess, imageArray[i].imageLoadAddress, imageArray[i].imageFilePath, NULL) ) {
- if ( kr != NULL )
- *kr = r;
- goto fail;
- }
- }
-
- // sanity check internal data did not overflow
- if ( obj->invalid() )
- goto fail;
-
- return obj;
-
-fail:
- free(obj);
- return NULL;
-}
-
-dyld_process_info_base* dyld_process_info_base::makeSuspended(task_t task, kern_return_t* kr)
+
+ if ( allImageInfo.libSystemInitialized != 0 ) {
+ stateInfo->dyldState = dyld_process_state_libSystem_initialized;
+ if ( allImageInfo.initialImageCount != imageCount ) {
+ stateInfo->dyldState = dyld_process_state_program_running;
+ }
+ }
+ if ( allImageInfo.errorMessage != 0 ) {
+ stateInfo->dyldState = allImageInfo.terminationFlags ? dyld_process_state_terminated_before_inits : dyld_process_state_dyld_terminated;
+ }
+ // fill in info for dyld
+ if ( allImageInfo.dyldPath != 0 ) {
+ if ((*kr = info->addDyldImage(task, allImageInfo.dyldImageLoadAddress, allImageInfo.dyldPath, NULL))) {
+ *kr = KERN_FAILURE;
+ result = nullptr;
+ return;
+ }
+ }
+ // fill in info for each image
+ for (uint32_t i=0; i < imageCount; ++i) {
+ if (!info->addImage(task, sameCacheAsThisProcess, imageArray[i].imageLoadAddress, imageArray[i].imageFilePath, NULL)) {
+ *kr = KERN_FAILURE;
+ result = nullptr;
+ return;
+ }
+ }
+ // sanity check internal data did not overflow
+ if ( info->invalid() ) {
+ *kr = KERN_FAILURE;
+ result = nullptr;
+ return;
+ }
+
+ result = std::move(info);
+ });
+
+ mach_vm_address_t aotImageArray = allImageInfo.aotInfoArray;
+ // shortcircuit this code path if aotImageArray == 0 (32 vs 64 bit struct difference)
+ // and if result == nullptr, since we need to append aot image infos to the process info struct
+ if (aotImageArray != 0 && result != nullptr) {
+ uint32_t aotImageCount = allImageInfo.aotInfoCount;
+ size_t aotImageArraySize = aotImageCount * sizeof(dyld_aot_image_info_64);
+
+ withRemoteBuffer(task, aotImageArray, aotImageArraySize, false, kr, ^(void *buffer, size_t size) {
+ dyld_aot_image_info_64* imageArray = (dyld_aot_image_info_64*)buffer;
+ for (uint32_t i = 0; i < aotImageCount; i++) {
+ if (!result->addAotImage(imageArray[i])) {
+ *kr = KERN_FAILURE;
+ result = nullptr;
+ return;
+ }
+ }
+ });
+ }
+ return std::move(result);
+}
+
+template<typename T>
+dyld_process_info_ptr dyld_process_info_base::makeSuspended(task_t task, const T& allImageInfo, kern_return_t* kr)
{
pid_t pid;
- kern_return_t result = pid_for_task(task, &pid);
- if ( result != KERN_SUCCESS ) {
- if ( kr != NULL )
- *kr = result;
+ if ((*kr = pid_for_task(task, &pid))) {
return NULL;
}
- unsigned imageCount = 0; // main executable and dyld
- uint64_t mainExecutableAddress = 0;
- uint64_t dyldAddress = 0;
- char dyldPathBuffer[PATH_MAX+1];
- char mainExecutablePathBuffer[PATH_MAX+1];
+ mach_task_basic_info ti;
+ mach_msg_type_number_t count = MACH_TASK_BASIC_INFO_COUNT;
+ if ((*kr = task_info(task, MACH_TASK_BASIC_INFO, (task_info_t)&ti, &count))) {
+ return nullptr;
+ }
+
+ // The task is not suspended, exit
+ if (ti.suspend_count == 0) {
+ return nullptr;
+ }
+
+ __block unsigned imageCount = 0; // main executable and dyld
+ __block uint64_t mainExecutableAddress = 0;
+ __block uint64_t dyldAddress = 0;
+ char dyldPathBuffer[PATH_MAX+1];
+ char mainExecutablePathBuffer[PATH_MAX+1];
+ __block char * dyldPath = &dyldPathBuffer[0];
+ __block char * mainExecutablePath = &mainExecutablePathBuffer[0];
+ __block dyld3::Platform platformID = dyld3::Platform::unknown;
mach_vm_size_t size;
for (mach_vm_address_t address = 0; ; address += size) {
vm_region_basic_info_data_64_t info;
mach_port_t objectName;
unsigned int infoCount = VM_REGION_BASIC_INFO_COUNT_64;
- result = mach_vm_region(task, &address, &size, VM_REGION_BASIC_INFO,
- (vm_region_info_t)&info, &infoCount, &objectName);
- if ( result != KERN_SUCCESS )
+ if (kern_return_t r = mach_vm_region(task, &address, &size, VM_REGION_BASIC_INFO,
+ (vm_region_info_t)&info, &infoCount, &objectName)) {
break;
- if ( info.protection == (VM_PROT_READ|VM_PROT_EXECUTE) ) {
+ }
+ if ( info.protection != (VM_PROT_READ|VM_PROT_EXECUTE) )
+ continue;
// read start of vm region to verify it is a mach header
- mach_vm_size_t readSize = sizeof(mach_header_64);
- mach_header_64 mhBuffer;
- if ( mach_vm_read_overwrite(task, address, sizeof(mach_header_64), (vm_address_t)&mhBuffer, &readSize) != KERN_SUCCESS )
- continue;
- if ( (mhBuffer.magic != MH_MAGIC) && (mhBuffer.magic != MH_MAGIC_64) )
- continue;
- // now know the region is the start of a mach-o file
- if ( mhBuffer.filetype == MH_EXECUTE ) {
- mainExecutableAddress = address;
- int len = proc_regionfilename(pid, mainExecutableAddress, mainExecutablePathBuffer, PATH_MAX);
- if ( len != 0 )
- mainExecutablePathBuffer[len] = '\0';
- ++imageCount;
- }
- else if ( mhBuffer.filetype == MH_DYLINKER ) {
- dyldAddress = address;
- int len = proc_regionfilename(pid, dyldAddress, dyldPathBuffer, PATH_MAX);
- if ( len != 0 )
- dyldPathBuffer[len] = '\0';
- ++imageCount;
- }
+ withRemoteObject(task, address, NULL, ^(mach_header_64 mhBuffer){
+ if ( (mhBuffer.magic != MH_MAGIC) && (mhBuffer.magic != MH_MAGIC_64) )
+ return;
+ // now know the region is the start of a mach-o file
+ if ( mhBuffer.filetype == MH_EXECUTE ) {
+ mainExecutableAddress = address;
+ int len = proc_regionfilename(pid, mainExecutableAddress, mainExecutablePath, PATH_MAX);
+ if ( len != 0 ) {
+ mainExecutablePath[len] = '\0';
+ }
+ ++imageCount;
+ }
+ else if ( mhBuffer.filetype == MH_DYLINKER ) {
+ dyldAddress = address;
+ int len = proc_regionfilename(pid, dyldAddress, dyldPath, PATH_MAX);
+ if ( len != 0 ) {
+ dyldPath[len] = '\0';
+ }
+ ++imageCount;
+ }
+ });
//fprintf(stderr, "vm region: addr=0x%llX, size=0x%llX, prot=0x%X\n", (uint64_t)address, (uint64_t)size, info.protection);
- }
}
//fprintf(stderr, "dyld: addr=0x%llX, path=%s\n", dyldAddress, dyldPathBuffer);
//fprintf(stderr, "app: addr=0x%llX, path=%s\n", mainExecutableAddress, mainExecutablePathBuffer);
+
+ // explicitly set aot image count to 0 in the suspended case
+ unsigned aotImageCount = 0;
// allocate result object
size_t allocationSize = sizeof(dyld_process_info_base)
+ sizeof(dyld_process_cache_info)
+ + sizeof(dyld_process_aot_cache_info)
+ sizeof(dyld_process_state_info)
+ sizeof(ImageInfo)*(imageCount)
- + sizeof(SegmentInfo)*imageCount*5
+ + sizeof(dyld_aot_image_info_64)*aotImageCount // this should always be 0, but including it here to be explicit
+ + sizeof(SegmentInfo)*imageCount*10
+ imageCount*PATH_MAX;
void* storage = malloc(allocationSize);
- dyld_process_info_base* obj = new (storage) dyld_process_info_base(imageCount, allocationSize); // placement new()
-
+ if (storage == nullptr) {
+ *kr = KERN_NO_SPACE;
+ return nullptr;
+ }
+ auto obj = dyld_process_info_ptr(new (storage) dyld_process_info_base((dyld_platform_t)platformID, imageCount, aotImageCount, allocationSize), deleter);
+ (void)obj->reserveSpace(sizeof(dyld_process_info_base)+sizeof(dyld_process_cache_info)+sizeof(dyld_process_aot_cache_info)+sizeof(dyld_process_state_info));
// fill in base info
dyld_process_cache_info* cacheInfo = obj->cacheInfo();
bzero(cacheInfo->cacheUUID, 16);
@@ -272,6 +548,11 @@
cacheInfo->noCache = true;
cacheInfo->privateCache = false;
+ // zero out aot cache info
+ dyld_process_aot_cache_info* aotCacheInfo = obj->aotCacheInfo();
+ bzero(aotCacheInfo->cacheUUID, 16);
+ aotCacheInfo->cacheBaseAddress = 0;
+
dyld_process_state_info* stateInfo = obj->stateInfo();
stateInfo->timestamp = 0;
stateInfo->imageCount = imageCount;
@@ -280,22 +561,30 @@
// fill in info for dyld
if ( dyldAddress != 0 ) {
- if ( kern_return_t r = obj->addDyldImage(task, dyldAddress, 0, dyldPathBuffer) ) {
- if ( kr != NULL )
- *kr = r;
- free(obj);
- return NULL;
+ if ((*kr = obj->addDyldImage(task, dyldAddress, 0, dyldPath))) {
+ return nullptr;
}
}
// fill in info for each image
if ( mainExecutableAddress != 0 ) {
- if ( kern_return_t r = obj->addImage(task, false, mainExecutableAddress, 0, mainExecutablePathBuffer) ) {
- if ( kr != NULL )
- *kr = r;
- free(obj);
- return NULL;
- }
+ if (!obj->addImage(task, false, mainExecutableAddress, 0, mainExecutablePath)) {
+ return nullptr;
+ }
+ }
+
+ if (allImageInfo.infoArrayChangeTimestamp != 0) {
+ return nullptr;
+ }
+
+ count = MACH_TASK_BASIC_INFO_COUNT;
+ if ((*kr = task_info(task, MACH_TASK_BASIC_INFO, (task_info_t)&ti, &count))) {
+ return nullptr;
+ }
+
+ // The task is not suspended, exit
+ if (ti.suspend_count == 0) {
+ return nullptr;
}
return obj;
@@ -303,119 +592,109 @@
-const char* dyld_process_info_base::addString(const char* str)
-{
- size_t len = strlen(str) + 1;
+const char* dyld_process_info_base::addString(const char* str, size_t maxlen)
+{
+ size_t len = strnlen(str, maxlen) + 1;
+ // If we don't have enough space return an empty string
+ if (!reserveSpace(len)) { return ""; }
_stringRevBumpPtr -= len;
- strcpy(_stringRevBumpPtr, str);
+ strlcpy(_stringRevBumpPtr, str, len);
return _stringRevBumpPtr;
}
-const char* dyld_process_info_base::copyPath(task_t task, uint64_t stringAddressInTask, kern_return_t* kr)
-{
- char temp[PATH_MAX+8]; // +8 is to allow '\0' at temp[PATH_MAX]
- mach_vm_size_t readSize = PATH_MAX;
- if ( ((stringAddressInTask & 0xFFF) + PATH_MAX) < 4096 ) {
- // string fits within page, only one vm_read needed
- if ( kern_return_t r = mach_vm_read_overwrite(task, stringAddressInTask, PATH_MAX, (vm_address_t)&temp, &readSize) ) {
- if ( kr != NULL )
- *kr = r;
- return NULL;
- }
- }
- else {
- // string may cross page boundary, split into two reads
- size_t firstLen = 4096 - (stringAddressInTask & 0xFFF);
- readSize = firstLen;
- if ( kern_return_t r = mach_vm_read_overwrite(task, stringAddressInTask, firstLen, (vm_address_t)&temp, &readSize) ) {
- if ( kr != NULL )
- *kr = r;
- return NULL;
- }
- temp[firstLen] = '\0';
- if ( strlen(temp) >= firstLen ) {
- readSize = PATH_MAX-firstLen;
- if ( kern_return_t r = mach_vm_read_overwrite(task, stringAddressInTask+firstLen, PATH_MAX-firstLen, (vm_address_t)&temp+firstLen, &readSize) ) {
- if ( kr != NULL )
- *kr = r;
- return NULL;
- temp[PATH_MAX] = '\0'; // truncate any string that is too long
- }
- }
- }
- if ( kr != NULL )
- *kr = KERN_SUCCESS;
- return addString(temp);
-}
-
-
-kern_return_t dyld_process_info_base::addImage(task_t task, bool sameCacheAsThisProcess, uint64_t imageAddress, uint64_t imagePath, const char* imagePathLocal)
+const char* dyld_process_info_base::copyPath(task_t task, uint64_t stringAddressInTask)
+{
+ __block const char* retval = "";
+ withRemoteBuffer(task, stringAddressInTask, PATH_MAX, true, nullptr, ^(void *buffer, size_t size) {
+ retval = addString(static_cast<const char *>(buffer), size);
+ });
+ return retval;
+}
+
+bool dyld_process_info_base::addImage(task_t task, bool sameCacheAsThisProcess, uint64_t imageAddress, uint64_t imagePath, const char* imagePathLocal)
{
_curImage->loadAddress = imageAddress;
_curImage->segmentStartIndex = _curSegmentIndex;
if ( imagePathLocal != NULL ) {
- _curImage->path = addString(imagePathLocal);
- }
- else if ( sameCacheAsThisProcess && inCache(imagePath) ) {
+ _curImage->path = addString(imagePathLocal, PATH_MAX);
+ } else if ( sameCacheAsThisProcess && inCache(imagePath) ) {
_curImage->path = (const char*)imagePath;
- }
- else {
- kern_return_t kr;
- _curImage->path = copyPath(task, imagePath, &kr);
- if ( kr )
- return kr;
- }
+ } else if (imagePath) {
+ _curImage->path = copyPath(task, imagePath);
+ } else {
+ _curImage->path = "";
+ }
+
if ( sameCacheAsThisProcess && inCache(imageAddress) ) {
addInfoFromLoadCommands((mach_header*)imageAddress, imageAddress, 32*1024);
- }
- else {
- mach_vm_size_t readSize = sizeof(mach_header_64);
- mach_header_64 mhBuffer;
- if ( kern_return_t r = mach_vm_read_overwrite(task, imageAddress, sizeof(mach_header_64), (vm_address_t)&mhBuffer, &readSize) ) {
- return r;
- }
- size_t headerPagesSize = (sizeof(mach_header_64) + mhBuffer.sizeofcmds + 4095) & (-4096);
- vm_address_t localCopyBuffer;
- unsigned int localCopyBufferSize;
- if ( kern_return_t r = mach_vm_read(task, imageAddress, headerPagesSize, &localCopyBuffer, &localCopyBufferSize) ) {
- return r;
- }
- addInfoFromLoadCommands((mach_header*)localCopyBuffer, imageAddress, localCopyBufferSize);
- vm_deallocate(mach_task_self(), localCopyBuffer, localCopyBufferSize);
+ } else if (addInfoFromRemoteLoadCommands(task, imageAddress) != KERN_SUCCESS) {
+ // The image is not here, return early
+ return false;
}
_curImage->segmentsCount = _curSegmentIndex - _curImage->segmentStartIndex;
_curImage++;
- return KERN_SUCCESS;
-}
-
+ return true;
+}
+
+bool dyld_process_info_base::addAotImage(dyld_aot_image_info_64 aotImageInfo) {
+ if (!reserveSpace(sizeof(dyld_aot_image_info_64))) {
+ return false;
+ }
+ _curAotImage->x86LoadAddress = aotImageInfo.x86LoadAddress;
+ _curAotImage->aotLoadAddress = aotImageInfo.aotLoadAddress;
+ _curAotImage->aotImageSize = aotImageInfo.aotImageSize;
+ memcpy(_curAotImage->aotImageKey, aotImageInfo.aotImageKey, sizeof(aotImageInfo.aotImageKey));
+
+ _curAotImage++;
+ return true;
+}
+
+kern_return_t dyld_process_info_base::addInfoFromRemoteLoadCommands(task_t task, uint64_t remoteMH) {
+ __block kern_return_t kr = KERN_SUCCESS;
+ __block size_t headerPagesSize = 0;
+ __block bool done = false;
+
+ //Since the minimum we can reasonably map is a page, map that.
+ withRemoteBuffer(task, remoteMH, PAGE_SIZE, false, &kr, ^(void * buffer, size_t size) {
+ const mach_header* mh = (const mach_header*)buffer;
+ headerPagesSize = sizeof(mach_header) + mh->sizeofcmds;
+ if (headerPagesSize <= PAGE_SIZE) {
+ addInfoFromLoadCommands(mh, remoteMH, size);
+ done = true;
+ }
+ });
+
+ //The load commands did not fit in the first page, but now we know the size, so remap and try again
+ if (!done) {
+ if (kr != KERN_SUCCESS) {
+ return kr;
+ }
+ withRemoteBuffer(task, remoteMH, headerPagesSize, false, &kr, ^(void * buffer, size_t size) {
+ addInfoFromLoadCommands((mach_header*)buffer, remoteMH, size);
+ });
+ }
+
+ return kr;
+}
kern_return_t dyld_process_info_base::addDyldImage(task_t task, uint64_t dyldAddress, uint64_t dyldPathAddress, const char* localPath)
{
- kern_return_t kr;
+ __block kern_return_t kr = KERN_SUCCESS;
_curImage->loadAddress = dyldAddress;
_curImage->segmentStartIndex = _curSegmentIndex;
if ( localPath != NULL ) {
- _curImage->path = addString(localPath);
+ _curImage->path = addString(localPath, PATH_MAX);
}
else {
- _curImage->path = copyPath(task, dyldPathAddress, &kr);
- if ( kr )
+ _curImage->path = copyPath(task, dyldPathAddress);
+ if ( kr != KERN_SUCCESS)
return kr;
}
- mach_vm_size_t readSize = sizeof(mach_header_64);
- mach_header_64 mhBuffer;
- if ( kern_return_t r = mach_vm_read_overwrite(task, dyldAddress, sizeof(mach_header_64), (vm_address_t)&mhBuffer, &readSize) ) {
- return r;
- }
- size_t headerPagesSize = (sizeof(mach_header_64) + mhBuffer.sizeofcmds + 4095) & (-4096);
- vm_address_t localCopyBuffer;
- unsigned int localCopyBufferSize;
- if ( kern_return_t r = mach_vm_read(task, dyldAddress, headerPagesSize, &localCopyBuffer, &localCopyBufferSize) ) {
- return r;
- }
- addInfoFromLoadCommands((mach_header*)localCopyBuffer, dyldAddress, localCopyBufferSize);
- vm_deallocate(mach_task_self(), localCopyBuffer, localCopyBufferSize);
+ kr = addInfoFromRemoteLoadCommands(task, dyldAddress);
+ if ( kr != KERN_SUCCESS)
+ return kr;
+
_curImage->segmentsCount = _curSegmentIndex - _curImage->segmentStartIndex;
_curImage++;
return KERN_SUCCESS;
@@ -431,7 +710,7 @@
startCmds = (load_command*)((char *)mh + sizeof(mach_header));
else
return; // not a mach-o file, or wrong endianness
-
+
const load_command* const cmdsEnd = (load_command*)((char*)startCmds + mh->sizeofcmds);
const load_command* cmd = startCmds;
for(uint32_t i = 0; i < mh->ncmds; ++i) {
@@ -444,6 +723,7 @@
memcpy(_curImage->uuid, uuidCmd->uuid, 16);
}
else if ( cmd->cmd == LC_SEGMENT ) {
+ if (!reserveSpace(sizeof(SegmentInfo))) { break; }
const segment_command* segCmd = (segment_command*)cmd;
_curSegment->name = copySegmentName(segCmd->segname);
_curSegment->addr = segCmd->vmaddr;
@@ -452,6 +732,7 @@
_curSegmentIndex++;
}
else if ( cmd->cmd == LC_SEGMENT_64 ) {
+ if (!reserveSpace(sizeof(SegmentInfo))) { break; }
const segment_command_64* segCmd = (segment_command_64*)cmd;
_curSegment->name = copySegmentName(segCmd->segname);
_curSegment->addr = segCmd->vmaddr;
@@ -466,13 +747,19 @@
const char* dyld_process_info_base::copySegmentName(const char* name)
{
// don't copy names of standard segments into string pool
- static const char* stdSegNames[] = {"__TEXT", "__DATA", "__LINKEDIT", "__DATA_DIRTY", "__DATA_CONST", "__OBJC", NULL };
+ static const char* stdSegNames[] = {
+ "__TEXT", "__DATA", "__LINKEDIT",
+ "__DATA_DIRTY", "__DATA_CONST",
+ "__OBJC", "__OBJC_CONST",
+ "__AUTH", "__AUTH_CONST",
+ NULL
+ };
for (const char** s=stdSegNames; *s != NULL; ++s) {
if ( strcmp(name, *s) == 0 )
return *s;
}
// copy custom segment names into string pool
- return addString(name);
+ return addString(name, 16);
}
void dyld_process_info_base::forEachImage(void (^callback)(uint64_t machHeaderAddress, const uuid_t uuid, const char* path)) const
@@ -481,20 +768,32 @@
callback(p->loadAddress, p->uuid, p->path);
}
}
+
+
+#if TARGET_OS_OSX
+void dyld_process_info_base::forEachAotImage(bool (^callback)(uint64_t x86Address, uint64_t aotAddress, uint64_t aotSize, uint8_t* aotImageKey, size_t aotImageKeySize)) const
+{
+ for (const dyld_aot_image_info_64* p = _firstAotImage; p < _curAotImage; ++p) {
+ if (!callback(p->x86LoadAddress, p->aotLoadAddress, p->aotImageSize, (uint8_t*)p->aotImageKey, sizeof(p->aotImageKey))) {
+ break;
+ }
+ }
+}
+#endif
void dyld_process_info_base::forEachSegment(uint64_t machHeaderAddress, void (^callback)(uint64_t segmentAddress, uint64_t segmentSize, const char* segmentName)) const
{
for (const ImageInfo* p = _firstImage; p < _curImage; ++p) {
if ( p->loadAddress == machHeaderAddress ) {
uint64_t slide = 0;
- for (int i=0; i < p->segmentsCount; ++i) {
+ for (uint32_t i=0; i < p->segmentsCount; ++i) {
const SegmentInfo* seg = &_firstSegment[p->segmentStartIndex+i];
if ( strcmp(seg->name, "__TEXT") == 0 ) {
slide = machHeaderAddress - seg->addr;
break;
}
}
- for (int i=0; i < p->segmentsCount; ++i) {
+ for (uint32_t i=0; i < p->segmentsCount; ++i) {
const SegmentInfo* seg = &_firstSegment[p->segmentStartIndex+i];
callback(seg->addr + slide, seg->size, seg->name);
}
@@ -503,163 +802,48 @@
}
}
-
-
-
-
-// Implementation that works with existing dyld data structures
-static dyld_process_info _dyld_process_info_create_inner(task_t task, uint64_t timestamp, kern_return_t* kr)
-{
- if ( kr != NULL )
- *kr = KERN_SUCCESS;
+dyld_process_info _dyld_process_info_create(task_t task, uint64_t timestamp, kern_return_t* kr)
+{
+ __block dyld_process_info result = nullptr;
+ kern_return_t krSink = KERN_SUCCESS;
+ if (kr == nullptr) {
+ kr = &krSink;
+ }
+ *kr = KERN_SUCCESS;
task_dyld_info_data_t task_dyld_info;
mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
if ( kern_return_t r = task_info(task, TASK_DYLD_INFO, (task_info_t)&task_dyld_info, &count) ) {
- if ( kr != NULL )
- *kr = r;
- return NULL;
+ *kr = r;
+ return nullptr;
}
//The kernel will return MACH_VM_MIN_ADDRESS for an executable that has not had dyld loaded
- if (task_dyld_info.all_image_info_addr == MACH_VM_MIN_ADDRESS)
- return NULL;
-
- if ( task_dyld_info.all_image_info_size > sizeof(dyld_all_image_infos_64) )
- return NULL;
-
- // read all_image_infos struct
- dyld_all_image_infos_64 allImageInfo64;
- mach_vm_size_t readSize = task_dyld_info.all_image_info_size;
- if ( kern_return_t r = mach_vm_read_overwrite(task, task_dyld_info.all_image_info_addr, task_dyld_info.all_image_info_size, (vm_address_t)&allImageInfo64, &readSize) ) {
- if ( kr != NULL )
- *kr = r;
- return NULL;
- }
- if ( allImageInfo64.infoArrayCount == 0 ) {
- // could be task was launch suspended or still launching, wait a moment to see
- usleep(1000 * 50); // 50ms
- if ( kern_return_t r = mach_vm_read_overwrite(task, task_dyld_info.all_image_info_addr, task_dyld_info.all_image_info_size, (vm_address_t)&allImageInfo64, &readSize) ) {
- if ( kr != NULL )
- *kr = r;
- return NULL;
- }
- // if infoArrayCount is still zero, then target was most likely launched suspended
- if ( allImageInfo64.infoArrayCount == 0 )
- return dyld_process_info_base::makeSuspended(task, kr);
- }
-
- // bail out of dyld is too old
- if ( allImageInfo64.version < 15 ) {
- if ( kr != NULL )
- *kr = KERN_INVALID_HOST;
- return NULL;
- }
-
- // normalize by expanding 32-bit all_image_infos into 64-bit one
- uint32_t imageCount = allImageInfo64.infoArrayCount;
- size_t imageArraySize = imageCount * sizeof(dyld_image_info_64);
- if ( task_dyld_info.all_image_info_format == TASK_DYLD_ALL_IMAGE_INFO_32 ) {
- const dyld_all_image_infos_32* allImageInfo32 = (dyld_all_image_infos_32*)&allImageInfo64;
- dyld_all_image_infos_64 info64;
- bzero(&info64, sizeof(info64));
- info64.version = allImageInfo32->version;
- info64.infoArrayCount = allImageInfo32->infoArrayCount;
- info64.infoArray = allImageInfo32->infoArray;
- info64.processDetachedFromSharedRegion = allImageInfo32->processDetachedFromSharedRegion;
- info64.libSystemInitialized = allImageInfo32->libSystemInitialized;
- info64.dyldImageLoadAddress = allImageInfo32->dyldImageLoadAddress;
- info64.initialImageCount = allImageInfo32->initialImageCount;
- info64.uuidArrayCount = allImageInfo32->uuidArrayCount;
- info64.uuidArray = allImageInfo32->uuidArray;
- info64.dyldAllImageInfosAddress = allImageInfo32->dyldAllImageInfosAddress;
- info64.sharedCacheSlide = allImageInfo32->sharedCacheSlide;
- info64.infoArrayChangeTimestamp = allImageInfo32->infoArrayChangeTimestamp;
- info64.sharedCacheBaseAddress = allImageInfo32->sharedCacheBaseAddress;
- info64.dyldPath = allImageInfo32->dyldPath;
- memcpy((void*)(info64.sharedCacheUUID), (void*)(allImageInfo32->sharedCacheUUID), 16);
- allImageInfo64 = info64;
- imageCount = allImageInfo64.infoArrayCount;
- imageArraySize = imageCount * sizeof(dyld_image_info_32);
- }
-
- // don't do any (more) work if target process's dyld timestamp has not changed since previous query
- if ( (timestamp != 0) && (timestamp == allImageInfo64.infoArrayChangeTimestamp) ) {
- if ( kr != NULL )
- *kr = KERN_SUCCESS;
- return NULL;
- }
-
- // For the moment we are going to truncate any image list longer than 8192 because some programs do
- // terrible things that corrupt their own image lists and we need to stop clients from crashing
- // reading them. We can try to do something more advanced in the future. rdar://27446361
- imageCount = MIN(imageCount, 8192);
-
- // read image array
- if ( allImageInfo64.infoArray == 0 ) {
- // dyld is in middle of updating image list, try again
- return NULL;
- }
- dyld_image_info_64 imageArray64[imageCount];
- if ( kern_return_t r = mach_vm_read_overwrite(task, allImageInfo64.infoArray, imageArraySize, (vm_address_t)&imageArray64, &readSize) ) {
- // if image array moved, try whole thing again
- if ( kr != NULL ) {
- *kr = r;
- }
- return NULL;
- }
- // normalize by expanding 32-bit image_infos into 64-bit ones
- if ( task_dyld_info.all_image_info_format == TASK_DYLD_ALL_IMAGE_INFO_32 ) {
- const dyld_image_info_32* imageArray32 = (dyld_image_info_32*)&imageArray64;
- dyld_image_info_64 tempArray[imageCount];
- for (uint32_t i=0; i < imageCount; ++i) {
- tempArray[i].imageLoadAddress = imageArray32[i].imageLoadAddress;
- tempArray[i].imageFilePath = imageArray32[i].imageFilePath;
- tempArray[i].imageFileModDate = imageArray32[i].imageFileModDate;
- }
- memcpy(imageArray64, tempArray, sizeof(dyld_image_info_64)*imageCount);
- }
-
- // create object based on local copy of all image infos and image array
- dyld_process_info result = dyld_process_info_base::make(task, allImageInfo64, imageArray64, kr);
-
- // verify nothing has changed by re-reading all_image_infos struct and checking timestamp
- if ( result != NULL ) {
- dyld_all_image_infos_64 allImageInfo64again;
- readSize = task_dyld_info.all_image_info_size;
- if ( kern_return_t r = mach_vm_read_overwrite(task, task_dyld_info.all_image_info_addr, task_dyld_info.all_image_info_size, (vm_address_t)&allImageInfo64again, &readSize) ) {
- if ( kr != NULL )
- *kr = r;
- free((void*)result);
- return NULL;
- }
- uint64_t doneTimeStamp = allImageInfo64again.infoArrayChangeTimestamp;
- if ( task_dyld_info.all_image_info_format == TASK_DYLD_ALL_IMAGE_INFO_32 ) {
- const dyld_all_image_infos_32* allImageInfo32 = (dyld_all_image_infos_32*)&allImageInfo64again;
- doneTimeStamp = allImageInfo32->infoArrayChangeTimestamp;
- }
- if ( allImageInfo64.infoArrayChangeTimestamp != doneTimeStamp ) {
- // image list has changed since we started reading it
- // throw out what we have and start over
- free((void*)result);
- result = nullptr;
- }
- }
-
- return result;
-}
-
-
-dyld_process_info _dyld_process_info_create(task_t task, uint64_t timestamp, kern_return_t* kr)
-{
- // Other process may be loading and unloading as we read its memory, which can cause a read failure
- // <rdar://problem30067343&29567679> Retry if something fails
- for (int i=0; i < 100; ++i) {
- if ( dyld_process_info result = _dyld_process_info_create_inner( task, timestamp, kr) )
- return result;
-
- }
- return NULL;
+ if (task_dyld_info.all_image_info_addr == MACH_VM_MIN_ADDRESS) {
+ *kr = KERN_FAILURE;
+ return nullptr;
+ }
+
+ for (auto i = 0; i < 10; ++i) {
+ withRemoteBuffer(task, task_dyld_info.all_image_info_addr, (size_t)task_dyld_info.all_image_info_size, false, kr, ^(void *buffer, size_t size) {
+ dyld_process_info_ptr base;
+ if (task_dyld_info.all_image_info_format == TASK_DYLD_ALL_IMAGE_INFO_32 ) {
+ const dyld_all_image_infos_32* info = (const dyld_all_image_infos_32*)buffer;
+ base = dyld_process_info_base::make<dyld_all_image_infos_32, dyld_image_info_32>(task, *info, timestamp, kr);
+ } else {
+ const dyld_all_image_infos_64* info = (const dyld_all_image_infos_64*)buffer;
+ base = dyld_process_info_base::make<dyld_all_image_infos_64, dyld_image_info_64>(task, *info, timestamp, kr);
+ }
+ if (base) {
+ if (result) {
+ free((void*)result);
+ }
+ result = base.release();
+ }
+ });
+ if (kr == KERN_SUCCESS) { break; }
+ }
+ return result;
}
void _dyld_process_info_get_state(dyld_process_info info, dyld_process_state_info* stateInfo)
@@ -672,16 +856,23 @@
*cacheInfo = *info->cacheInfo();
}
-void _dyld_process_info_retain(dyld_process_info info)
-{
- info->retainCount() += 1;
-}
-
-void _dyld_process_info_release(dyld_process_info info)
-{
- info->retainCount() -= 1;
- if ( info->retainCount() == 0 )
- free((void*)info);
+void _dyld_process_info_get_aot_cache(dyld_process_info info, dyld_process_aot_cache_info* aotCacheInfo)
+{
+ *aotCacheInfo = *info->aotCacheInfo();
+}
+
+void _dyld_process_info_retain(dyld_process_info object)
+{
+ const_cast<dyld_process_info_base*>(object)->retain();
+}
+
+dyld_platform_t _dyld_process_info_get_platform(dyld_process_info object) {
+ return const_cast<dyld_process_info_base*>(object)->platform();
+}
+
+void _dyld_process_info_release(dyld_process_info object)
+{
+ const_cast<dyld_process_info_base*>(object)->release();
}
void _dyld_process_info_for_each_image(dyld_process_info info, void (^callback)(uint64_t machHeaderAddress, const uuid_t uuid, const char* path))
@@ -689,6 +880,12 @@
info->forEachImage(callback);
}
+#if TARGET_OS_OSX
+void _dyld_process_info_for_each_aot_image(dyld_process_info info, bool (^callback)(uint64_t x86Address, uint64_t aotAddress, uint64_t aotSize, uint8_t* aotImageKey, size_t aotImageKeySize))
+{
+ info->forEachAotImage(callback);
+}
+#endif
void _dyld_process_info_for_each_segment(dyld_process_info info, uint64_t machHeaderAddress, void (^callback)(uint64_t segmentAddress, uint64_t segmentSize, const char* segmentName))
{