1//===-- sanitizer_procmaps_mac.cc -----------------------------------------===// 2// 3// This file is distributed under the University of Illinois Open Source 4// License. See LICENSE.TXT for details. 5// 6//===----------------------------------------------------------------------===// 7// 8// Information about the process mappings (Mac-specific parts). 9//===----------------------------------------------------------------------===// 10 11#include "sanitizer_platform.h" 12#if SANITIZER_MAC 13#include "sanitizer_common.h" 14#include "sanitizer_placement_new.h" 15#include "sanitizer_procmaps.h" 16 17#include <mach-o/dyld.h> 18#include <mach-o/loader.h> 19 20namespace __sanitizer { 21 22MemoryMappingLayout::MemoryMappingLayout(bool cache_enabled) { 23 Reset(); 24} 25 26MemoryMappingLayout::~MemoryMappingLayout() { 27} 28 29// More information about Mach-O headers can be found in mach-o/loader.h 30// Each Mach-O image has a header (mach_header or mach_header_64) starting with 31// a magic number, and a list of linker load commands directly following the 32// header. 33// A load command is at least two 32-bit words: the command type and the 34// command size in bytes. We're interested only in segment load commands 35// (LC_SEGMENT and LC_SEGMENT_64), which tell that a part of the file is mapped 36// into the task's address space. 37// The |vmaddr|, |vmsize| and |fileoff| fields of segment_command or 38// segment_command_64 correspond to the memory address, memory size and the 39// file offset of the current memory segment. 40// Because these fields are taken from the images as is, one needs to add 41// _dyld_get_image_vmaddr_slide() to get the actual addresses at runtime. 42 43void MemoryMappingLayout::Reset() { 44 // Count down from the top. 45 // TODO(glider): as per man 3 dyld, iterating over the headers with 46 // _dyld_image_count is thread-unsafe. We need to register callbacks for 47 // adding and removing images which will invalidate the MemoryMappingLayout 48 // state. 49 current_image_ = _dyld_image_count(); 50 current_load_cmd_count_ = -1; 51 current_load_cmd_addr_ = 0; 52 current_magic_ = 0; 53 current_filetype_ = 0; 54} 55 56// static 57void MemoryMappingLayout::CacheMemoryMappings() { 58 // No-op on Mac for now. 59} 60 61void MemoryMappingLayout::LoadFromCache() { 62 // No-op on Mac for now. 63} 64 65// Next and NextSegmentLoad were inspired by base/sysinfo.cc in 66// Google Perftools, http://code.google.com/p/google-perftools. 67 68// NextSegmentLoad scans the current image for the next segment load command 69// and returns the start and end addresses and file offset of the corresponding 70// segment. 71// Note that the segment addresses are not necessarily sorted. 72template<u32 kLCSegment, typename SegmentCommand> 73bool MemoryMappingLayout::NextSegmentLoad( 74 uptr *start, uptr *end, uptr *offset, 75 char filename[], uptr filename_size, uptr *protection) { 76 const char* lc = current_load_cmd_addr_; 77 current_load_cmd_addr_ += ((const load_command *)lc)->cmdsize; 78 if (((const load_command *)lc)->cmd == kLCSegment) { 79 const sptr dlloff = _dyld_get_image_vmaddr_slide(current_image_); 80 const SegmentCommand* sc = (const SegmentCommand *)lc; 81 if (start) *start = sc->vmaddr + dlloff; 82 if (protection) { 83 // Return the initial protection. 84 *protection = sc->initprot; 85 } 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, prot; 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(), &prot); 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, prot & kProtectionExecute); 182 } 183 return n_modules; 184} 185 186} // namespace __sanitizer 187 188#endif // SANITIZER_MAC 189