dyld-551.3.tar.gz
[apple/dyld.git] / dyld3 / shared-cache / DyldSharedCache.cpp
1 /* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*-
2 *
3 * Copyright (c) 2014 Apple Inc. All rights reserved.
4 *
5 * @APPLE_LICENSE_HEADER_START@
6 *
7 * This file contains Original Code and/or Modifications of Original Code
8 * as defined in and that are subject to the Apple Public Source License
9 * Version 2.0 (the 'License'). You may not use this file except in
10 * compliance with the License. Please obtain a copy of the License at
11 * http://www.opensource.apple.com/apsl/ and read it before using this
12 * file.
13 *
14 * The Original Code and all software distributed under the License are
15 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
19 * Please see the License for the specific language governing rights and
20 * limitations under the License.
21 *
22 * @APPLE_LICENSE_HEADER_END@
23 */
24
25
26 #include <dirent.h>
27 #include <sys/errno.h>
28 #include <sys/fcntl.h>
29 #include <sys/param.h>
30 #include <mach/mach.h>
31 #include <mach-o/loader.h>
32 #include <mach-o/fat.h>
33 #include <mach-o/dyld_priv.h>
34 #include <assert.h>
35 #include <unistd.h>
36 #include <dlfcn.h>
37 #include <CommonCrypto/CommonDigest.h>
38 #include <CommonCrypto/CommonDigestSPI.h>
39
40 #if !DYLD_IN_PROCESS
41 #include <set>
42 #include <string>
43 #include <vector>
44 #include <unordered_map>
45 #include <unordered_set>
46 #endif
47
48 #define NO_ULEB
49 #include "MachOParser.h"
50 #include "CacheBuilder.h"
51 #include "DyldSharedCache.h"
52 #include "LaunchCache.h"
53 #include "Trie.hpp"
54 #include "StringUtils.h"
55
56
57
58 #if !DYLD_IN_PROCESS
59 DyldSharedCache::CreateResults DyldSharedCache::create(const CreateOptions& options,
60 const std::vector<MappedMachO>& dylibsToCache,
61 const std::vector<MappedMachO>& otherOsDylibs,
62 const std::vector<MappedMachO>& osExecutables)
63 {
64 CreateResults results;
65 CacheBuilder cache(options);
66
67 cache.build(dylibsToCache, otherOsDylibs, osExecutables);
68
69 results.agileSignature = cache.agileSignature();
70 results.cdHashFirst = cache.cdHashFirst();
71 results.cdHashSecond = cache.cdHashSecond();
72 results.warnings = cache.warnings();
73 results.evictions = cache.evictions();
74
75 if ( cache.errorMessage().empty() ) {
76 results.cacheContent = cache.buffer();
77 results.cacheLength = cache.bufferSize();
78 }
79 else {
80 cache.deleteBuffer();
81 results.cacheContent = nullptr;
82 results.cacheLength = 0;
83 results.errorMessage = cache.errorMessage();
84 }
85 return results;
86 }
87
88 bool DyldSharedCache::verifySelfContained(std::vector<MappedMachO>& dylibsToCache, MappedMachO (^loader)(const std::string& runtimePath), std::vector<std::pair<DyldSharedCache::MappedMachO, std::set<std::string>>>& rejected)
89 {
90
91 // build map of dylibs
92 __block std::map<std::string, std::set<std::string>> badDylibs;
93 __block std::set<std::string> knownDylibs;
94 for (const DyldSharedCache::MappedMachO& dylib : dylibsToCache) {
95 std::set<std::string> reasons;
96 dyld3::MachOParser parser(dylib.mh);
97 if (parser.canBePlacedInDyldCache(dylib.runtimePath, reasons)) {
98 knownDylibs.insert(dylib.runtimePath);
99 knownDylibs.insert(parser.installName());
100 } else {
101 badDylibs[dylib.runtimePath] = reasons;
102 }
103 }
104
105 // check all dependencies to assure every dylib in cache only depends on other dylibs in cache
106 __block bool doAgain = true;
107 while ( doAgain ) {
108 __block std::vector<DyldSharedCache::MappedMachO> foundMappings;
109 doAgain = false;
110 // scan dylib list making sure all dependents are in dylib list
111 for (const DyldSharedCache::MappedMachO& dylib : dylibsToCache) {
112 if ( badDylibs.count(dylib.runtimePath) != 0 )
113 continue;
114 dyld3::MachOParser parser(dylib.mh);
115 parser.forEachDependentDylib(^(const char* loadPath, bool isWeak, bool isReExport, bool isUpward, uint32_t compatVersion, uint32_t curVersion, bool& stop) {
116 if ( knownDylibs.count(loadPath) == 0 ) {
117 doAgain = true;
118 MappedMachO foundMapping;
119 if ( badDylibs.count(loadPath) == 0 )
120 foundMapping = loader(loadPath);
121 if ( foundMapping.length == 0 ) {
122 std::string reason = std::string("Could not find dependency '") + loadPath +"'";
123 auto i = badDylibs.find(dylib.runtimePath);
124 if (i == badDylibs.end()) {
125 std::set<std::string> reasons;
126 reasons.insert(reason);
127 badDylibs[dylib.runtimePath] = reasons;
128 } else {
129 i->second.insert(reason);
130 }
131 knownDylibs.erase(dylib.runtimePath);
132 dyld3::MachOParser parserBad(dylib.mh);
133 knownDylibs.erase(parserBad.installName());
134 }
135 else {
136 dyld3::MachOParser foundParser(foundMapping.mh);
137 std::set<std::string> reasons;
138 if (foundParser.canBePlacedInDyldCache(foundParser.installName(), reasons)) {
139 foundMappings.push_back(foundMapping);
140 knownDylibs.insert(foundMapping.runtimePath);
141 knownDylibs.insert(foundParser.installName());
142 } else {
143 auto i = badDylibs.find(dylib.runtimePath);
144 if (i == badDylibs.end()) {
145 badDylibs[dylib.runtimePath] = reasons;
146 } else {
147 i->second.insert(reasons.begin(), reasons.end());
148 }
149 }
150 }
151 }
152 });
153 }
154 dylibsToCache.insert(dylibsToCache.end(), foundMappings.begin(), foundMappings.end());
155 // remove bad dylibs
156 const auto badDylibsCopy = badDylibs;
157 dylibsToCache.erase(std::remove_if(dylibsToCache.begin(), dylibsToCache.end(), [&](const DyldSharedCache::MappedMachO& dylib) {
158 auto i = badDylibsCopy.find(dylib.runtimePath);
159 if ( i != badDylibsCopy.end()) {
160 rejected.push_back(std::make_pair(dylib, i->second));
161 return true;
162 }
163 else {
164 return false;
165 }
166 }), dylibsToCache.end());
167 }
168
169 return badDylibs.empty();
170 }
171 #endif
172
173 void DyldSharedCache::forEachRegion(void (^handler)(const void* content, uint64_t vmAddr, uint64_t size, uint32_t permissions)) const
174 {
175 const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)this + header.mappingOffset);
176 const dyld_cache_mapping_info* mappingsEnd = &mappings[header.mappingCount];
177 for (const dyld_cache_mapping_info* m=mappings; m < mappingsEnd; ++m) {
178 handler((char*)this + m->fileOffset, m->address, m->size, m->initProt);
179 }
180 }
181
182 void DyldSharedCache::forEachImage(void (^handler)(const mach_header* mh, const char* installName)) const
183 {
184 const dyld_cache_image_info* dylibs = (dyld_cache_image_info*)((char*)this + header.imagesOffset);
185 const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)this + header.mappingOffset);
186 if ( mappings[0].fileOffset != 0 )
187 return;
188 uint64_t firstImageOffset = 0;
189 uint64_t firstRegionAddress = mappings[0].address;
190 for (uint32_t i=0; i < header.imagesCount; ++i) {
191 const char* dylibPath = (char*)this + dylibs[i].pathFileOffset;
192 uint64_t offset = dylibs[i].address - firstRegionAddress;
193 if ( firstImageOffset == 0 )
194 firstImageOffset = offset;
195 // skip over aliases
196 if ( dylibs[i].pathFileOffset < firstImageOffset)
197 continue;
198 const mach_header* mh = (mach_header*)((char*)this + offset);
199 handler(mh, dylibPath);
200 }
201 }
202
203 void DyldSharedCache::forEachImageEntry(void (^handler)(const char* path, uint64_t mTime, uint64_t inode)) const
204 {
205 const dyld_cache_image_info* dylibs = (dyld_cache_image_info*)((char*)this + header.imagesOffset);
206 const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)this + header.mappingOffset);
207 if ( mappings[0].fileOffset != 0 )
208 return;
209 uint64_t firstImageOffset = 0;
210 uint64_t firstRegionAddress = mappings[0].address;
211 for (uint32_t i=0; i < header.imagesCount; ++i) {
212 const char* dylibPath = (char*)this + dylibs[i].pathFileOffset;
213 uint64_t offset = dylibs[i].address - firstRegionAddress;
214 if ( firstImageOffset == 0 )
215 firstImageOffset = offset;
216 // skip over aliases
217 if ( dylibs[i].pathFileOffset < firstImageOffset)
218 continue;
219 handler(dylibPath, dylibs[i].modTime, dylibs[i].inode);
220 }
221 }
222
223 void DyldSharedCache::forEachImageTextSegment(void (^handler)(uint64_t loadAddressUnslid, uint64_t textSegmentSize, const uuid_t dylibUUID, const char* installName)) const
224 {
225 // check for old cache without imagesText array
226 if ( header.mappingOffset < 123 )
227 return;
228
229 // walk imageText table and call callback for each entry
230 const dyld_cache_image_text_info* imagesText = (dyld_cache_image_text_info*)((char*)this + header.imagesTextOffset);
231 const dyld_cache_image_text_info* imagesTextEnd = &imagesText[header.imagesTextCount];
232 for (const dyld_cache_image_text_info* p=imagesText; p < imagesTextEnd; ++p) {
233 handler(p->loadAddress, p->textSegmentSize, p->uuid, (char*)this + p->pathOffset);
234 }
235 }
236
237
238 std::string DyldSharedCache::archName() const
239 {
240 const char* archSubString = ((char*)this) + 8;
241 while (*archSubString == ' ')
242 ++archSubString;
243 return archSubString;
244 }
245
246
247 uint32_t DyldSharedCache::platform() const
248 {
249 return header.platform;
250 }
251
252 #if !DYLD_IN_PROCESS
253 std::string DyldSharedCache::mapFile() const
254 {
255 __block std::string result;
256 __block std::vector<uint64_t> regionStartAddresses;
257 __block std::vector<uint64_t> regionSizes;
258 __block std::vector<uint64_t> regionFileOffsets;
259
260 result.reserve(256*1024);
261 forEachRegion(^(const void* content, uint64_t vmAddr, uint64_t size, uint32_t permissions) {
262 regionStartAddresses.push_back(vmAddr);
263 regionSizes.push_back(size);
264 regionFileOffsets.push_back((uint8_t*)content - (uint8_t*)this);
265 char lineBuffer[256];
266 const char* prot = "RW";
267 if ( permissions == (VM_PROT_EXECUTE|VM_PROT_READ) )
268 prot = "EX";
269 else if ( permissions == VM_PROT_READ )
270 prot = "RO";
271 if ( size > 1024*1024 )
272 sprintf(lineBuffer, "mapping %s %4lluMB 0x%0llX -> 0x%0llX\n", prot, size/(1024*1024), vmAddr, vmAddr+size);
273 else
274 sprintf(lineBuffer, "mapping %s %4lluKB 0x%0llX -> 0x%0llX\n", prot, size/1024, vmAddr, vmAddr+size);
275 result += lineBuffer;
276 });
277
278 // TODO: add linkedit breakdown
279 result += "\n\n";
280
281 forEachImage(^(const mach_header* mh, const char* installName) {
282 result += std::string(installName) + "\n";
283 dyld3::MachOParser parser(mh);
284 parser.forEachSegment(^(const char* segName, uint32_t fileOffset, uint32_t fileSize, uint64_t vmAddr, uint64_t vmSize, uint8_t protections, bool& stop) {
285 char lineBuffer[256];
286 sprintf(lineBuffer, "\t%16s 0x%08llX -> 0x%08llX\n", segName, vmAddr, vmAddr+vmSize);
287 result += lineBuffer;
288 });
289 result += "\n";
290 });
291
292 return result;
293 }
294 #endif
295
296
297 uint64_t DyldSharedCache::unslidLoadAddress() const
298 {
299 const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)this + header.mappingOffset);
300 return mappings[0].address;
301 }
302
303 void DyldSharedCache::getUUID(uuid_t uuid) const
304 {
305 memcpy(uuid, header.uuid, sizeof(uuid_t));
306 }
307
308 uint64_t DyldSharedCache::mappedSize() const
309 {
310 __block uint64_t startAddr = 0;
311 __block uint64_t endAddr = 0;
312 forEachRegion(^(const void* content, uint64_t vmAddr, uint64_t size, uint32_t permissions) {
313 if ( startAddr == 0 )
314 startAddr = vmAddr;
315 uint64_t end = vmAddr+size;
316 if ( end > endAddr )
317 endAddr = end;
318 });
319 return (endAddr - startAddr);
320 }
321
322
323
324
325
326
327
328
329
330