Loading...
--- dyld/dyld-852.2/dyld3/Loading.cpp
+++ dyld/dyld-640.2/dyld3/Loading.cpp
@@ -39,26 +39,21 @@
#include <System/sys/mman.h>
#include <System/sys/csr.h>
#include <System/machine/cpu_capabilities.h>
-#if !TARGET_OS_SIMULATOR && !TARGET_OS_DRIVERKIT
+#include <bootstrap.h>
+#include <CommonCrypto/CommonDigest.h>
#include <sandbox.h>
#include <sandbox/private.h>
-#endif
-//#include <dispatch/dispatch.h>
+#include <dispatch/dispatch.h>
#include <mach/vm_page_size.h>
-#include "ClosureFileSystemPhysical.h"
#include "MachOFile.h"
#include "MachOLoaded.h"
-#include "MachOAnalyzer.h"
#include "Logging.h"
#include "Loading.h"
-#include "RootsChecker.h"
#include "Tracing.h"
-#include "dyld2.h"
+#include "dyld.h"
#include "dyld_cache_format.h"
-#include "libdyldEntryVector.h"
-
-#include "objc-shared-cache.h"
+
namespace dyld {
void log(const char* m, ...);
@@ -103,61 +98,24 @@
namespace dyld3 {
-Loader::Loader(const Array<LoadedImage>& existingImages, Array<LoadedImage>& newImagesStorage,
- const void* cacheAddress, const Array<const dyld3::closure::ImageArray*>& imagesArrays,
- const closure::ObjCSelectorOpt* selOpt, const Array<closure::Image::ObjCSelectorImage>& selImages,
- const RootsChecker& rootsChecker, dyld3::Platform platform,
- LogFunc logLoads, LogFunc logSegments, LogFunc logFixups, LogFunc logDof,
- bool allowMissingLazies, dyld3::LaunchErrorInfo* launchErrorInfo)
- : _existingImages(existingImages), _newImages(newImagesStorage),
- _imagesArrays(imagesArrays), _dyldCacheAddress(cacheAddress), _dyldCacheSelectorOpt(nullptr),
- _closureSelectorOpt(selOpt), _closureSelectorImages(selImages),
- _rootsChecker(rootsChecker), _allowMissingLazies(allowMissingLazies), _platform(platform),
- _logLoads(logLoads), _logSegments(logSegments), _logFixups(logFixups), _logDofs(logDof), _launchErrorInfo(launchErrorInfo)
-
-{
-#if BUILDING_DYLD
- // This is only needed for dyld and the launch closure, not the dlopen closures
- if ( _dyldCacheAddress != nullptr ) {
- _dyldCacheSelectorOpt = ((const DyldSharedCache*)_dyldCacheAddress)->objcOpt()->selopt();
- }
-#endif
+Loader::Loader(Array<LoadedImage>& storage, const void* cacheAddress, const Array<const dyld3::closure::ImageArray*>& imagesArrays,
+ LogFunc logLoads, LogFunc logSegments, LogFunc logFixups, LogFunc logDofs)
+ : _allImages(storage), _imagesArrays(imagesArrays), _dyldCacheAddress(cacheAddress),
+ _logLoads(logLoads), _logSegments(logSegments), _logFixups(logFixups), _logDofs(logDofs)
+{
}
void Loader::addImage(const LoadedImage& li)
{
- _newImages.push_back(li);
-}
-
-LoadedImage* Loader::findImage(closure::ImageNum targetImageNum) const
-{
-#if BUILDING_DYLD
- // The launch images are different in dyld vs libdyld. In dyld, the new images are
- // the launch images, while in libdyld, the existing images are the launch images
- if (LoadedImage* info = _launchImagesCache.findImage(targetImageNum, _newImages)) {
- return info;
- }
-
- for (uintptr_t index = 0; index != _newImages.count(); ++index) {
- LoadedImage& info = _newImages[index];
- if ( info.image()->representsImageNum(targetImageNum) ) {
- // Try cache this entry for next time
- _launchImagesCache.tryAddImage(targetImageNum, index);
- return &info;
- }
- }
-#elif BUILDING_LIBDYLD
- for (const LoadedImage& info : _existingImages) {
- if ( info.image()->representsImageNum(targetImageNum) )
- return (LoadedImage*)&info;
- }
- for (LoadedImage& info : _newImages) {
+ _allImages.push_back(li);
+}
+
+LoadedImage* Loader::findImage(closure::ImageNum targetImageNum)
+{
+ for (LoadedImage& info : _allImages) {
if ( info.image()->representsImageNum(targetImageNum) )
return &info;
}
-#else
-#error Must be building dyld or libdyld
-#endif
return nullptr;
}
@@ -185,23 +143,17 @@
}
-void Loader::completeAllDependents(Diagnostics& diag, bool& someCacheImageOverridden)
-{
- bool iOSonMac = (_platform == Platform::iOSMac);
-#if (TARGET_OS_OSX && TARGET_CPU_ARM64)
- if ( _platform == Platform::iOS )
- iOSonMac = true;
-#endif
- // accumulate all image overrides (512 is placeholder for max unzippered twins in dyld cache)
- STACK_ALLOC_ARRAY(ImageOverride, overrides, _existingImages.maxCount() + _newImages.maxCount() + 512);
+void Loader::completeAllDependents(Diagnostics& diag, uintptr_t topIndex)
+{
+ // accumulate all image overrides
+ STACK_ALLOC_ARRAY(ImageOverride, overrides, _allImages.maxCount());
for (const auto anArray : _imagesArrays) {
- // ignore prebuilt Image* in dyld cache, except for MacCatalyst apps where unzipped twins can override each other
- if ( (anArray->startImageNum() < dyld3::closure::kFirstLaunchClosureImageNum) && !iOSonMac )
+ // ignore prebuilt Image* in dyld cache
+ if ( anArray->startImageNum() < dyld3::closure::kFirstLaunchClosureImageNum )
continue;
anArray->forEachImage(^(const dyld3::closure::Image* image, bool& stop) {
ImageOverride overrideEntry;
if ( image->isOverrideOfDyldCacheImage(overrideEntry.inCache) ) {
- someCacheImageOverridden = true;
overrideEntry.replacement = image->imageNum();
overrides.push_back(overrideEntry);
}
@@ -210,16 +162,15 @@
// make cache for fast lookup of already loaded images
__block ImageNumSet alreadyLoaded;
- for (const LoadedImage& info : _existingImages) {
- alreadyLoaded.add(info.image()->imageNum());
- }
- alreadyLoaded.add(_newImages.begin()->image()->imageNum());
-
- // for each image in _newImages, starting at the top image, make sure its dependents are in _allImages
- uintptr_t index = 0;
- while ( (index < _newImages.count()) && diag.noError() ) {
- const closure::Image* image = _newImages[index].image();
- //dyld::log("completeAllDependents(): looking at dependents of %s\n", image->path());
+ for (int i=0; i <= topIndex; ++i) {
+ alreadyLoaded.add(_allImages[i].image()->imageNum());
+ }
+
+ // for each image in _allImages, starting at topIndex, make sure its depenents are in _allImages
+ uintptr_t index = topIndex;
+ while ( (index < _allImages.count()) && diag.noError() ) {
+ const closure::Image* image = _allImages[index].image();
+ //fprintf(stderr, "completeAllDependents(): looking at dependents of %s\n", image->path());
image->forEachDependentImage(^(uint32_t depIndex, closure::Image::LinkKind kind, closure::ImageNum depImageNum, bool& stop) {
// check if imageNum needs to be changed to an override
for (const ImageOverride& entry : overrides) {
@@ -233,13 +184,13 @@
// if not, look in imagesArrays
const closure::Image* depImage = closure::ImageArray::findImage(_imagesArrays, depImageNum);
if ( depImage != nullptr ) {
- //dyld::log(" load imageNum=0x%05X, image path=%s\n", depImageNum, depImage->path());
- if ( _newImages.freeCount() == 0 ) {
+ //dyld::log(" load imageNum=0x%05X, image path=%s\n", depImageNum, depImage->path());
+ if ( _allImages.freeCount() == 0 ) {
diag.error("too many initial images");
stop = true;
}
else {
- _newImages.push_back(LoadedImage::make(depImage));
+ _allImages.push_back(LoadedImage::make(depImage));
}
alreadyLoaded.add(depImageNum);
}
@@ -253,18 +204,16 @@
}
}
-void Loader::mapAndFixupAllImages(Diagnostics& diag, bool processDOFs, bool fromOFI, bool* closureOutOfDate, bool* recoverable)
-{
- *closureOutOfDate = false;
- *recoverable = true;
-
+void Loader::mapAndFixupAllImages(Diagnostics& diag, bool processDOFs, bool fromOFI, uintptr_t topIndex)
+{
// scan array and map images not already loaded
- for (LoadedImage& info : _newImages) {
+ for (uintptr_t i=topIndex; i < _allImages.count(); ++i) {
+ LoadedImage& info = _allImages[i];
if ( info.loadedAddress() != nullptr ) {
// log main executable's segments
if ( (info.loadedAddress()->filetype == MH_EXECUTE) && (info.state() == LoadedImage::State::mapped) ) {
if ( _logSegments("dyld: mapped by kernel %s\n", info.image()->path()) ) {
- info.image()->forEachDiskSegment(^(uint32_t segIndex, uint32_t fileOffset, uint32_t fileSize, int64_t vmOffset, uint64_t vmSize, uint8_t permissions, bool laterReadOnly, bool& stop) {
+ info.image()->forEachDiskSegment(^(uint32_t segIndex, uint32_t fileOffset, uint32_t fileSize, int64_t vmOffset, uint64_t vmSize, uint8_t permissions, bool& stop) {
uint64_t start = (long)info.loadedAddress() + vmOffset;
uint64_t end = start+vmSize-1;
if ( (segIndex == 0) && (permissions == 0) ) {
@@ -282,21 +231,21 @@
if ( info.image()->inDyldCache() ) {
if ( info.image()->overridableDylib() ) {
struct stat statBuf;
- if ( dyld3::stat(info.image()->path(), &statBuf) == 0 ) {
- dyld3::closure::FileSystemPhysical fileSystem;
- if ( _rootsChecker.onDiskFileIsRoot(info.image()->path(), (const DyldSharedCache*)_dyldCacheAddress, info.image(),
- &fileSystem, statBuf.st_ino, statBuf.st_mtime) ) {
- if ( ((const DyldSharedCache*)_dyldCacheAddress)->header.dylibsExpectedOnDisk ) {
+ if ( stat(info.image()->path(), &statBuf) == 0 ) {
+ // verify file has not changed since closure was built
+ uint64_t inode;
+ uint64_t mtime;
+ if ( info.image()->hasFileModTimeAndInode(inode, mtime) ) {
+ if ( (statBuf.st_mtime != mtime) || (statBuf.st_ino != inode) ) {
diag.error("dylib file mtime/inode changed since closure was built for '%s'", info.image()->path());
- } else {
- diag.error("dylib file not expected on disk, must be a root '%s'", info.image()->path());
}
- *closureOutOfDate = true;
+ }
+ else {
+ diag.error("dylib file not expected on disk, must be a root '%s'", info.image()->path());
}
}
else if ( (_dyldCacheAddress != nullptr) && ((dyld_cache_header*)_dyldCacheAddress)->dylibsExpectedOnDisk ) {
diag.error("dylib file missing, was in dyld shared cache '%s'", info.image()->path());
- *closureOutOfDate = true;
}
}
if ( diag.noError() ) {
@@ -312,28 +261,29 @@
}
}
else {
- mapImage(diag, info, fromOFI, closureOutOfDate);
+ mapImage(diag, info, fromOFI);
if ( diag.hasError() )
break; // out of for loop
}
}
- if ( diag.hasError() ) {
- // need to clean up by unmapping any images just mapped
- unmapAllImages();
+ if ( diag.hasError() ) {
+ // bummer, need to clean up by unmapping any images just mapped
+ for (LoadedImage& info : _allImages) {
+ if ( (info.state() == LoadedImage::State::mapped) && !info.image()->inDyldCache() && !info.leaveMapped() ) {
+ _logSegments("dyld: unmapping %s\n", info.image()->path());
+ unmapImage(info);
+ }
+ }
return;
}
- // apply fixups to all but main executable
- LoadedImage* mainInfo = nullptr;
- for (LoadedImage& info : _newImages) {
+ // apply fixups
+ for (uintptr_t i=topIndex; i < _allImages.count(); ++i) {
+ LoadedImage& info = _allImages[i];
// images in shared cache do not need fixups applied
if ( info.image()->inDyldCache() )
continue;
- if ( info.loadedAddress()->filetype == MH_EXECUTE ) {
- mainInfo = &info;
- continue;
- }
// previously loaded images were previously fixed up
if ( info.state() < LoadedImage::State::fixedUp ) {
applyFixupsToImage(diag, info);
@@ -342,31 +292,12 @@
info.setState(LoadedImage::State::fixedUp);
}
}
- if ( diag.hasError() ) {
- // need to clean up by unmapping any images just mapped
- unmapAllImages();
- return;
- }
-
- if ( mainInfo != nullptr ) {
- // now apply fixups to main executable
- // we do it in this order so that if there is a problem with the dylibs in the closure
- // the main executable is left untouched so the closure can be rebuilt
- applyFixupsToImage(diag, *mainInfo);
- if ( diag.hasError() ) {
- // need to clean up by unmapping any images just mapped
- unmapAllImages();
- // we have already started fixing up the main executable, so we cannot retry the launch again
- *recoverable = false;
- return;
- }
- mainInfo->setState(LoadedImage::State::fixedUp);
- }
// find and register dtrace DOFs
if ( processDOFs ) {
- STACK_ALLOC_OVERFLOW_SAFE_ARRAY(DOFInfo, dofImages, _newImages.count());
- for (LoadedImage& info : _newImages) {
+ STACK_ALLOC_OVERFLOW_SAFE_ARRAY(DOFInfo, dofImages, _allImages.count());
+ for (uintptr_t i=topIndex; i < _allImages.count(); ++i) {
+ LoadedImage& info = _allImages[i];
info.image()->forEachDOF(info.loadedAddress(), ^(const void* section) {
DOFInfo dofInfo;
dofInfo.dof = section;
@@ -379,21 +310,9 @@
}
}
-void Loader::unmapAllImages()
-{
- for (LoadedImage& info : _newImages) {
- if ( !info.image()->inDyldCache() && !info.leaveMapped() ) {
- if ( (info.state() == LoadedImage::State::mapped) || (info.state() == LoadedImage::State::fixedUp) ) {
- _logSegments("dyld: unmapping %s\n", info.image()->path());
- unmapImage(info);
- }
- }
- }
-}
-
bool Loader::sandboxBlocked(const char* path, const char* kind)
{
-#if TARGET_OS_SIMULATOR || TARGET_OS_DRIVERKIT
+#if TARGET_IPHONE_SIMULATOR
// sandbox calls not yet supported in dyld_sim
return false;
#else
@@ -417,7 +336,7 @@
return sandboxBlocked(path, "file-read-metadata");
}
-void Loader::mapImage(Diagnostics& diag, LoadedImage& info, bool fromOFI, bool* closureOutOfDate)
+void Loader::mapImage(Diagnostics& diag, LoadedImage& info, bool fromOFI)
{
dyld3::ScopedTimer timer(DBG_DYLD_TIMING_MAP_IMAGE, info.image()->path(), 0, 0);
@@ -429,7 +348,7 @@
bool isCodeSigned = image->hasCodeSignature(codeSignFileOffset, codeSignFileSize);
// open file
- int fd = dyld3::open(info.image()->path(), O_RDONLY, 0);
+ int fd = ::open(info.image()->path(), O_RDONLY, 0);
if ( fd == -1 ) {
int openErr = errno;
if ( (openErr == EPERM) && sandboxBlockedOpen(image->path()) )
@@ -441,8 +360,8 @@
// get file info
struct stat statBuf;
-#if TARGET_OS_SIMULATOR
- if ( dyld3::stat(image->path(), &statBuf) != 0 ) {
+#if TARGET_IPHONE_SIMULATOR
+ if ( stat(image->path(), &statBuf) != 0 ) {
#else
if ( fstat(fd, &statBuf) != 0 ) {
#endif
@@ -461,7 +380,6 @@
if ( image->hasFileModTimeAndInode(inode, mtime) ) {
if ( (statBuf.st_mtime != mtime) || (statBuf.st_ino != inode) ) {
diag.error("file mtime/inode changed since closure was built for '%s'", image->path());
- *closureOutOfDate = true;
close(fd);
return;
}
@@ -474,23 +392,6 @@
// file is now thin
sliceOffset = 0;
}
- }
- }
-
- if ( isCodeSigned && (sliceOffset == 0) ) {
- uint64_t expectedFileSize = round_page_kernel(codeSignFileOffset+codeSignFileSize);
- uint64_t actualFileSize = round_page_kernel(statBuf.st_size);
- if ( actualFileSize < expectedFileSize ) {
- diag.error("File size too small for code signature");
- *closureOutOfDate = true;
- close(fd);
- return;
- }
- if ( actualFileSize != expectedFileSize ) {
- diag.error("File size doesn't match code signature");
- *closureOutOfDate = true;
- close(fd);
- return;
}
}
@@ -508,13 +409,6 @@
if ( (errnoCopy == EPERM) || (errnoCopy == EBADEXEC) ) {
diag.error("code signature invalid (errno=%d) sliceOffset=0x%08llX, codeBlobOffset=0x%08X, codeBlobSize=0x%08X for '%s'",
errnoCopy, sliceOffset, codeSignFileOffset, codeSignFileSize, image->path());
-#if BUILDING_LIBDYLD
- if ( errnoCopy == EBADEXEC ) {
- // dlopen closures many be prebuilt in to the shared cache with a code signature, but the dylib is replaced
- // with one without a code signature. In that case, lets build a new closure
- *closureOutOfDate = true;
- }
-#endif
}
else {
diag.error("fcntl(fd, F_ADDFILESIGS_RETURN) failed with errno=%d, sliceOffset=0x%08llX, codeBlobOffset=0x%08X, codeBlobSize=0x%08X for '%s'",
@@ -563,12 +457,11 @@
_logSegments("dyld: Mapping %s\n", image->path());
// map each segment
- __block bool mmapFailure = false;
+ __block bool mmapFailure = false;
__block const uint8_t* codeSignatureStartAddress = nullptr;
__block const uint8_t* linkeditEndAddress = nullptr;
- __block bool mappedFirstSegment = false;
- __block uint64_t maxFileOffset = 0;
- image->forEachDiskSegment(^(uint32_t segIndex, uint32_t fileOffset, uint32_t fileSize, int64_t vmOffset, uint64_t vmSize, uint8_t permissions, bool laterReadOnly, bool& stop) {
+ __block bool mappedFirstSegment = false;
+ image->forEachDiskSegment(^(uint32_t segIndex, uint32_t fileOffset, uint32_t fileSize, int64_t vmOffset, uint64_t vmSize, uint8_t permissions, bool& stop) {
// <rdar://problem/32363581> Mapping zero filled segments fails with mmap of size 0
if ( fileSize == 0 )
return;
@@ -606,7 +499,6 @@
(permissions & PROT_READ) ? 'r' : '.', (permissions & PROT_WRITE) ? 'w' : '.', (permissions & PROT_EXEC) ? 'x' : '.' ,
(long)segAddress, (long)segAddress+(long)vmSize-1);
}
- maxFileOffset = fileOffset + fileSize;
});
if ( mmapFailure ) {
::vm_deallocate(mach_task_self(), loadAddress, (vm_size_t)totalVMSize);
@@ -614,72 +506,38 @@
return;
}
- // <rdar://problem/47163421> speculatively read whole slice
- fspecread_t specread = {} ;
- specread.fsr_offset = sliceOffset;
- specread.fsr_length = maxFileOffset;
- specread.fsr_flags = 0;
- fcntl(fd, F_SPECULATIVE_READ, &specread);
- _logSegments("dyld: Speculatively read offset=0x%08llX, len=0x%08llX, path=%s\n", sliceOffset, maxFileOffset, image->path());
-
// close file
close(fd);
#if BUILDING_LIBDYLD
// verify file has not changed since closure was built by checking code signature has not changed
- struct CDHashWrapper {
- uint8_t cdHash[20];
- };
-
- // Get all the hashes for the image
- STACK_ALLOC_OVERFLOW_SAFE_ARRAY(CDHashWrapper, expectedCDHashes, 1);
- image->forEachCDHash(^(const uint8_t *cdHash, bool &stop) {
- CDHashWrapper cdHashWrapper;
- memcpy(cdHashWrapper.cdHash, cdHash, sizeof(CDHashWrapper::cdHash));
- expectedCDHashes.push_back(cdHashWrapper);
- });
-
- if (!expectedCDHashes.empty()) {
- if (expectedCDHashes.count() != 1) {
- // We should only see a single hash for dylibs
- diag.error("code signature count invalid");
- } else if ( codeSignatureStartAddress == nullptr ) {
+ uint8_t cdHashExpected[20];
+ if ( image->hasCdHash(cdHashExpected) ) {
+ if ( codeSignatureStartAddress == nullptr ) {
diag.error("code signature missing");
}
else if ( codeSignatureStartAddress+codeSignFileSize > linkeditEndAddress ) {
diag.error("code signature extends beyond end of __LINKEDIT");
}
else {
- // Get all the cd hashes for the macho
- STACK_ALLOC_OVERFLOW_SAFE_ARRAY(CDHashWrapper, foundCDHashes, 1);
+ uint8_t cdHashFound[20];
const MachOLoaded* lmo = (MachOLoaded*)loadAddress;
- lmo->forEachCDHashOfCodeSignature(codeSignatureStartAddress, codeSignFileSize,
- ^(const uint8_t *cdHash) {
- CDHashWrapper cdHashWrapper;
- memcpy(cdHashWrapper.cdHash, cdHash, sizeof(CDHashWrapper::cdHash));
- foundCDHashes.push_back(cdHashWrapper);
- });
-
- if (foundCDHashes.empty()) {
+ if ( lmo->cdHashOfCodeSignature(codeSignatureStartAddress, codeSignFileSize, cdHashFound) ) {
+ if ( ::memcmp(cdHashFound, cdHashExpected, 20) != 0 )
+ diag.error("code signature changed since closure was built");
+ }
+ else {
diag.error("code signature format invalid");
- } else if (expectedCDHashes.count() != foundCDHashes.count()) {
- diag.error("code signature count invalid");
- } else {
- // We found a hash, so make sure its equal.
- if ( ::memcmp(foundCDHashes[0].cdHash, expectedCDHashes[0].cdHash, 20) != 0 )
- diag.error("code signature changed since closure was built");
}
}
if ( diag.hasError() ) {
- *closureOutOfDate = true;
::vm_deallocate(mach_task_self(), loadAddress, (vm_size_t)totalVMSize);
return;
}
}
-
-#endif
-
-#if (__arm__ || __arm64__) && !TARGET_OS_SIMULATOR
+#endif
+
+#if __IPHONE_OS_VERSION_MIN_REQUIRED && !TARGET_IPHONE_SIMULATOR
// tell kernel about fairplay encrypted regions
uint32_t fpTextOffset;
uint32_t fpSize;
@@ -713,7 +571,7 @@
if ( dofs.empty() )
return;
- int fd = ::open("/dev/" DTRACEMNR_HELPER, O_RDWR);
+ int fd = open("/dev/" DTRACEMNR_HELPER, O_RDWR);
if ( fd < 0 ) {
_logDofs("can't open /dev/" DTRACEMNR_HELPER " to register dtrace DOF sections\n");
}
@@ -751,18 +609,23 @@
bool Loader::dtraceUserProbesEnabled()
{
-#if !TARGET_OS_SIMULATOR
- uint8_t dofEnabled = *((uint8_t*)_COMM_PAGE_DTRACE_DOF_ENABLED);
- return ( (dofEnabled & 1) );
+#if __IPHONE_OS_VERSION_MIN_REQUIRED && !TARGET_IPHONE_SIMULATOR
+ int dof_mode;
+ size_t dof_mode_size = sizeof(dof_mode);
+ if ( sysctlbyname("kern.dtrace.dof_mode", &dof_mode, &dof_mode_size, nullptr, 0) == 0 ) {
+ return ( dof_mode != 0 );
+ }
+ return false;
#else
- return false;
+ // dtrace is always available for macOS and simulators
+ return true;
#endif
}
void Loader::vmAccountingSetSuspended(bool suspend, LogFunc logger)
{
-#if TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR
+#if __arm__ || __arm64__
// <rdar://problem/29099600> dyld should tell the kernel when it is doing fix-ups caused by roots
logger("vm.footprint_suspend=%d\n", suspend);
int newValue = suspend ? 1 : 0;
@@ -773,21 +636,6 @@
#endif
}
-static const char* targetString(const MachOAnalyzerSet::FixupTarget& target)
-{
- switch (target.kind ) {
- case MachOAnalyzerSet::FixupTarget::Kind::rebase:
- return "rebase";
- case MachOAnalyzerSet::FixupTarget::Kind::bindAbsolute:
- return "abolute";
- case MachOAnalyzerSet::FixupTarget::Kind::bindToImage:
- return target.foundSymbolName;
- case MachOAnalyzerSet::FixupTarget::Kind::bindMissingSymbol:
- return "missing";
- }
- return "";
-}
-
void Loader::applyFixupsToImage(Diagnostics& diag, LoadedImage& info)
{
dyld3::ScopedTimer timer(DBG_DYLD_TIMING_APPLY_FIXUPS, (uint64_t)info.loadedAddress(), 0, 0);
@@ -797,204 +645,78 @@
const uint8_t* imageLoadAddress = (uint8_t*)info.loadedAddress();
uintptr_t slide = info.loadedAddress()->getSlide();
bool overrideOfCache = info.image()->isOverrideOfDyldCacheImage(cacheImageNum);
-
if ( overrideOfCache )
vmAccountingSetSuspended(true, _logFixups);
- if ( image->fixupsNotEncoded() ) {
- // make the cache writable for this block
- // We do this lazily, only if we find a symbol which needs to be overridden
- DyldSharedCache::DataConstLazyScopedWriter patcher((const DyldSharedCache*)_dyldCacheAddress, mach_task_self(), (DyldSharedCache::DataConstLogFunc)_logSegments);
- auto* patcherPtr = &patcher;
-
- WrappedMachO wmo((MachOAnalyzer*)info.loadedAddress(), this, (void*)info.image());
- wmo.forEachFixup(diag,
- ^(uint64_t fixupLocRuntimeOffset, PointerMetaData pmd, const FixupTarget& target, bool& stop) {
- uintptr_t* fixUpLoc = (uintptr_t*)(imageLoadAddress + fixupLocRuntimeOffset);
- uintptr_t value;
- switch ( target.kind ) {
- case MachOAnalyzerSet::FixupTarget::Kind::rebase:
- case MachOAnalyzerSet::FixupTarget::Kind::bindToImage:
- value = (uintptr_t)(target.foundInImage._mh) + target.offsetInImage;
- break;
- case MachOAnalyzerSet::FixupTarget::Kind::bindAbsolute:
- value = (uintptr_t)target.offsetInImage;
- break;
- case MachOAnalyzerSet::FixupTarget::Kind::bindMissingSymbol:
- if ( _launchErrorInfo ) {
- _launchErrorInfo->kind = DYLD_EXIT_REASON_SYMBOL_MISSING;
- _launchErrorInfo->clientOfDylibPath = info.image()->path();
- _launchErrorInfo->targetDylibPath = target.foundInImage.path();
- _launchErrorInfo->symbol = target.requestedSymbolName;
- }
- // we have no value to set, and forEachFixup() is about to finish
- return;
- }
- #if __has_feature(ptrauth_calls)
- if ( pmd.authenticated )
- value = MachOLoaded::ChainedFixupPointerOnDisk::Arm64e::signPointer(value, fixUpLoc, pmd.usesAddrDiversity, pmd.diversity, pmd.key);
+ image->forEachFixup(^(uint64_t imageOffsetToRebase, bool &stop) {
+ uintptr_t* fixUpLoc = (uintptr_t*)(imageLoadAddress + imageOffsetToRebase);
+ *fixUpLoc += slide;
+ _logFixups("dyld: fixup: %s:%p += %p\n", leafName, fixUpLoc, (void*)slide);
+ },
+ ^(uint64_t imageOffsetToBind, closure::Image::ResolvedSymbolTarget bindTarget, bool &stop) {
+ uintptr_t* fixUpLoc = (uintptr_t*)(imageLoadAddress + imageOffsetToBind);
+ uintptr_t value = resolveTarget(bindTarget);
+ _logFixups("dyld: fixup: %s:%p = %p\n", leafName, fixUpLoc, (void*)value);
+ *fixUpLoc = value;
+ },
+ ^(uint64_t imageOffsetStart, const Array<closure::Image::ResolvedSymbolTarget>& targets, bool& stop) {
+ // walk each fixup in the chain
+ image->forEachChainedFixup((void*)imageLoadAddress, imageOffsetStart, ^(uint64_t* fixupLoc, MachOLoaded::ChainedFixupPointerOnDisk fixupInfo, bool& stopChain) {
+ if ( fixupInfo.authRebase.auth ) {
+ #if __has_feature(ptrauth_calls)
+ if ( fixupInfo.authBind.bind ) {
+ closure::Image::ResolvedSymbolTarget bindTarget = targets[fixupInfo.authBind.ordinal];
+ uint64_t targetAddr = resolveTarget(bindTarget);
+ // Don't sign missing weak imports.
+ if (targetAddr != 0)
+ targetAddr = fixupInfo.signPointer(fixupLoc, targetAddr);
+ _logFixups("dyld: fixup: *%p = %p (JOP: diversity 0x%04X, addr-div=%d, key=%s)\n",
+ fixupLoc, (void*)targetAddr, fixupInfo.authBind.diversity, fixupInfo.authBind.addrDiv, fixupInfo.authBind.keyName());
+ *fixupLoc = targetAddr;
+ }
+ else {
+ uint64_t targetAddr = (uint64_t)imageLoadAddress + fixupInfo.authRebase.target;
+ targetAddr = fixupInfo.signPointer(fixupLoc, targetAddr);
+ _logFixups("dyld: fixup: *%p = %p (JOP: diversity 0x%04X, addr-div=%d, key=%s)\n",
+ fixupLoc, (void*)targetAddr, fixupInfo.authRebase.diversity, fixupInfo.authRebase.addrDiv, fixupInfo.authRebase.keyName());
+ *fixupLoc = targetAddr;
+ }
+ #else
+ diag.error("malformed chained pointer");
+ stop = true;
+ stopChain = true;
#endif
- if ( pmd.high8 )
- value |= ((uint64_t)pmd.high8 << 56);
- _logFixups("dyld: fixup: %s:%p = %p (%s)\n", leafName, fixUpLoc, (void*)value, targetString(target));
- *fixUpLoc = value;
- },
- ^(uint32_t cachedDylibIndex, uint32_t exportCacheOffset, const FixupTarget& target) {
-#if BUILDING_LIBDYLD && __x86_64__
- // Full dlopen closures don't patch weak defs. Bail out early if we are libdyld to match this behaviour
- return;
-#endif
- patcherPtr->makeWriteable();
- ((const DyldSharedCache*)_dyldCacheAddress)->forEachPatchableUseOfExport(cachedDylibIndex, exportCacheOffset, ^(dyld_cache_patchable_location patchLoc) {
- uintptr_t* loc = (uintptr_t*)(((uint8_t*)_dyldCacheAddress)+patchLoc.cacheOffset);
- uintptr_t newImpl = (uintptr_t)(target.foundInImage._mh) + target.offsetInImage + DyldSharedCache::getAddend(patchLoc);
- #if __has_feature(ptrauth_calls)
- if ( patchLoc.authenticated )
- newImpl = MachOLoaded::ChainedFixupPointerOnDisk::Arm64e::signPointer(newImpl, loc, patchLoc.usesAddressDiversity, patchLoc.discriminator, patchLoc.key);
- #endif
- // ignore duplicate patch entries
- if ( *loc != newImpl ) {
- _logFixups("dyld: cache patch: %p = 0x%0lX\n", loc, newImpl);
- *loc = newImpl;
- }
- });
+ }
+ else {
+ if ( fixupInfo.plainRebase.bind ) {
+ closure::Image::ResolvedSymbolTarget bindTarget = targets[fixupInfo.plainBind.ordinal];
+ uint64_t targetAddr = resolveTarget(bindTarget) + fixupInfo.plainBind.signExtendedAddend();
+ _logFixups("dyld: fixup: %s:%p = %p\n", leafName, fixupLoc, (void*)targetAddr);
+ *fixupLoc = targetAddr;
+ }
+ else {
+ uint64_t targetAddr = fixupInfo.plainRebase.signExtendedTarget() + slide;
+ _logFixups("dyld: fixup: %s:%p += %p\n", leafName, fixupLoc, (void*)slide);
+ *fixupLoc = targetAddr;
+ }
+ }
});
-#if BUILDING_LIBDYLD && TARGET_OS_OSX
- // <rdar://problem/59265987> support old licenseware plugins on macOS using minimal closures
- __block bool oldBinary = true;
- info.loadedAddress()->forEachSupportedPlatform(^(Platform platform, uint32_t minOS, uint32_t sdk) {
- if ( (platform == Platform::macOS) && (sdk >= 0x000A0F00) )
- oldBinary = false;
- });
- if ( oldBinary ) {
- // look for __DATA,__dyld section
- info.loadedAddress()->forEachSection(^(const MachOAnalyzer::SectionInfo& sectInfo, bool malformedSectionRange, bool& stop) {
- if ( (strcmp(sectInfo.sectName, "__dyld") == 0) && (strcmp(sectInfo.segInfo.segName, "__DATA") == 0) ) {
- // dyld_func_lookup is second pointer in __dyld section
- uintptr_t* dyldSection = (uintptr_t*)(sectInfo.sectAddr + (uintptr_t)info.loadedAddress());
- _logFixups("dyld: __dyld section: %p = %p\n", &dyldSection[1], &dyld3::compatFuncLookup);
- dyldSection[1] = (uintptr_t)&dyld3::compatFuncLookup;
- }
- });
- }
-#endif
- }
- else {
- if ( image->rebasesNotEncoded() ) {
- // <rdar://problem/56172089> some apps have so many rebases the closure file is too big, instead we go back to rebase opcodes
- ((MachOAnalyzer*)imageLoadAddress)->forEachRebase(diag, true, ^(uint64_t imageOffsetToRebase, bool& stop) {
- // this is a rebase, add slide
- uintptr_t* fixUpLoc = (uintptr_t*)(imageLoadAddress + imageOffsetToRebase);
- *fixUpLoc += slide;
- _logFixups("dyld: fixup: %s:%p += %p\n", leafName, fixUpLoc, (void*)slide);
- });
- }
- image->forEachFixup(^(uint64_t imageOffsetToRebase, bool& stop) {
- // this is a rebase, add slide
- uintptr_t* fixUpLoc = (uintptr_t*)(imageLoadAddress + imageOffsetToRebase);
- *fixUpLoc += slide;
- _logFixups("dyld: fixup: %s:%p += %p\n", leafName, fixUpLoc, (void*)slide);
- },
- ^(uint64_t imageOffsetToBind, closure::Image::ResolvedSymbolTarget bindTarget, bool& stop) {
- // this is a bind, set to target
- uintptr_t* fixUpLoc = (uintptr_t*)(imageLoadAddress + imageOffsetToBind);
- uintptr_t value = resolveTarget(bindTarget);
- _logFixups("dyld: fixup: %s:%p = %p\n", leafName, fixUpLoc, (void*)value);
- *fixUpLoc = value;
- },
- ^(uint64_t imageOffsetToStartsInfo, const Array<closure::Image::ResolvedSymbolTarget>& targets, bool& stop) {
- // this is a chain of fixups, fix up all
- STACK_ALLOC_OVERFLOW_SAFE_ARRAY(const void*, targetAddrs, 128);
- targetAddrs.reserve(targets.count());
- for (uint32_t i=0; i < targets.count(); ++i)
- targetAddrs.push_back((void*)resolveTarget(targets[i]));
- ((dyld3::MachOAnalyzer*)(info.loadedAddress()))->withChainStarts(diag, imageOffsetToStartsInfo, ^(const dyld_chained_starts_in_image* starts) {
- info.loadedAddress()->fixupAllChainedFixups(diag, starts, slide, targetAddrs, ^(void* loc, void* newValue) {
- _logFixups("dyld: fixup: %s:%p = %p\n", leafName, loc, newValue);
- });
- });
- },
- ^(uint64_t imageOffsetToFixup) {
- uintptr_t* fixUpLoc = (uintptr_t*)(imageLoadAddress + imageOffsetToFixup);
- _logFixups("dyld: fixup objc image info: %s Setting objc image info for precomputed objc\n", leafName);
-
- MachOAnalyzer::ObjCImageInfo *imageInfo = (MachOAnalyzer::ObjCImageInfo *)fixUpLoc;
- ((MachOAnalyzer::ObjCImageInfo *)imageInfo)->flags |= MachOAnalyzer::ObjCImageInfo::dyldPreoptimized;
- },
- ^(uint64_t imageOffsetToBind, closure::Image::ResolvedSymbolTarget bindTarget, bool& stop) {
- // this is a bind, set to target
- uintptr_t* fixUpLoc = (uintptr_t*)(imageLoadAddress + imageOffsetToBind);
- uintptr_t value = resolveTarget(bindTarget);
-#if __has_feature(ptrauth_calls)
- // Sign the ISA on arm64e.
- // Unfortunately a hard coded value here is not ideal, but this is ABI so we aren't going to change it
- // This matches the value in libobjc __objc_opt_ptrs: .quad x@AUTH(da, 27361, addr)
- value = MachOLoaded::ChainedFixupPointerOnDisk::Arm64e::signPointer(value, fixUpLoc, true, 27361, 2);
-#endif
- _logFixups("dyld: fixup objc protocol: %s:%p = %p\n", leafName, fixUpLoc, (void*)value);
- *fixUpLoc = value;
- },
- ^(uint64_t imageOffsetToFixup, uint32_t selectorIndex, bool inSharedCache, bool &stop) {
- // fixupObjCSelRefs
- closure::Image::ResolvedSymbolTarget fixupTarget;
- if ( inSharedCache ) {
- const char* selectorString = _dyldCacheSelectorOpt->getEntryForIndex(selectorIndex);
- fixupTarget.sharedCache.kind = closure::Image::ResolvedSymbolTarget::kindSharedCache;
- fixupTarget.sharedCache.offset = (uint64_t)selectorString - (uint64_t)_dyldCacheAddress;
- } else {
- closure::ImageNum imageNum;
- uint64_t vmOffset;
- bool gotLocation = _closureSelectorOpt->getStringLocation(selectorIndex, _closureSelectorImages, imageNum, vmOffset);
- assert(gotLocation);
- fixupTarget.image.kind = closure::Image::ResolvedSymbolTarget::kindImage;
- fixupTarget.image.imageNum = imageNum;
- fixupTarget.image.offset = vmOffset;
- }
- uintptr_t* fixUpLoc = (uintptr_t*)(imageLoadAddress + imageOffsetToFixup);
- uintptr_t value = resolveTarget(fixupTarget);
- _logFixups("dyld: fixup objc selector: %s:%p(was '%s') = %p(now '%s')\n", leafName, fixUpLoc, (const char*)*fixUpLoc, (void*)value, (const char*)value);
- *fixUpLoc = value;
- }, ^(uint64_t imageOffsetToFixup, bool &stop) {
- // fixupObjCStableSwift
- // Class really is stable Swift, pretending to be pre-stable.
- // Fix its lie.
- uintptr_t* fixUpLoc = (uintptr_t*)(imageLoadAddress + imageOffsetToFixup);
- uintptr_t value = ((*fixUpLoc) | MachOAnalyzer::ObjCClassInfo::FAST_IS_SWIFT_STABLE) & ~MachOAnalyzer::ObjCClassInfo::FAST_IS_SWIFT_LEGACY;
- _logFixups("dyld: fixup objc stable Swift: %s:%p = %p\n", leafName, fixUpLoc, (void*)value);
- *fixUpLoc = value;
- }, ^(uint64_t imageOffsetToFixup, bool &stop) {
- // fixupObjCMethodList
- // Set the method list to have the uniqued bit set
- uint32_t* fixUpLoc = (uint32_t*)(imageLoadAddress + imageOffsetToFixup);
- uint32_t value = (*fixUpLoc) | MachOAnalyzer::ObjCMethodList::methodListIsUniqued;
- _logFixups("dyld: fixup objc method list: %s:%p = 0x%08x\n", leafName, fixUpLoc, value);
- *fixUpLoc = value;
- });
+ });
#if __i386__
- __block bool segmentsMadeWritable = false;
- image->forEachTextReloc(^(uint32_t imageOffsetToRebase, bool& stop) {
- if ( !segmentsMadeWritable )
- setSegmentProtects(info, true);
- uintptr_t* fixUpLoc = (uintptr_t*)(imageLoadAddress + imageOffsetToRebase);
- *fixUpLoc += slide;
- _logFixups("dyld: fixup: %s:%p += %p\n", leafName, fixUpLoc, (void*)slide);
- },
- ^(uint32_t imageOffsetToBind, closure::Image::ResolvedSymbolTarget bindTarget, bool& stop) {
- // FIXME
- });
- if ( segmentsMadeWritable )
- setSegmentProtects(info, false);
-#endif
- }
-
- // make any read-only data segments read-only
- if ( image->hasReadOnlyData() && !image->inDyldCache() ) {
- image->forEachDiskSegment(^(uint32_t segIndex, uint32_t fileOffset, uint32_t fileSize, int64_t vmOffset, uint64_t vmSize, uint8_t permissions, bool laterReadOnly, bool& segStop) {
- if ( laterReadOnly ) {
- ::mprotect((void*)(imageLoadAddress+vmOffset), (size_t)vmSize, VM_PROT_READ);
- }
- });
- }
+ __block bool segmentsMadeWritable = false;
+ image->forEachTextReloc(^(uint32_t imageOffsetToRebase, bool& stop) {
+ if ( !segmentsMadeWritable )
+ setSegmentProtects(info, true);
+ uintptr_t* fixUpLoc = (uintptr_t*)(imageLoadAddress + imageOffsetToRebase);
+ *fixUpLoc += slide;
+ _logFixups("dyld: fixup: %s:%p += %p\n", leafName, fixUpLoc, (void*)slide);
+ },
+ ^(uint32_t imageOffsetToBind, closure::Image::ResolvedSymbolTarget bindTarget, bool& stop) {
+ // FIXME
+ });
+ if ( segmentsMadeWritable )
+ setSegmentProtects(info, false);
+#endif
if ( overrideOfCache )
vmAccountingSetSuspended(false, _logFixups);
@@ -1003,7 +725,7 @@
#if __i386__
void Loader::setSegmentProtects(const LoadedImage& info, bool write)
{
- info.image()->forEachDiskSegment(^(uint32_t segIndex, uint32_t fileOffset, uint32_t fileSize, int64_t vmOffset, uint64_t vmSize, uint8_t protections, bool laterReadOnly, bool& segStop) {
+ info.image()->forEachDiskSegment(^(uint32_t segIndex, uint32_t fileOffset, uint32_t fileSize, int64_t vmOffset, uint64_t vmSize, uint8_t protections, bool& segStop) {
if ( protections & VM_PROT_WRITE )
return;
uint32_t regionProt = protections;
@@ -1015,132 +737,7 @@
}
#endif
-
-void Loader::forEachImage(void (^handler)(const LoadedImage& li, bool& stop)) const
-{
- bool stop = false;
- for (const LoadedImage& li : _existingImages) {
- handler(li, stop);
- if ( stop )
- return;
- }
- for (const LoadedImage& li : _newImages) {
- handler(li, stop);
- if ( stop )
- return;
- }
-}
-
-void Loader::mas_forEachImage(void (^handler)(const WrappedMachO& wmo, bool hidden, bool& stop)) const
-{
- forEachImage(^(const LoadedImage& li, bool& stop) {
- WrappedMachO wmo((MachOAnalyzer*)li.loadedAddress(), this, (void*)li.image());
- handler(wmo, li.hideFromFlatSearch(), stop);
- });
-}
-
-
-bool Loader::wmo_missingSymbolResolver(const WrappedMachO* fromWmo, bool weakImport, bool lazyBind, const char* symbolName, const char* expectedInDylibPath, const char* clientPath, FixupTarget& target) const
-{
- if ( weakImport ) {
- target.offsetInImage = 0;
- target.kind = FixupTarget::Kind::bindAbsolute;
- return true;
- }
-
- if ( lazyBind && _allowMissingLazies ) {
- __block bool result = false;
- forEachImage(^(const LoadedImage& li, bool& stop) {
- if ( li.loadedAddress()->isDylib() && (strcmp(li.loadedAddress()->installName(), "/usr/lib/system/libdyld.dylib") == 0) ) {
- WrappedMachO libdyldWmo((MachOAnalyzer*)li.loadedAddress(), this, (void*)li.image());
- Diagnostics diag;
- if ( libdyldWmo.findSymbolIn(diag, "__dyld_missing_symbol_abort", 0, target) ) {
- // <rdar://problem/44315944> closures should bind missing lazy-bind symbols to a missing symbol handler in libdyld in flat namespace
- result = true;
- }
- stop = true;
- }
- });
- return result;
- }
-
- // FIXME
- return false;
-}
-
-
-void Loader::mas_mainExecutable(WrappedMachO& mainWmo) const
-{
- forEachImage(^(const LoadedImage& li, bool& stop) {
- if ( li.loadedAddress()->isMainExecutable() ) {
- WrappedMachO wmo((MachOAnalyzer*)li.loadedAddress(), this, (void*)li.image());
- mainWmo = wmo;
- stop = true;
- }
- });
-}
-
-void* Loader::mas_dyldCache() const
-{
- return (void*)_dyldCacheAddress;
-}
-
-
-bool Loader::wmo_dependent(const WrappedMachO* wmo, uint32_t depIndex, WrappedMachO& childWmo, bool& missingWeakDylib) const
-{
- const closure::Image* image = (closure::Image*)(wmo->_other);
- closure::ImageNum depImageNum = image->dependentImageNum(depIndex);
- if ( depImageNum == closure::kMissingWeakLinkedImage ) {
- missingWeakDylib = true;
- return true;
- }
- else {
- if ( LoadedImage* li = findImage(depImageNum) ) {
- WrappedMachO foundWmo((MachOAnalyzer*)li->loadedAddress(), this, (void*)li->image());
- missingWeakDylib = false;
- childWmo = foundWmo;
- return true;
- }
- }
- return false;
-}
-
-
-const char* Loader::wmo_path(const WrappedMachO* wmo) const
-{
- const closure::Image* image = (closure::Image*)(wmo->_other);
- return image->path();
-}
-
-
-
#if BUILDING_DYLD
-LoadedImage* Loader::LaunchImagesCache::findImage(closure::ImageNum imageNum,
- Array<LoadedImage>& images) const {
- if ( (imageNum < _firstImageNum) || (imageNum >= _lastImageNum) )
- return nullptr;
-
- unsigned int cacheIndex = imageNum - _firstImageNum;
- uint32_t imagesIndex = _imageIndices[cacheIndex];
- if ( imagesIndex == 0 )
- return nullptr;
-
- // Note the index is offset by 1 so that 0's are not yet set
- return &images[imagesIndex - 1];
-}
-
-void Loader::LaunchImagesCache::tryAddImage(closure::ImageNum imageNum, uint64_t allImagesIndex) const {
- if ( (imageNum < _firstImageNum) || (imageNum >= _lastImageNum) )
- return;
-
- unsigned int cacheIndex = imageNum - _firstImageNum;
-
- // Note the index is offset by 1 so that 0's are not yet set
- _imageIndices[cacheIndex] = (uint32_t)allImagesIndex + 1;
-}
- #endif
-
-
void forEachLineInFile(const char* buffer, size_t bufferLen, void (^lineHandler)(const char* line, bool& stop))
{
bool stop = false;
@@ -1163,7 +760,7 @@
void forEachLineInFile(const char* path, void (^lineHandler)(const char* line, bool& stop))
{
- int fd = dyld3::open(path, O_RDONLY, 0);
+ int fd = dyld::my_open(path, O_RDONLY, 0);
if ( fd != -1 ) {
struct stat statBuf;
if ( fstat(fd, &statBuf) == 0 ) {
@@ -1178,18 +775,87 @@
}
-#if (BUILDING_LIBDYLD || BUILDING_DYLD)
- bool internalInstall()
- {
-#if TARGET_OS_SIMULATOR
+bool internalInstall()
+{
+#if TARGET_IPHONE_SIMULATOR
+ return false;
+#elif __IPHONE_OS_VERSION_MIN_REQUIRED
+ uint32_t devFlags = *((uint32_t*)_COMM_PAGE_DEV_FIRM);
+ return ( (devFlags & 1) == 1 );
+#else
+ return ( csr_check(CSR_ALLOW_APPLE_INTERNAL) == 0 );
+#endif
+}
+
+/* Checks to see if there are any args that impact dyld. These args
+ * can be set sevaral ways. These will only be honored on development
+ * and Apple Internal builds.
+ *
+ * First the existence of a file is checked for:
+ * /S/L/C/com.apple.dyld/dyld-bootargs
+ * If it exists it will be mapped and scanned line by line. If the executable
+ * exists in the file then the arguments on its line will be applied. "*" may
+ * be used a wildcard to represent all apps. First matching line will be used,
+ * the wild card must be one the last line. Additionally, lines must end with
+ * a "\n"
+ *
+ *
+ * SAMPLE FILE:
+
+ /bin/ls:force_dyld2=1
+ /usr/bin/sw_vers:force_dyld2=1
+*:force_dyld3=1
+EOL
+
+ If no file exists then the kernel boot-args will be scanned.
+ */
+bool bootArgsContains(const char* arg)
+{
+ //FIXME: Use strnstr(). Unfortunately we are missing an imp libc.
+#if TARGET_IPHONE_SIMULATOR
+ return false;
+#else
+ // don't check for boot-args on customer installs
+ if ( !internalInstall() )
return false;
-#elif TARGET_OS_IPHONE
- uint32_t devFlags = *((uint32_t*)_COMM_PAGE_DEV_FIRM);
- return ( (devFlags & 1) == 1 );
+
+ char pathBuffer[MAXPATHLEN+1];
+#if __IPHONE_OS_VERSION_MIN_REQUIRED
+ strlcpy(pathBuffer, IPHONE_DYLD_SHARED_CACHE_DIR, sizeof(IPHONE_DYLD_SHARED_CACHE_DIR));
#else
- return ( csr_check(CSR_ALLOW_APPLE_INTERNAL) == 0 );
-#endif
- }
+ strlcpy(pathBuffer, MACOSX_DYLD_SHARED_CACHE_DIR, sizeof(MACOSX_DYLD_SHARED_CACHE_DIR));
+#endif
+ strlcat(pathBuffer, "dyld-bootargs", MAXPATHLEN+1);
+ __block bool result = false;
+ forEachLineInFile(pathBuffer, ^(const char* line, bool& stop) {
+ const char* delim = strchr(line, ':');
+ if ( delim == nullptr )
+ return;
+ char binary[MAXPATHLEN];
+ char options[MAXPATHLEN];
+ strlcpy(binary, line, MAXPATHLEN);
+ binary[delim-line] = '\0';
+ strlcpy(options, delim+1, MAXPATHLEN);
+ if ( (strcmp(dyld::getExecutablePath(), binary) == 0) || (strcmp("*", binary) == 0) ) {
+ result = (strstr(options, arg) != nullptr);
+ return;
+ }
+ });
+
+ // get length of full boot-args string
+ size_t len;
+ if ( sysctlbyname("kern.bootargs", NULL, &len, NULL, 0) != 0 )
+ return false;
+
+ // get copy of boot-args string
+ char bootArgsBuffer[len];
+ if ( sysctlbyname("kern.bootargs", bootArgsBuffer, &len, NULL, 0) != 0 )
+ return false;
+
+ // return true if 'arg' is a sub-string of boot-args
+ return (strstr(bootArgsBuffer, arg) != nullptr);
+#endif
+}
#endif
#if BUILDING_LIBDYLD