sanitizer_procmaps_mac.cc revision 2d1fdb26e458c4ddc04155c1d421bced3ba90cd0
1//===-- sanitizer_procmaps_mac.cc -----------------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// Information about the process mappings (Mac-specific parts). 11//===----------------------------------------------------------------------===// 12 13#include "sanitizer_platform.h" 14#if SANITIZER_MAC 15#include "sanitizer_common.h" 16#include "sanitizer_placement_new.h" 17#include "sanitizer_procmaps.h" 18 19#include <mach-o/dyld.h> 20#include <mach-o/loader.h> 21 22namespace __sanitizer { 23 24MemoryMappingLayout::MemoryMappingLayout(bool cache_enabled) { 25 Reset(); 26} 27 28MemoryMappingLayout::~MemoryMappingLayout() { 29} 30 31// More information about Mach-O headers can be found in mach-o/loader.h 32// Each Mach-O image has a header (mach_header or mach_header_64) starting with 33// a magic number, and a list of linker load commands directly following the 34// header. 35// A load command is at least two 32-bit words: the command type and the 36// command size in bytes. We're interested only in segment load commands 37// (LC_SEGMENT and LC_SEGMENT_64), which tell that a part of the file is mapped 38// into the task's address space. 39// The |vmaddr|, |vmsize| and |fileoff| fields of segment_command or 40// segment_command_64 correspond to the memory address, memory size and the 41// file offset of the current memory segment. 42// Because these fields are taken from the images as is, one needs to add 43// _dyld_get_image_vmaddr_slide() to get the actual addresses at runtime. 44 45void MemoryMappingLayout::Reset() { 46 // Count down from the top. 47 // TODO(glider): as per man 3 dyld, iterating over the headers with 48 // _dyld_image_count is thread-unsafe. We need to register callbacks for 49 // adding and removing images which will invalidate the MemoryMappingLayout 50 // state. 51 current_image_ = _dyld_image_count(); 52 current_load_cmd_count_ = -1; 53 current_load_cmd_addr_ = 0; 54 current_magic_ = 0; 55 current_filetype_ = 0; 56} 57 58// static 59void MemoryMappingLayout::CacheMemoryMappings() { 60 // No-op on Mac for now. 61} 62 63void MemoryMappingLayout::LoadFromCache() { 64 // No-op on Mac for now. 65} 66 67// Next and NextSegmentLoad were inspired by base/sysinfo.cc in 68// Google Perftools, http://code.google.com/p/google-perftools. 69 70// NextSegmentLoad scans the current image for the next segment load command 71// and returns the start and end addresses and file offset of the corresponding 72// segment. 73// Note that the segment addresses are not necessarily sorted. 74template<u32 kLCSegment, typename SegmentCommand> 75bool MemoryMappingLayout::NextSegmentLoad( 76 uptr *start, uptr *end, uptr *offset, 77 char filename[], uptr filename_size, uptr *protection) { 78 if (protection) 79 UNIMPLEMENTED(); 80 const char* lc = current_load_cmd_addr_; 81 current_load_cmd_addr_ += ((const load_command *)lc)->cmdsize; 82 if (((const load_command *)lc)->cmd == kLCSegment) { 83 const sptr dlloff = _dyld_get_image_vmaddr_slide(current_image_); 84 const SegmentCommand* sc = (const SegmentCommand *)lc; 85 if (start) *start = sc->vmaddr + dlloff; 86 if (end) *end = sc->vmaddr + sc->vmsize + dlloff; 87 if (offset) { 88 if (current_filetype_ == /*MH_EXECUTE*/ 0x2) { 89 *offset = sc->vmaddr; 90 } else { 91 *offset = sc->fileoff; 92 } 93 } 94 if (filename) { 95 internal_strncpy(filename, _dyld_get_image_name(current_image_), 96 filename_size); 97 } 98 return true; 99 } 100 return false; 101} 102 103bool MemoryMappingLayout::Next(uptr *start, uptr *end, uptr *offset, 104 char filename[], uptr filename_size, 105 uptr *protection) { 106 for (; current_image_ >= 0; current_image_--) { 107 const mach_header* hdr = _dyld_get_image_header(current_image_); 108 if (!hdr) continue; 109 if (current_load_cmd_count_ < 0) { 110 // Set up for this image; 111 current_load_cmd_count_ = hdr->ncmds; 112 current_magic_ = hdr->magic; 113 current_filetype_ = hdr->filetype; 114 switch (current_magic_) { 115#ifdef MH_MAGIC_64 116 case MH_MAGIC_64: { 117 current_load_cmd_addr_ = (char*)hdr + sizeof(mach_header_64); 118 break; 119 } 120#endif 121 case MH_MAGIC: { 122 current_load_cmd_addr_ = (char*)hdr + sizeof(mach_header); 123 break; 124 } 125 default: { 126 continue; 127 } 128 } 129 } 130 131 for (; current_load_cmd_count_ >= 0; current_load_cmd_count_--) { 132 switch (current_magic_) { 133 // current_magic_ may be only one of MH_MAGIC, MH_MAGIC_64. 134#ifdef MH_MAGIC_64 135 case MH_MAGIC_64: { 136 if (NextSegmentLoad<LC_SEGMENT_64, struct segment_command_64>( 137 start, end, offset, filename, filename_size, protection)) 138 return true; 139 break; 140 } 141#endif 142 case MH_MAGIC: { 143 if (NextSegmentLoad<LC_SEGMENT, struct segment_command>( 144 start, end, offset, filename, filename_size, protection)) 145 return true; 146 break; 147 } 148 } 149 } 150 // If we get here, no more load_cmd's in this image talk about 151 // segments. Go on to the next image. 152 } 153 return false; 154} 155 156uptr MemoryMappingLayout::DumpListOfModules(LoadedModule *modules, 157 uptr max_modules, 158 string_predicate_t filter) { 159 Reset(); 160 uptr cur_beg, cur_end; 161 InternalScopedBuffer<char> module_name(kMaxPathLength); 162 uptr n_modules = 0; 163 for (uptr i = 0; n_modules < max_modules && 164 Next(&cur_beg, &cur_end, 0, module_name.data(), 165 module_name.size(), 0); 166 i++) { 167 const char *cur_name = module_name.data(); 168 if (cur_name[0] == '\0') 169 continue; 170 if (filter && !filter(cur_name)) 171 continue; 172 LoadedModule *cur_module = 0; 173 if (n_modules > 0 && 174 0 == internal_strcmp(cur_name, modules[n_modules - 1].full_name())) { 175 cur_module = &modules[n_modules - 1]; 176 } else { 177 void *mem = &modules[n_modules]; 178 cur_module = new(mem) LoadedModule(cur_name, cur_beg); 179 n_modules++; 180 } 181 cur_module->addAddressRange(cur_beg, cur_end); 182 } 183 return n_modules; 184} 185 186} // namespace __sanitizer 187 188#endif // SANITIZER_MAC 189