update_dyld_shared_cache.cpp [plain text]
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <mach/mach.h>
#include <mach/mach_time.h>
#include <mach-o/dyld.h>
#include <limits.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <fcntl.h>
#include <dlfcn.h>
#include <signal.h>
#include <errno.h>
#include <assert.h>
#include <sys/uio.h>
#include <unistd.h>
#include <sys/param.h>
#include <sys/sysctl.h>
#include <sys/resource.h>
#include <dirent.h>
#include <rootless.h>
#include <dscsym.h>
#include <dispatch/dispatch.h>
#include <pthread/pthread.h>
#include <Bom/Bom.h>
#include <CoreFoundation/CoreFoundation.h>
#include <algorithm>
#include <vector>
#include <unordered_set>
#include <unordered_set>
#include <iostream>
#include <fstream>
#include "FileUtils.h"
#include "StringUtils.h"
#include "DyldSharedCache.h"
#include "MachOFile.h"
#include "MachOAnalyzer.h"
#include "ClosureFileSystemPhysical.h"
struct MappedMachOsByCategory
{
const dyld3::GradedArchs& archs;
std::vector<DyldSharedCache::MappedMachO> dylibsForCache;
std::vector<DyldSharedCache::MappedMachO> otherDylibsAndBundles;
std::vector<DyldSharedCache::MappedMachO> mainExecutables;
std::unordered_set<std::string> badZippered;
};
static const char* sAllowedPrefixes[] = {
"/bin/",
"/sbin/",
"/usr/",
"/System/",
"/Library/Apple/System/",
"/Library/Apple/usr/",
"/System/Applications/App Store.app/",
"/System/Applications/Automator.app/",
"/System/Applications/Calculator.app/",
"/System/Applications/Calendar.app/",
"/System/Applications/Chess.app/",
"/System/Applications/Contacts.app/",
"/System/Applications/Dashboard.app/",
"/System/Applications/Dictionary.app/",
"/System/Applications/FaceTime.app/",
"/System/Applications/Font Book.app/",
"/System/Applications/Image Capture.app/",
"/System/Applications/Launchpad.app/",
"/System/Applications/Mail.app/",
"/System/Applications/Maps.app/",
"/System/Applications/Messages.app/",
"/System/Applications/Mission Control.app/",
"/System/Applications/Notes.app/",
"/System/Applications/Photo Booth.app/",
"/System/Applications/Preview.app/",
"/System/Applications/QuickTime Player.app/",
"/System/Applications/Reminders.app/",
"/Applications/Safari.app/",
"/System/Applications/Siri.app/",
"/System/Applications/Stickies.app/",
"/System/Applications/System Preferences.app/",
"/System/Applications/TextEdit.app/",
"/System/Applications/Time Machine.app/",
"/System/Applications/iBooks.app/",
"/System/Applications/iTunes.app/",
"/System/Applications/Utilities/Activity Monitor.app",
"/System/Applications/Utilities/AirPort Utility.app",
"/System/Applications/Utilities/Audio MIDI Setup.app",
"/System/Applications/Utilities/Bluetooth File Exchange.app",
"/System/Applications/Utilities/Boot Camp Assistant.app",
"/System/Applications/Utilities/ColorSync Utility.app",
"/System/Applications/Utilities/Console.app",
"/System/Applications/Utilities/Digital Color Meter.app",
"/System/Applications/Utilities/Disk Utility.app",
"/System/Applications/Utilities/Grab.app",
"/System/Applications/Utilities/Grapher.app",
"/System/Applications/Utilities/Keychain Access.app",
"/System/Applications/Utilities/Migration Assistant.app",
"/System/Applications/Utilities/Script Editor.app",
"/System/Applications/Utilities/System Information.app",
"/System/Applications/Utilities/Terminal.app",
"/System/Applications/Utilities/VoiceOver Utility.app",
"/Library/CoreMediaIO/Plug-Ins/DAL/" };
static const char* sDontUsePrefixes[] = {
"/usr/share",
"/usr/local/",
"/System/Library/Assets",
"/System/Library/StagedFrameworks",
"/Library/Apple/System/Library/StagedFrameworks",
"/System/Library/Kernels/",
"/bin/zsh", "/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/Metadata.framework/Versions/A/Support/mdworker", "/usr/bin/mdimport", };
static bool verbose = false;
static bool addIfMachO(const dyld3::closure::FileSystem& fileSystem, const std::string& runtimePath, const struct stat& statBuf,
bool requireSIP, dev_t rootFS, std::vector<MappedMachOsByCategory>& files)
{
if ( endsWith(runtimePath, "_profile.dylib") || endsWith(runtimePath, "_debug.dylib") || endsWith(runtimePath, "_profile") || endsWith(runtimePath, "_debug") )
return false;
if ( startsWith(runtimePath, "/usr/lib/system/introspection/") )
return false;
#if !BUILDING_UPDATE_OTHER_DYLD_CACHE_BUILDER
if (statBuf.st_dev != rootFS) {
if ( verbose )
fprintf(stderr, "update_dyld_shared_cache: warning: skipping overlay file '%s' which is not on the root volume\n", runtimePath.c_str());
return false;
}
#endif
auto warningHandler = ^(const char* msg) {
if ( verbose )
fprintf(stderr, "update_dyld_shared_cache: warning: cannot build dlopen closure for '%s' because %s\n", runtimePath.c_str(), msg);
};
bool result = false;
for (MappedMachOsByCategory& file : files) {
Diagnostics diag;
char realerPath[MAXPATHLEN];
dyld3::closure::LoadedFileInfo loadedFileInfo = dyld3::MachOAnalyzer::load(diag, fileSystem, runtimePath.c_str(), file.archs, dyld3::Platform::macOS, realerPath);
if (diag.hasError() ) {
diag.clearError();
loadedFileInfo = dyld3::MachOAnalyzer::load(diag, fileSystem, runtimePath.c_str(), file.archs, dyld3::Platform::iOSMac, realerPath);
}
const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)loadedFileInfo.fileContent;
if ( ma != nullptr ) {
bool issetuid = false;
const uint64_t sliceLen = loadedFileInfo.sliceLen;
const bool isSipProtected = loadedFileInfo.isSipProtected;
if ( ma->isDynamicExecutable() ) {
if ( !requireSIP || isSipProtected ) {
issetuid = (statBuf.st_mode & (S_ISUID|S_ISGID));
file.mainExecutables.emplace_back(runtimePath, ma, sliceLen, issetuid, isSipProtected, loadedFileInfo.sliceOffset, statBuf.st_mtime, statBuf.st_ino);
}
}
else if ( ma->canBePlacedInDyldCache(runtimePath.c_str(), ^(const char* msg) {
if (verbose)
fprintf(stderr, "update_dyld_shared_cache: warning dylib located at '%s' cannot be placed in cache because: %s\n", runtimePath.c_str(), msg);
}) ) {
if ( !requireSIP || isSipProtected )
file.dylibsForCache.emplace_back(runtimePath, ma, sliceLen, issetuid, isSipProtected, loadedFileInfo.sliceOffset, statBuf.st_mtime, statBuf.st_ino);
else if ( ma->canHavePrecomputedDlopenClosure(runtimePath.c_str(), warningHandler) )
file.otherDylibsAndBundles.emplace_back(runtimePath, ma, sliceLen, issetuid, isSipProtected, loadedFileInfo.sliceOffset, statBuf.st_mtime, statBuf.st_ino);
}
else {
if ( ma->isDylib() ) {
std::string installName = ma->installName();
if ( startsWith(installName, "@") && !contains(runtimePath, ".app/") && !contains(runtimePath, ".xpc/") ) {
if ( dyld3::MachOFile::isSharedCacheEligiblePath(runtimePath.c_str()) )
fprintf(stderr, "update_dyld_shared_cache: warning @rpath install name for system framework: %s\n", runtimePath.c_str());
}
}
if ( ma->canHavePrecomputedDlopenClosure(runtimePath.c_str(), warningHandler) ) {
bool addClosure = false;
if ( ma->isDylib() ) {
std::string installName = ma->installName();
addClosure = installName == "/usr/lib/libobjc-trampolines.dylib";
} else {
addClosure = true;
}
if (addClosure)
file.otherDylibsAndBundles.emplace_back(runtimePath, ma, sliceLen, issetuid, isSipProtected, loadedFileInfo.sliceOffset, statBuf.st_mtime, statBuf.st_ino);
}
}
result = true;
}
}
return result;
}
static void findAllFiles(const dyld3::closure::FileSystem& fileSystem, const std::vector<std::string>& pathPrefixes,
bool requireSIP, dev_t rootFS, std::vector<MappedMachOsByCategory>& files)
{
std::unordered_set<std::string> skipDirs;
for (const char* s : sDontUsePrefixes)
skipDirs.insert(s);
__block std::unordered_set<std::string> alreadyUsed;
bool multiplePrefixes = (pathPrefixes.size() > 1);
for (const std::string& prefix : pathPrefixes) {
for (const char* searchDir : sAllowedPrefixes ) {
iterateDirectoryTree(prefix, searchDir, ^(const std::string& dirPath) { return (skipDirs.count(dirPath) != 0); }, ^(const std::string& path, const struct stat& statBuf) {
const bool hasXBit = ((statBuf.st_mode & S_IXOTH) == S_IXOTH);
if ( !hasXBit && !endsWith(path, ".dylib") )
return;
if ( statBuf.st_size < 0x3000 )
return;
if ( multiplePrefixes && (alreadyUsed.count(path) != 0) )
return;
if ( addIfMachO(fileSystem, path, statBuf, requireSIP, rootFS, files) ) {
if ( multiplePrefixes )
alreadyUsed.insert(path);
}
});
}
}
}
static const char* sReceiptLocations[] = {
"/System/Library/Receipts",
"/Library/Apple/System/Library/Receipts"
};
static void findOSFilesViaBOMS(const dyld3::closure::FileSystem& fileSystem, const std::vector<std::string>& pathPrefixes,
bool requireSIP, dev_t rootFS, std::vector<MappedMachOsByCategory>& files)
{
__block std::unordered_set<std::string> runtimePathsFound;
__block bool foundUsableBom = false;
for (const std::string& prefix : pathPrefixes) {
for (const char* dirToIterate : sReceiptLocations ) {
iterateDirectoryTree(prefix, dirToIterate, ^(const std::string&) { return false; }, ^(const std::string& path, const struct stat& statBuf) {
if ( !contains(path, "com.apple.pkg.") )
return;
if ( !endsWith(path, ".bom") )
return;
std::string fullPath = prefix + path;
BOMBom bom = BOMBomOpenWithSys(fullPath.c_str(), false, NULL);
if ( bom == nullptr )
return;
BOMFSObject rootFso = BOMBomGetRootFSObject(bom);
if ( rootFso == nullptr ) {
BOMBomFree(bom);
return;
}
BOMBomEnumerator e = BOMBomEnumeratorNew(bom, rootFso);
if ( e == nullptr ) {
fprintf(stderr, "Can't get enumerator for BOM root FSObject\n");
return;
}
BOMFSObjectFree(rootFso);
foundUsableBom = true;
while (BOMFSObject fso = BOMBomEnumeratorNext(e)) {
if ( BOMFSObjectIsBinaryObject(fso) ) {
const char* runPath = BOMFSObjectPathName(fso);
if ( (runPath[0] == '.') && (runPath[1] == '/') )
++runPath;
if (strncmp(runPath, "/System/Library/Templates/Data/", 31) == 0 )
runPath = &runPath[30];
if ( runtimePathsFound.count(runPath) == 0 ) {
bool inSearchDir = false;
for (const char* searchDir : sAllowedPrefixes ) {
if ( strncmp(searchDir, runPath, strlen(searchDir)) == 0 ) {
inSearchDir = true;
break;
}
}
if ( inSearchDir ) {
bool inSkipDir = false;
for (const char* skipDir : sDontUsePrefixes) {
if ( strncmp(skipDir, runPath, strlen(skipDir)) == 0 ) {
inSkipDir = true;
break;
}
}
if ( !inSkipDir ) {
for (const std::string& prefix2 : pathPrefixes) {
struct stat statBuf2;
std::string fullPath2 = prefix2 + runPath;
if ( stat(fullPath2.c_str(), &statBuf2) == 0 ) {
if ( addIfMachO(fileSystem, runPath, statBuf2, requireSIP, rootFS, files) ) {
runtimePathsFound.insert(runPath);
break;
}
}
}
}
}
}
}
BOMFSObjectFree(fso);
}
BOMBomEnumeratorFree(e);
BOMBomFree(bom);
});
}
}
if (!foundUsableBom)
fprintf(stderr, "update_dyld_shared_cache: warning: No usable BOM files were found in '/System/Library/Receipts'\n");
}
static bool dontCache(const std::string& volumePrefix, const std::string& archName,
const std::unordered_set<std::string>& pathsWithDuplicateInstallName,
const std::unordered_set<std::string>& badZippered,
const DyldSharedCache::MappedMachO& aFile, bool warn,
const std::unordered_set<std::string>& skipDylibs)
{
if ( skipDylibs.count(aFile.runtimePath) )
return true;
if ( startsWith(aFile.runtimePath, "/usr/lib/system/introspection/") )
return true;
if ( startsWith(aFile.runtimePath, "/System/Library/QuickTime/") )
return true;
if ( startsWith(aFile.runtimePath, "/System/Library/Tcl/") )
return true;
if ( startsWith(aFile.runtimePath, "/System/Library/Perl/") )
return true;
if ( startsWith(aFile.runtimePath, "/System/Library/MonitorPanels/") )
return true;
if ( startsWith(aFile.runtimePath, "/System/Library/Accessibility/") )
return true;
if ( startsWith(aFile.runtimePath, "/usr/local/") )
return true;
if ( aFile.runtimePath.find(".app/") != std::string::npos )
return true;
if ( archName == "i386" ) {
if ( startsWith(aFile.runtimePath, "/System/Library/CoreServices/") )
return true;
if ( startsWith(aFile.runtimePath, "/System/Library/Extensions/") )
return true;
}
if ( aFile.runtimePath.find("//") != std::string::npos ) {
if (warn) fprintf(stderr, "update_dyld_shared_cache: warning: %s skipping because of bad install name %s\n", archName.c_str(), aFile.runtimePath.c_str());
return true;
}
const char* installName = aFile.mh->installName();
if ( (pathsWithDuplicateInstallName.count(aFile.runtimePath) != 0) && (aFile.runtimePath != installName) ) {
struct stat statBuf;
bool isSymLink = ( (lstat(aFile.runtimePath.c_str(), &statBuf) == 0) && S_ISLNK(statBuf.st_mode) );
if (!isSymLink && warn) fprintf(stderr, "update_dyld_shared_cache: warning: %s skipping because of duplicate install name %s\n", archName.c_str(), aFile.runtimePath.c_str());
return true;
}
if (badZippered.count(aFile.runtimePath)) {
return true;
}
if ( aFile.runtimePath != installName ) {
std::string fullInstall = volumePrefix + installName;
char resolvedPath[PATH_MAX];
if ( realpath(fullInstall.c_str(), resolvedPath) != NULL ) {
std::string resolvedSymlink = resolvedPath;
if ( !volumePrefix.empty() ) {
resolvedSymlink = resolvedSymlink.substr(volumePrefix.size());
}
if ( aFile.runtimePath == resolvedSymlink ) {
return false;
}
}
std::string fullRuntime = volumePrefix + aFile.runtimePath;
if ( realpath(fullRuntime.c_str(), resolvedPath) != NULL ) {
std::string resolvedSymlink = resolvedPath;
if ( !volumePrefix.empty() ) {
resolvedSymlink = resolvedSymlink.substr(volumePrefix.size());
}
if ( resolvedSymlink == installName ) {
return false;
}
}
if (warn) fprintf(stderr, "update_dyld_shared_cache: warning: %s skipping because of bad install name %s\n", archName.c_str(), aFile.runtimePath.c_str());
return true;
}
return false;
}
static void pruneCachedDylibs(const std::string& volumePrefix, const std::unordered_set<std::string>& skipDylibs,
MappedMachOsByCategory& fileSet, bool warn)
{
std::unordered_set<std::string> pathsWithDuplicateInstallName;
std::unordered_map<std::string, std::string> installNameToFirstPath;
for (DyldSharedCache::MappedMachO& aFile : fileSet.dylibsForCache) {
const char* installName = aFile.mh->installName();
auto pos = installNameToFirstPath.find(installName);
if ( pos == installNameToFirstPath.end() ) {
installNameToFirstPath[installName] = aFile.runtimePath;
}
else {
pathsWithDuplicateInstallName.insert(aFile.runtimePath);
pathsWithDuplicateInstallName.insert(installNameToFirstPath[installName]);
}
}
std::unordered_map<std::string, std::string> macOSPathToTwinPath;
for (const auto& entry : installNameToFirstPath) {
if ( startsWith(entry.first, "/System/iOSSupport/") ) {
std::string tail = entry.first.substr(18);
if ( installNameToFirstPath.count(tail) != 0 ) {
macOSPathToTwinPath.insert({ tail, entry.first });
}
}
}
for (DyldSharedCache::MappedMachO& aFile : fileSet.dylibsForCache) {
if ( aFile.mh->isZippered() ) {
aFile.mh->forEachDependentDylib(^(const char* loadPath, bool isWeak, bool isReExport, bool isUpward, uint32_t compatVersion, uint32_t curVersion, bool& stop) {
auto macOSAndTwinPath = macOSPathToTwinPath.find(loadPath);
if ( macOSAndTwinPath != macOSPathToTwinPath.end() ) {
if ( warn ) {
fprintf(stderr, "update_dyld_shared_cache: warning: evicting UIKitForMac binary: %s as it is linked by zippered binary %s\n",
macOSAndTwinPath->second.c_str(), aFile.runtimePath.c_str());
}
fileSet.badZippered.insert(macOSAndTwinPath->second);
}
});
}
}
for (DyldSharedCache::MappedMachO& aFile : fileSet.dylibsForCache) {
if ( dontCache(volumePrefix, fileSet.archs.name(), pathsWithDuplicateInstallName, fileSet.badZippered, aFile, true, skipDylibs) ){
if ( pathsWithDuplicateInstallName.count(aFile.runtimePath) == 0 )
fileSet.otherDylibsAndBundles.push_back(aFile);
}
}
fileSet.dylibsForCache.erase(std::remove_if(fileSet.dylibsForCache.begin(), fileSet.dylibsForCache.end(),
[&](const DyldSharedCache::MappedMachO& aFile) { return dontCache(volumePrefix, fileSet.archs.name(), pathsWithDuplicateInstallName, fileSet.badZippered, aFile, false, skipDylibs); }),
fileSet.dylibsForCache.end());
}
static void pruneOtherDylibs(const std::string& volumePrefix, MappedMachOsByCategory& fileSet)
{
fileSet.otherDylibsAndBundles.erase(std::remove_if(fileSet.otherDylibsAndBundles.begin(), fileSet.otherDylibsAndBundles.end(),
[&](const DyldSharedCache::MappedMachO& aFile) { return (aFile.runtimePath.find(".app/") != std::string::npos); }),
fileSet.otherDylibsAndBundles.end());
}
static void pruneExecutables(const std::string& volumePrefix, MappedMachOsByCategory& fileSet)
{
fileSet.mainExecutables.erase(std::remove_if(fileSet.mainExecutables.begin(), fileSet.mainExecutables.end(),
[&](const DyldSharedCache::MappedMachO& aFile) {
if ( !startsWith(aFile.runtimePath, "/usr/bin/") )
return false;
__block bool isXcodeShim = false;
aFile.mh->forEachDependentDylib(^(const char* loadPath, bool, bool, bool, uint32_t, uint32_t, bool &stop) {
if ( strcmp(loadPath, "/usr/lib/libxcselect.dylib") == 0 )
isXcodeShim = true;
});
return isXcodeShim;
}), fileSet.mainExecutables.end());
}
static bool existingCacheUpToDate(const std::string& existingCache, const std::vector<DyldSharedCache::MappedMachO>& currentDylibs)
{
int fd = ::open(existingCache.c_str(), O_RDONLY);
if ( fd < 0 )
return false;
struct stat statbuf;
if ( ::fstat(fd, &statbuf) == -1 ) {
::close(fd);
return false;
}
std::unordered_map<std::string, const DyldSharedCache::MappedMachO*> currentDylibMap;
for (const DyldSharedCache::MappedMachO& aFile : currentDylibs) {
currentDylibMap[aFile.runtimePath] = &aFile;
}
__block bool foundMismatch = false;
const uint64_t cacheMapLen = statbuf.st_size;
void *p = ::mmap(NULL, cacheMapLen, PROT_READ, MAP_PRIVATE, fd, 0);
if ( p != MAP_FAILED ) {
const DyldSharedCache* cache = (DyldSharedCache*)p;
cache->forEachImageEntry(^(const char* installName, uint64_t mTime, uint64_t inode) {
bool foundMatch = false;
auto pos = currentDylibMap.find(installName);
if ( pos != currentDylibMap.end() ) {
const DyldSharedCache::MappedMachO* foundDylib = pos->second;
if ( (foundDylib->inode == inode) && (foundDylib->modTime == mTime) ) {
foundMatch = true;
}
}
if ( !foundMatch ) {
bool foundSlow = false;
for (const DyldSharedCache::MappedMachO& aFile : currentDylibs) {
if ( (aFile.inode == inode) && (aFile.modTime == mTime) ) {
foundSlow = true;
break;
}
}
if ( !foundSlow ) {
foundMismatch = true;
if ( verbose )
fprintf(stderr, "rebuilding dyld cache because dylib changed: %s\n", installName);
}
}
});
::munmap(p, cacheMapLen);
}
::close(fd);
return !foundMismatch;
}
inline uint32_t absolutetime_to_milliseconds(uint64_t abstime)
{
return (uint32_t)(abstime/1000/1000);
}
static bool runningOnHaswell()
{
struct host_basic_info info;
mach_msg_type_number_t count = HOST_BASIC_INFO_COUNT;
mach_port_t hostPort = mach_host_self();
kern_return_t result = host_info(hostPort, HOST_BASIC_INFO, (host_info_t)&info, &count);
mach_port_deallocate(mach_task_self(), hostPort);
return ( (result == KERN_SUCCESS) && (info.cpu_subtype == CPU_SUBTYPE_X86_64_H) );
}
#if !BUILDING_UPDATE_OTHER_DYLD_CACHE_BUILDER
static std::string currentToolRealPath()
{
char curToolPath[PATH_MAX];
uint32_t curToolPathsize = PATH_MAX;
int result = _NSGetExecutablePath(curToolPath, &curToolPathsize);
if ( result == 0 ) {
char resolvedCurToolPath[PATH_MAX];
if ( realpath(curToolPath, resolvedCurToolPath) != NULL )
return resolvedCurToolPath;
else
return curToolPath;
}
return "/usr/bin/update_dyld_shared_cache";
}
#endif
#define TERMINATE_IF_LAST_ARG( s ) \
do { \
if ( i == argc - 1 ) { \
fprintf(stderr, s ); \
return 1; \
} \
} while ( 0 )
int main(int argc, const char* argv[], const char* envp[])
{
std::string rootPath;
std::string overlayPath;
std::string dylibListFile;
bool universal = false;
bool force = false;
bool searchDisk = false;
bool dylibsRemoved = false;
std::string cacheDir;
std::unordered_set<std::string> archStrs;
std::unordered_set<std::string> skipDylibs;
for (int i = 1; i < argc; ++i) {
const char* arg = argv[i];
if (strcmp(arg, "-debug") == 0) {
verbose = true;
}
else if (strcmp(arg, "-verbose") == 0) {
verbose = true;
}
else if (strcmp(arg, "-dont_map_local_symbols") == 0) {
}
else if (strcmp(arg, "-dylib_list") == 0) {
TERMINATE_IF_LAST_ARG("-dylib_list missing argument");
dylibListFile = argv[++i];
}
else if ((strcmp(arg, "-root") == 0) || (strcmp(arg, "--root") == 0)) {
TERMINATE_IF_LAST_ARG("-root missing path argument\n");
rootPath = argv[++i];
}
else if (strcmp(arg, "-overlay") == 0) {
TERMINATE_IF_LAST_ARG("-overlay missing path argument\n");
overlayPath = argv[++i];
}
else if (strcmp(arg, "-cache_dir") == 0) {
TERMINATE_IF_LAST_ARG("-cache_dir missing path argument\n");
cacheDir = argv[++i];
}
else if (strcmp(arg, "-arch") == 0) {
TERMINATE_IF_LAST_ARG("-arch missing argument\n");
archStrs.insert(argv[++i]);
}
else if (strcmp(arg, "-search_disk") == 0) {
searchDisk = true;
}
else if (strcmp(arg, "-dylibs_removed_in_mastering") == 0) {
dylibsRemoved = true;
}
else if (strcmp(arg, "-force") == 0) {
force = true;
}
else if (strcmp(arg, "-sort_by_name") == 0) {
}
else if (strcmp(arg, "-universal_boot") == 0) {
universal = true;
}
else if (strcmp(arg, "-skip") == 0) {
TERMINATE_IF_LAST_ARG("-skip missing argument\n");
skipDylibs.insert(argv[++i]);
}
else {
fprintf(stderr, "update_dyld_shared_cache: unknown option: %s\n", arg);
return 1;
}
}
if ( !rootPath.empty() & !overlayPath.empty() ) {
fprintf(stderr, "-root and -overlay cannot be used together\n");
return 1;
}
if ( !rootPath.empty() ) {
char resolvedPath[PATH_MAX];
if ( realpath(rootPath.c_str(), resolvedPath) != NULL ) {
rootPath = resolvedPath;
}
if ( rootPath == "/" ) {
rootPath = "";
}
}
if ( !overlayPath.empty() ) {
char resolvedPath[PATH_MAX];
if ( realpath(overlayPath.c_str(), resolvedPath) != NULL ) {
overlayPath = resolvedPath;
}
}
#if !BUILDING_UPDATE_OTHER_DYLD_CACHE_BUILDER
std::string newTool;
if ( !rootPath.empty() )
newTool = rootPath + "/usr/bin/update_dyld_shared_cache_root_mode";
else if ( !overlayPath.empty() )
newTool = overlayPath + "/usr/bin/update_dyld_shared_cache";
if ( !newTool.empty() ) {
struct stat newToolStatBuf;
if ( stat(newTool.c_str(), &newToolStatBuf) == 0 ) {
if ( newTool != currentToolRealPath() ) {
argv[0] = newTool.c_str();
execve(newTool.c_str(), (char**)argv, (char**)envp);
fprintf(stderr, "update_dyld_shared_cache: error: could not find '%s/usr/bin/update_dyld_shared_cache_root_mode' in target volume\n", rootPath.c_str());
return 1;
}
}
if ( !rootPath.empty() ) {
newTool = rootPath + "/usr/bin/update_dyld_shared_cache";
if ( stat(newTool.c_str(), &newToolStatBuf) == 0 ) {
if ( newTool != currentToolRealPath() ) {
argv[0] = newTool.c_str();
execve(newTool.c_str(), (char**)argv, (char**)envp);
}
}
fprintf(stderr, "update_dyld_shared_cache: error: could not find '%s/usr/bin/update_dyld_shared_cache_root_mode' in target volume\n", rootPath.c_str());
return 1;
}
}
#else
if ( rootPath.empty() ) {
fprintf(stderr, "update_dyld_shared_cache_root_mode: error: -root option missing\n");
return 1;
}
#endif
struct stat rootStatBuf;
if ( stat(rootPath == "" ? "/" : rootPath.c_str(), &rootStatBuf) != 0 ) {
fprintf(stderr, "update_dyld_shared_cache: error: could not stat root file system because '%s'\n", strerror(errno));
return 1;
}
dev_t rootFS = rootStatBuf.st_dev;
std::vector<std::string> pathPrefixes;
if ( !overlayPath.empty() ) {
struct stat overlayStatBuf;
if ( stat(overlayPath.c_str(), &overlayStatBuf) != 0 ) {
fprintf(stderr, "update_dyld_shared_cache: warning: ignoring overlay dir '%s' because '%s'\n", overlayPath.c_str(), strerror(errno));
overlayPath.clear();
}
else {
char resolvedOverlayPath[PATH_MAX];
if ( realpath(overlayPath.c_str(), resolvedOverlayPath) != NULL ) {
overlayPath = resolvedOverlayPath;
}
else {
fprintf(stderr, "update_dyld_shared_cache: warning: ignoring overlay dir '%s' because realpath() failed\n", overlayPath.c_str());
overlayPath.clear();
}
}
if ( !overlayPath.empty() )
pathPrefixes.push_back(overlayPath);
}
pathPrefixes.push_back(rootPath);
const char* fsRoot = rootPath.empty() ? nullptr : rootPath.c_str();
const char* fsOverlay = overlayPath.empty() ? nullptr : overlayPath.c_str();
dyld3::closure::FileSystemPhysical fileSystem(fsRoot, fsOverlay);
if ( cacheDir.empty() ) {
if ( geteuid() != 0 ) {
fprintf(stderr, "update_dyld_shared_cache: must be run as root (sudo)\n");
return 1;
}
if ( rootPath != "/" )
cacheDir = rootPath + MACOSX_DYLD_SHARED_CACHE_DIR;
else if ( !overlayPath.empty() )
cacheDir = overlayPath + MACOSX_DYLD_SHARED_CACHE_DIR;
else
cacheDir = MACOSX_DYLD_SHARED_CACHE_DIR;
}
int err = mkpath_np(cacheDir.c_str(), S_IRWXU | S_IRGRP|S_IXGRP | S_IROTH|S_IXOTH);
if ( (err != 0) && (err != EEXIST) ) {
fprintf(stderr, "update_dyld_shared_cache: could not access cache dir: mkpath_np(%s) failed errno=%d\n", cacheDir.c_str(), err);
return 1;
}
char resolvedCachePath[PATH_MAX];
::realpath(cacheDir.c_str(), resolvedCachePath);
cacheDir = resolvedCachePath;
#if BUILDING_UPDATE_OTHER_DYLD_CACHE_BUILDER
bool requireDylibsBeRootlessProtected = false;
#else
bool requireDylibsBeRootlessProtected = isProtectedBySIPExceptDyld(cacheDir);
if ( requireDylibsBeRootlessProtected && !overlayPath.empty() && !isProtectedBySIP(overlayPath.c_str()) ) {
fprintf(stderr, "update_dyld_shared_cache: warning: ignoring overlay dir '%s' because it is not SIP protected\n", overlayPath.c_str());
overlayPath.clear();
pathPrefixes.clear();
pathPrefixes.push_back(rootPath);
}
#endif
if ( archStrs.empty() ) {
char realerPath[MAXPATHLEN];
Diagnostics testDiag;
const char* foundationPath = "/System/Library/Frameworks/Foundation.framework/Versions/C/Foundation";
dyld3::closure::LoadedFileInfo foundationInfo = dyld3::MachOAnalyzer::load(testDiag, fileSystem, foundationPath, dyld3::GradedArchs::i386, dyld3::Platform::macOS, realerPath);
bool foundationHas32bit = (foundationInfo.fileContent != NULL);
if ( foundationHas32bit )
fileSystem.unloadFile(foundationInfo);
if ( universal ) {
if ( foundationHas32bit )
archStrs.insert("i386");
archStrs.insert("x86_64");
archStrs.insert("x86_64h");
}
else {
if ( foundationHas32bit )
archStrs.insert("i386");
archStrs.insert(runningOnHaswell() ? "x86_64h" : "x86_64");
}
}
uint64_t t1 = mach_absolute_time();
__block std::vector<MappedMachOsByCategory> allFileSets;
if ( archStrs.count("x86_64") )
allFileSets.push_back({dyld3::GradedArchs::x86_64});
if ( archStrs.count("x86_64h") )
allFileSets.push_back({dyld3::GradedArchs::x86_64h});
if ( archStrs.count("i386") )
allFileSets.push_back({dyld3::GradedArchs::i386});
if ( searchDisk )
findAllFiles(fileSystem, pathPrefixes, requireDylibsBeRootlessProtected, rootFS, allFileSets);
else {
std::unordered_set<std::string> runtimePathsFound;
findOSFilesViaBOMS(fileSystem, pathPrefixes, requireDylibsBeRootlessProtected, rootFS, allFileSets);
}
for (MappedMachOsByCategory& fileSet : allFileSets) {
pruneCachedDylibs(rootPath, skipDylibs, fileSet, verbose);
pruneOtherDylibs(rootPath, fileSet);
pruneExecutables(rootPath, fileSet);
}
uint64_t t2 = mach_absolute_time();
if ( verbose ) {
if ( searchDisk )
fprintf(stderr, "time to scan file system and construct lists of mach-o files: %ums\n", absolutetime_to_milliseconds(t2-t1));
else
fprintf(stderr, "time to read BOM and construct lists of mach-o files: %ums\n", absolutetime_to_milliseconds(t2-t1));
}
uint64_t memSize = 0;
size_t sz = sizeof(memSize);;
bool buildInParallel = false;
if ( sysctlbyname("hw.memsize", &memSize, &sz, NULL, 0) == 0 ) {
if ( memSize >= 0x100000000ULL )
buildInParallel = true;
}
dispatch_queue_t dqueue = buildInParallel ? dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
: dispatch_queue_create("serial-queue", DISPATCH_QUEUE_SERIAL);
__block bool cacheBuildFailure = false;
__block bool wroteSomeCacheFile = false;
dispatch_apply(allFileSets.size(), dqueue, ^(size_t index) {
MappedMachOsByCategory& fileSet = allFileSets[index];
const std::string outFile = cacheDir + "/dyld_shared_cache_" + fileSet.archs.name();
DyldSharedCache::MappedMachO (^loader)(const std::string&) = ^DyldSharedCache::MappedMachO(const std::string& runtimePath) {
if ( skipDylibs.count(runtimePath) )
return DyldSharedCache::MappedMachO();
if (fileSet.badZippered.count(runtimePath)) {
return DyldSharedCache::MappedMachO();
}
for (const std::string& prefix : pathPrefixes) {
std::string fullPath = prefix + runtimePath;
struct stat statBuf;
if ( stat(fullPath.c_str(), &statBuf) == 0 ) {
char resolvedPath[PATH_MAX];
if ( realpath(fullPath.c_str(), resolvedPath) != NULL ) {
std::string resolvedSymlink = resolvedPath;
if ( !rootPath.empty() ) {
resolvedSymlink = resolvedSymlink.substr(rootPath.size());
}
if ( (runtimePath != resolvedSymlink) && !contains(runtimePath, "InputContext") ) { for (const DyldSharedCache::MappedMachO& aDylibMapping : fileSet.dylibsForCache) {
if ( aDylibMapping.runtimePath == resolvedSymlink ) {
if ( verbose )
fprintf(stderr, "verifySelfContained, redirect %s to %s\n", runtimePath.c_str(), aDylibMapping.runtimePath.c_str());
return aDylibMapping;
}
}
}
}
std::vector<MappedMachOsByCategory> mappedFiles;
mappedFiles.push_back({fileSet.archs});
if ( addIfMachO(fileSystem, runtimePath, statBuf, requireDylibsBeRootlessProtected, rootFS, mappedFiles) ) {
if ( !mappedFiles.back().dylibsForCache.empty() ) {
if ( verbose )
fprintf(stderr, "verifySelfContained, add %s\n", mappedFiles.back().dylibsForCache.back().runtimePath.c_str());
return mappedFiles.back().dylibsForCache.back();
}
}
}
}
return DyldSharedCache::MappedMachO();
};
size_t startCount = fileSet.dylibsForCache.size();
std::vector<std::pair<DyldSharedCache::MappedMachO, std::set<std::string>>> excludes;
DyldSharedCache::verifySelfContained(fileSet.dylibsForCache, fileSet.badZippered, loader, excludes);
for (size_t i=startCount; i < fileSet.dylibsForCache.size(); ++i) {
fprintf(stderr, "update_dyld_shared_cache: warning: %s not in .bom, but adding required dylib %s\n", fileSet.archs.name(), fileSet.dylibsForCache[i].runtimePath.c_str());
}
for (auto& exclude : excludes) {
std::string reasons = "(\"";
for (auto i = exclude.second.begin(); i != exclude.second.end(); ++i) {
reasons += *i;
if (i != --exclude.second.end()) {
reasons += "\", \"";
}
}
reasons += "\")";
fprintf(stderr, "update_dyld_shared_cache: warning: %s rejected from cached dylibs: %s (%s)\n", fileSet.archs.name(), exclude.first.runtimePath.c_str(), reasons.c_str());
fileSet.otherDylibsAndBundles.push_back(exclude.first);
}
if ( !force ) {
if ( existingCacheUpToDate(outFile, fileSet.dylibsForCache) )
return;
}
fprintf(stderr, "update_dyld_shared_cache: %s incorporating %lu OS dylibs, tracking %lu others, building closures for %lu executables\n",
fileSet.archs.name(), fileSet.dylibsForCache.size(), fileSet.otherDylibsAndBundles.size(), fileSet.mainExecutables.size());
DyldSharedCache::CreateOptions options;
options.outputFilePath = outFile;
options.outputMapFilePath = cacheDir + "/dyld_shared_cache_" + fileSet.archs.name() + ".map";
options.archs = &fileSet.archs;
options.platform = dyld3::Platform::macOS;
options.excludeLocalSymbols = false;
options.optimizeStubs = false;
options.optimizeObjC = true;
options.codeSigningDigestMode = DyldSharedCache::SHA256only;
options.dylibsRemovedDuringMastering = dylibsRemoved;
options.inodesAreSameAsRuntime = true;
options.cacheSupportsASLR = (&fileSet.archs != &dyld3::GradedArchs::i386);
options.forSimulator = false;
options.isLocallyBuiltCache = true;
options.verbose = verbose;
options.evictLeafDylibsOnOverflow = true;
DyldSharedCache::CreateResults results = DyldSharedCache::create(options, fileSystem, fileSet.dylibsForCache, fileSet.otherDylibsAndBundles, fileSet.mainExecutables);
for (const std::string& warn : results.warnings) {
fprintf(stderr, "update_dyld_shared_cache: warning: %s %s\n", fileSet.archs.name(), warn.c_str());
}
if ( results.errorMessage.empty() ) {
wroteSomeCacheFile = true;
}
else {
fprintf(stderr, "update_dyld_shared_cache: %s\n", results.errorMessage.c_str());
cacheBuildFailure = true;
}
});
if ( wroteSomeCacheFile ) {
void* h = dlopen("/usr/lib/libdscsym.dylib", 0);
if ( h != nullptr ) {
typedef int (*dscym_func)(const char*);
dscym_func func = (dscym_func)dlsym(h, "dscsym_save_dscsyms_for_current_caches");
std::string nuggetRoot = rootPath;
if ( nuggetRoot.empty() )
nuggetRoot = overlayPath;
if ( nuggetRoot.empty() )
nuggetRoot = "/";
(*func)(nuggetRoot.c_str());
}
}
return (cacheBuildFailure ? 1 : 0);
}