Loading...
--- dyld/dyld-1340/libdyld/dyld_process_info.cpp
+++ dyld/dyld-960/libdyld/dyld_process_info.cpp
@@ -22,9 +22,6 @@
* @APPLE_LICENSE_HEADER_END@
*/
-#include <TargetConditionals.h>
-#if !TARGET_OS_EXCLAVEKIT
-
#include <dlfcn.h>
#include <stdlib.h>
#include <string.h>
@@ -38,22 +35,13 @@
#include <libkern/OSAtomic.h>
#include <mach-o/dyld_process_info.h>
#include <mach-o/dyld_images.h>
-#include <mach-o/dyld_priv.h>
#include "MachOFile.h"
-#include "DyldSharedCache.h"
#include "dyld_process_info_internal.h"
#include "Tracing.h"
+#include "DebuggerSupport.h"
#include "DyldProcessConfig.h"
-#include "StringUtils.h"
-#include "DyldLegacyInterfaceGlue.h"
-#include "SafeVMPrimitives.h"
-
-extern "C" const dyld_all_image_infos* getProcessDyldInfo();
-
-#define BLEND_KERN_RETURN_LOCATION(kr, loc) (kr) = ((kr & 0x00ffffff) | loc<<24);
-
-#define IMAGE_COUNT_MAX 8192
+
RemoteBuffer& RemoteBuffer::operator=(RemoteBuffer&& other) {
std::swap(_localAddress, other._localAddress);
std::swap(_size, other._size);
@@ -70,17 +58,29 @@
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 __arm64e__
- // Mask out TBI bits
- remote_address &= 0x00ff'ffff'ffff'ffffUL;
+#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 = mach_vm_remap_new(mach_task_self(),
+ auto kr = mvrn(mach_task_self(),
&localAddress,
size,
0, // mask
@@ -93,7 +93,6 @@
VM_INHERIT_NONE);
// The call is not succesfull return
if (kr != KERN_SUCCESS) {
- BLEND_KERN_RETURN_LOCATION(kr, 0xfd)
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
@@ -102,15 +101,12 @@
// 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 + 1);
+ 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);
}
- remote_memory_audit_start();
memcpy(buffer, (void *)localAddress, size);
- remote_memory_audit_end();
- ((char*)buffer)[size] = 0; // Add a null terminator so strlcpy does not read base the end of the buffer.
(void)vm_deallocate(mach_task_self(), (vm_address_t)localAddress, size);
return std::make_pair((vm_address_t)buffer, KERN_SUCCESS);
}
@@ -128,8 +124,7 @@
// 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) {
- // Manually set to 4096 instead of page size to deal with wierd issues involving 4k page arm64 binaries
- size = 4096 - remote_address%4096;
+ 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);
}
@@ -181,7 +176,7 @@
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, uint64_t timestamp, kern_return_t* kr);
+ 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); }
@@ -231,15 +226,15 @@
dyld_process_info_base(dyld_platform_t platform, unsigned imageCount, unsigned aotImageCount, size_t totalSize);
void* operator new (size_t, void* buf) { return buf; }
- kern_return_t addImage(task_t task, bool sameCacheAsThisProcess, uint64_t sharedCacheStart, uint64_t sharedCacheEnd, uint64_t imageAddress, uint64_t imagePath, const char* imagePathLocal,
- uint32_t imageIndex);
-
- kern_return_t addAotImage(dyld_aot_image_info_64 aotImageInfo);
+ static bool inCache(uint64_t addr) { return (addr > SHARED_REGION_BASE) && (addr < SHARED_REGION_BASE+SHARED_REGION_SIZE); }
+ 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, kern_return_t* kr, uint64_t pathAddr);
+ const char* copyPath(task_t task, uint64_t pathAddr);
const char* addString(const char*, size_t);
const char* copySegmentName(const char*);
@@ -274,20 +269,13 @@
// char stringPool[]
};
-static uint32_t addWithOverflowOrReturnZero(uint32_t a, uint32_t b)
-{
- uint32_t result = 0;
- assert( !__builtin_add_overflow(a, b, &result) );
- return result;
-}
-
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)),
- _aotCacheInfoOffset(_cacheInfoOffset + sizeof(dyld_process_cache_info)),
- _stateInfoOffset(_aotCacheInfoOffset + sizeof(dyld_process_aot_cache_info)),
- _imageInfosOffset(_stateInfoOffset + sizeof(dyld_process_state_info)),
- _aotImageInfosOffset(addWithOverflowOrReturnZero(_imageInfosOffset, imageCount*sizeof(ImageInfo))),
- _segmentInfosOffset(addWithOverflowOrReturnZero(_aotImageInfosOffset, aotImageCount*sizeof(dyld_aot_image_info_64))),
+ _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)),
@@ -298,7 +286,6 @@
_curSegmentIndex(0),
_stringRevBumpPtr((char*)(this)+totalSize)
{
-
}
template<typename T1, typename T2>
@@ -313,16 +300,8 @@
}
// Check if the process is suspended
- bool shouldMakeSuspended = (allImageInfo.infoArrayChangeTimestamp == 0);
- if ( !shouldMakeSuspended ) {
- if ( (allImageInfo.infoArray == 0)
- && (allImageInfo.sharedCacheBaseAddress != 0)
- && ((uintptr_t)allImageInfo.dyldImageLoadAddress > allImageInfo.sharedCacheBaseAddress) )
- shouldMakeSuspended = true;
- }
- if (shouldMakeSuspended) {
- result = dyld_process_info_base::makeSuspended<T1>(task, allImageInfo,
- allImageInfo.infoArrayChangeTimestamp, kr);
+ 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
@@ -330,9 +309,7 @@
}
usleep(1000 * 50); // 50ms
// Not exactly correct, but conveys that operation may succeed in the future
- if (*kr == KERN_SUCCESS) {
- *kr = KERN_RESOURCE_SHORTAGE;
- }
+ *kr = KERN_RESOURCE_SHORTAGE;
return nullptr;
}
@@ -347,7 +324,7 @@
if (infoArray == 0) {
usleep(1000 * 50); // 50ms
// Not exactly correct, but conveys that operation may succeed in the future
- *kr = KERN_UREFS_OVERFLOW;
+ *kr = KERN_RESOURCE_SHORTAGE;
return nullptr;
};
@@ -355,52 +332,28 @@
// 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, IMAGE_COUNT_MAX);
+ imageCount = MIN(imageCount, 8192);
size_t imageArraySize = imageCount * sizeof(T2);
-
- uint64_t sharedCacheStart = 0;
- uint64_t sharedCacheEnd = 0;
- size_t sharedCacheLength = 0;
- if ( const void* start = _dyld_get_shared_cache_range(&sharedCacheLength) ) {
- sharedCacheStart = (uint64_t)start;
- sharedCacheEnd = sharedCacheStart + (uint64_t)sharedCacheLength;
- }
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 = getProcessDyldInfo(); // FIXME: should not need dyld_all_image_info
- const bool sameCacheAsThisProcess = true
- && (myInfo != nullptr)
- && (allImageInfo.sharedCacheBaseAddress != 0)
- && (myInfo->sharedCacheBaseAddress != 0)
- && !allImageInfo.processDetachedFromSharedRegion
+ const dyld_all_image_infos* myInfo = (const dyld_all_image_infos*)dyld4::gDyld.allImageInfos;
+ bool sameCacheAsThisProcess = !allImageInfo.processDetachedFromSharedRegion
&& !myInfo->processDetachedFromSharedRegion
&& ((memcmp(myInfo->sharedCacheUUID, &allImageInfo.sharedCacheUUID[0], 16) == 0)
&& (myInfo->sharedCacheSlide == allImageInfo.sharedCacheSlide));
unsigned countOfPathsNeedingCopying = 0;
- // If constexpr is basically superfluous, we only do it to avoid compiler warnings...
- // The only time when sizeof(T2().imageFilePath) != sizeof(void*) is when a 64 bit process is introspecting a 32 bit process
- // or vice versa, and in those cases sameCacheAsThisProcess will be false. The issue is the compiler can't know that which
- // forces it to build the code, which results in the case from imageArray[i].imageFilePath to a (void*) to generate a warning.
- // By using the constexpr check here we can elide compiling that case and the warning, which prevents -Werror failues.
- if constexpr(sizeof(T2().imageFilePath) == sizeof(void*)) {
- const DyldSharedCache* dyldCacheHeader = (DyldSharedCache*)sharedCacheStart;
- if ( sameCacheAsThisProcess && dyldCacheHeader != nullptr) {
- bool readOnly = false;
- for (uint32_t i=0; i < imageCount; ++i) {
- if ( !dyldCacheHeader->inCache((void*)imageArray[i].imageFilePath, 1, readOnly) || !readOnly )
- ++countOfPathsNeedingCopying;
- }
- }
- else {
- countOfPathsNeedingCopying = imageCount+1;
- }
- } else {
+ if ( sameCacheAsThisProcess ) {
+ for (uint32_t i=0; i < imageCount; ++i) {
+ if ( !inCache(imageArray[i].imageFilePath) )
+ ++countOfPathsNeedingCopying;
+ }
+ }
+ else {
countOfPathsNeedingCopying = imageCount+1;
}
unsigned imageCountWithDyld = imageCount+1;
- unsigned aotImageCount = MIN(allImageInfo.aotInfoCount, IMAGE_COUNT_MAX);
// allocate result object
size_t allocationSize = sizeof(dyld_process_info_base)
@@ -408,7 +361,7 @@
+ sizeof(dyld_process_aot_cache_info)
+ sizeof(dyld_process_state_info)
+ sizeof(ImageInfo)*(imageCountWithDyld)
- + sizeof(dyld_aot_image_info_64)*(aotImageCount) // add the size necessary for aot info to this buffer
+ + 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);
@@ -464,8 +417,8 @@
}
// fill in info for each image
for (uint32_t i=0; i < imageCount; ++i) {
- *kr = info->addImage(task, sameCacheAsThisProcess, sharedCacheStart, sharedCacheEnd, imageArray[i].imageLoadAddress, imageArray[i].imageFilePath, NULL, i);
- if (*kr != KERN_SUCCESS) {
+ if (!info->addImage(task, sameCacheAsThisProcess, imageArray[i].imageLoadAddress, imageArray[i].imageFilePath, NULL)) {
+ *kr = KERN_FAILURE;
result = nullptr;
return;
}
@@ -490,7 +443,8 @@
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 ((*kr = result->addAotImage(imageArray[i]))) {
+ if (!result->addAotImage(imageArray[i])) {
+ *kr = KERN_FAILURE;
result = nullptr;
return;
}
@@ -501,8 +455,7 @@
}
template<typename T>
-dyld_process_info_ptr dyld_process_info_base::makeSuspended(task_t task, const T& allImageInfo,
- uint64_t timestamp, kern_return_t* kr)
+dyld_process_info_ptr dyld_process_info_base::makeSuspended(task_t task, const T& allImageInfo, kern_return_t* kr)
{
pid_t pid;
if ((*kr = pid_for_task(task, &pid))) {
@@ -512,26 +465,12 @@
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))) {
- *kr = KERN_NO_SPACE;
- BLEND_KERN_RETURN_LOCATION(*kr, 0xfc)
return nullptr;
}
// The task is not suspended, exit
if (ti.suspend_count == 0) {
- // Even if the process is not suspended it might never make forward progress. This is because it might be a corpse, which
- // despite not being runnable may not have the suspended flag set. The only way to tell if it is a corpse is to to try to
- // map the corpse data, even though we don't actually need the corpse data
- mach_vm_address_t kcd_addr_begin = 0;
- mach_vm_size_t kcd_size = 0;
- *kr = task_map_corpse_info_64(mach_task_self(), task, &kcd_addr_begin, &kcd_size);
- if (*kr != KERN_SUCCESS) {
- BLEND_KERN_RETURN_LOCATION(*kr, 0xfb)
- // Not a corpse, so forward progress is possible. Return so that make() can pause and retry
- return nullptr;
- }
- // It is a corpse. Unmap the corpse info and keep scavenging the suspended process
- vm_deallocate(mach_task_self(), (vm_address_t)kcd_addr_begin, (vm_size_t)kcd_size);
+ return nullptr;
}
__block unsigned imageCount = 0; // main executable and dyld
@@ -541,10 +480,8 @@
char mainExecutablePathBuffer[PATH_MAX+1];
__block char * dyldPath = &dyldPathBuffer[0];
__block char * mainExecutablePath = &mainExecutablePathBuffer[0];
- mach_vm_size_t size;
- dyldPathBuffer[0] = '\0';
- mainExecutablePathBuffer[0] = '\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;
@@ -563,18 +500,16 @@
if ( mhBuffer.filetype == MH_EXECUTE ) {
mainExecutableAddress = address;
int len = proc_regionfilename(pid, mainExecutableAddress, mainExecutablePath, PATH_MAX);
- // explicitly clear the path if call failed
- if ( len <= 0 ) {
- strlcpy(mainExecutablePath, "/main_executable_path_missing", 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);
- // explicitly clear the path if call failed
- if ( len <= 0 ) {
- strlcpy(dyldPath, "/dyld_path_missing", PATH_MAX);
+ if ( len != 0 ) {
+ dyldPath[len] = '\0';
}
++imageCount;
}
@@ -584,15 +519,6 @@
//fprintf(stderr, "dyld: addr=0x%llX, path=%s\n", dyldAddress, dyldPathBuffer);
//fprintf(stderr, "app: addr=0x%llX, path=%s\n", mainExecutableAddress, mainExecutablePathBuffer);
- // fill in info for dyld
- if ( dyldAddress == 0 ) {
- // if dyld was not found in vm walk, then we've switched to the dyld in the cache
- dyldAddress = allImageInfo.dyldImageLoadAddress;
- strcpy(dyldPathBuffer, "/usr/lib/dyld");
- ++imageCount;
- }
-
- imageCount = MIN(imageCount, IMAGE_COUNT_MAX);
// explicitly set aot image count to 0 in the suspended case
unsigned aotImageCount = 0;
@@ -608,10 +534,9 @@
void* storage = malloc(allocationSize);
if (storage == nullptr) {
*kr = KERN_NO_SPACE;
- BLEND_KERN_RETURN_LOCATION(*kr, 0xfa)
return nullptr;
}
- auto obj = dyld_process_info_ptr(new (storage) dyld_process_info_base(PLATFORM_UNKNOWN, imageCount, aotImageCount, allocationSize), deleter);
+ 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();
@@ -626,11 +551,12 @@
aotCacheInfo->cacheBaseAddress = 0;
dyld_process_state_info* stateInfo = obj->stateInfo();
- stateInfo->timestamp = timestamp;
+ stateInfo->timestamp = 0;
stateInfo->imageCount = imageCount;
stateInfo->initialImageCount = imageCount;
stateInfo->dyldState = dyld_process_state_not_started;
+ // fill in info for dyld
if ( dyldAddress != 0 ) {
if ((*kr = obj->addDyldImage(task, dyldAddress, 0, dyldPath))) {
return nullptr;
@@ -639,13 +565,22 @@
// fill in info for each image
if ( mainExecutableAddress != 0 ) {
- if ((*kr = obj->addImage(task, false, 0, 0, mainExecutableAddress, 0, mainExecutablePath, 0))) {
+ if (!obj->addImage(task, false, mainExecutableAddress, 0, mainExecutablePath)) {
return nullptr;
}
}
- if (allImageInfo.infoArrayChangeTimestamp != timestamp) {
- *kr = KERN_INVALID_VALUE;
+ 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;
}
@@ -664,76 +599,43 @@
return _stringRevBumpPtr;
}
-const char* dyld_process_info_base::copyPath(task_t task, kern_return_t *kr, uint64_t stringAddressInTask)
+const char* dyld_process_info_base::copyPath(task_t task, uint64_t stringAddressInTask)
{
__block const char* retval = "";
- withRemoteBuffer(task, stringAddressInTask, PATH_MAX, true, kr, ^(void *buffer, size_t size) {
+ withRemoteBuffer(task, stringAddressInTask, PATH_MAX, true, nullptr, ^(void *buffer, size_t size) {
retval = addString(static_cast<const char *>(buffer), size);
});
return retval;
}
-static char sCrashReporterInfo[4096];
-
-static void checkPath(const char* path, uint64_t pathAddress, uint32_t imageIndex)
-{
- if ( path[0] != '/' ) {
- // Set the crash reporter info to help work out why we pass non-UTF8 strings to CS
- snprintf(sCrashReporterInfo, sizeof(sCrashReporterInfo), "dyld: found non-UTF8 string on image[%d]: 0x%llx [ ", imageIndex, pathAddress);
- for ( char c : std::string_view(path, strnlen(path, 8)) ) {
- char buffer[8];
- bytesToHex((uint8_t*)&c, 1, buffer);
- strlcat(sCrashReporterInfo, buffer, sizeof(sCrashReporterInfo));
- strlcat(sCrashReporterInfo, " ", sizeof(sCrashReporterInfo));
- }
-
- strlcat(sCrashReporterInfo, " ]\n", sizeof(sCrashReporterInfo));
-
- CRSetCrashLogMessage2(sCrashReporterInfo);
- }
-}
-
-kern_return_t dyld_process_info_base::addImage(task_t task, bool sameCacheAsThisProcess, uint64_t sharedCacheStart, uint64_t sharedCacheEnd,
- uint64_t imageAddress, uint64_t imagePath, const char* imagePathLocal,
- uint32_t imageIndex)
-{
- const DyldSharedCache* dyldCacheHeader = (DyldSharedCache*)sharedCacheStart;
- bool readOnly = false;
+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, PATH_MAX);
- } else if ( sameCacheAsThisProcess && dyldCacheHeader != nullptr && dyldCacheHeader->inCache((void*)imagePath, 1, readOnly) && readOnly ) {
+ } else if ( sameCacheAsThisProcess && inCache(imagePath) ) {
_curImage->path = (const char*)imagePath;
} else if (imagePath) {
- kern_return_t kr = KERN_SUCCESS;
- _curImage->path = copyPath(task, &kr, imagePath);
- if ( kr != KERN_SUCCESS ) {
- return kr;
- }
+ _curImage->path = copyPath(task, imagePath);
} else {
- _curImage->path = addString("/<unknown>", PATH_MAX);
- }
-
- checkPath(_curImage->path, imagePath, imageIndex);
-
- if ( sameCacheAsThisProcess && dyldCacheHeader != nullptr && dyldCacheHeader->inCache((void*)imageAddress, 32*1024, readOnly) ) {
+ _curImage->path = "";
+ }
+
+ if ( sameCacheAsThisProcess && inCache(imageAddress) ) {
addInfoFromLoadCommands((mach_header*)imageAddress, imageAddress, 32*1024);
- } else {
- auto kr = addInfoFromRemoteLoadCommands(task, imageAddress);
- if (kr != KERN_SUCCESS) {
- // The image is not here, return early
- return kr;
- }
+ } 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;
-}
-
-kern_return_t dyld_process_info_base::addAotImage(dyld_aot_image_info_64 aotImageInfo) {
+ return true;
+}
+
+bool dyld_process_info_base::addAotImage(dyld_aot_image_info_64 aotImageInfo) {
if (!reserveSpace(sizeof(dyld_aot_image_info_64))) {
- return KERN_NO_SPACE;
+ return false;
}
_curAotImage->x86LoadAddress = aotImageInfo.x86LoadAddress;
_curAotImage->aotLoadAddress = aotImageInfo.aotLoadAddress;
@@ -741,7 +643,7 @@
memcpy(_curAotImage->aotImageKey, aotImageInfo.aotImageKey, sizeof(aotImageInfo.aotImageKey));
_curAotImage++;
- return KERN_SUCCESS;
+ return true;
}
kern_return_t dyld_process_info_base::addInfoFromRemoteLoadCommands(task_t task, uint64_t remoteMH) {
@@ -750,7 +652,7 @@
__block bool done = false;
//Since the minimum we can reasonably map is a page, map that.
- withRemoteBuffer(task, remoteMH, 4096, true, &kr, ^(void * buffer, size_t size) {
+ withRemoteBuffer(task, remoteMH, PAGE_SIZE, true, &kr, ^(void * buffer, size_t size) {
if (size > sizeof(mach_header)) {
const mach_header* mh = (const mach_header*)buffer;
headerPagesSize = sizeof(mach_header) + mh->sizeofcmds;
@@ -783,12 +685,10 @@
_curImage->path = addString(localPath, PATH_MAX);
}
else {
- _curImage->path = copyPath(task, &kr, dyldPathAddress);
+ _curImage->path = copyPath(task, dyldPathAddress);
if ( kr != KERN_SUCCESS)
return kr;
}
-
- checkPath(_curImage->path, dyldPathAddress, ~0U);
kr = addInfoFromRemoteLoadCommands(task, dyldAddress);
if ( kr != KERN_SUCCESS)
@@ -864,18 +764,7 @@
void dyld_process_info_base::forEachImage(void (^callback)(uint64_t machHeaderAddress, const uuid_t uuid, const char* path)) const
{
for (const ImageInfo* p = _firstImage; p < _curImage; ++p) {
- // Set a temporary to hold a log message. We will always switch back to the original value before the scope ends, so it can live on the stack
- char asiBuffer[1024];
- const char* oldLogMessage = CRGetCrashLogMessage();
- if (p->loadAddress == 0 || p->path == nullptr) {
- // Set an ASI for debugging. Unfortunately we don't have much state here, so let's grab what we have that is meaingful which will hopefully
- // let us figure out why this is sometimes set incorrectly.
- snprintf(&asiBuffer[0], 1024, "Bad dyld_proces_info image info for\n\tplatform: %u\n\taddress = 0x%llx\n\tpath = %s\n",
- _platform, p->loadAddress, p->path ? p->path : "(null)");
- CRSetCrashLogMessage(asiBuffer);
- }
callback(p->loadAddress, p->uuid, p->path);
- CRSetCrashLogMessage(oldLogMessage);
}
}
@@ -914,9 +803,6 @@
dyld_process_info _dyld_process_info_create(task_t task, uint64_t timestamp, kern_return_t* kr)
{
- if ( const IntrospectionVtable* vtable = dyldFrameworkIntrospectionVtable() ) {
- return vtable->_dyld_process_info_create(task, timestamp, kr);
- }
__block dyld_process_info result = nullptr;
kern_return_t krSink = KERN_SUCCESS;
if (kr == nullptr) {
@@ -928,14 +814,12 @@
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) ) {
*kr = r;
- BLEND_KERN_RETURN_LOCATION(*kr, 0xff);
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) {
*kr = KERN_FAILURE;
- BLEND_KERN_RETURN_LOCATION(*kr, 0xfe);
return nullptr;
}
@@ -957,89 +841,55 @@
}
});
if (*kr == KERN_SUCCESS) { break; }
- // possible that dyld moved, causing imageinfo reads to fail, so get TASK_DYLD_INFO again
- task_dyld_info_data_t task_dyld_info2;
- mach_msg_type_number_t count2 = TASK_DYLD_INFO_COUNT;
- if ( task_info(task, TASK_DYLD_INFO, (task_info_t)&task_dyld_info2, &count2) == KERN_SUCCESS ) {
- task_dyld_info = task_dyld_info2;
- }
}
return result;
}
void _dyld_process_info_get_state(dyld_process_info info, dyld_process_state_info* stateInfo)
{
- if ( const IntrospectionVtable* vtable = dyldFrameworkIntrospectionVtable() ) {
- return vtable->_dyld_process_info_get_state(info, stateInfo);
- }
*stateInfo = *info->stateInfo();
}
void _dyld_process_info_get_cache(dyld_process_info info, dyld_process_cache_info* cacheInfo)
{
- if ( const IntrospectionVtable* vtable = dyldFrameworkIntrospectionVtable() ) {
- return vtable->_dyld_process_info_get_cache(info, cacheInfo);
- }
*cacheInfo = *info->cacheInfo();
}
void _dyld_process_info_get_aot_cache(dyld_process_info info, dyld_process_aot_cache_info* aotCacheInfo)
{
- if ( const IntrospectionVtable* vtable = dyldFrameworkIntrospectionVtable() ) {
- return vtable->_dyld_process_info_get_aot_cache(info, aotCacheInfo);
- }
*aotCacheInfo = *info->aotCacheInfo();
}
void _dyld_process_info_retain(dyld_process_info object)
{
- if ( const IntrospectionVtable* vtable = dyldFrameworkIntrospectionVtable() ) {
- return vtable->_dyld_process_info_retain(object);
- }
const_cast<dyld_process_info_base*>(object)->retain();
}
dyld_platform_t _dyld_process_info_get_platform(dyld_process_info object) {
- if ( const IntrospectionVtable* vtable = dyldFrameworkIntrospectionVtable() ) {
- return vtable->_dyld_process_info_get_platform(object);
- }
return const_cast<dyld_process_info_base*>(object)->platform();
}
void _dyld_process_info_release(dyld_process_info object)
{
- if ( const IntrospectionVtable* vtable = dyldFrameworkIntrospectionVtable() ) {
- return vtable->_dyld_process_info_release(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))
{
- if ( const IntrospectionVtable* vtable = dyldFrameworkIntrospectionVtable() ) {
- return vtable->_dyld_process_info_for_each_image(info, callback);
- }
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))
{
- if ( const IntrospectionVtable* vtable = dyldFrameworkIntrospectionVtable() ) {
- return vtable->_dyld_process_info_for_each_aot_image(info, callback);
- }
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))
{
- if ( const IntrospectionVtable* vtable = dyldFrameworkIntrospectionVtable() ) {
- return vtable->_dyld_process_info_for_each_segment(info, machHeaderAddress, callback);
- }
info->forEachSegment(machHeaderAddress, callback);
}
-#endif // !TARGET_OS_EXCLAVEKIT
-
-
+
+