MachVMMemory.cpp revision d906b1b24a6c838d78039b399ee43dc57598ab52
1//===-- MachVMMemory.cpp ----------------------------------------*- C++ -*-===// 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// Created by Greg Clayton on 6/26/07. 11// 12//===----------------------------------------------------------------------===// 13 14#include "MachVMMemory.h" 15#include "MachVMRegion.h" 16#include "DNBLog.h" 17#include <mach/mach_vm.h> 18 19MachVMMemory::MachVMMemory() : 20 m_page_size (kInvalidPageSize), 21 m_err (0) 22{ 23} 24 25MachVMMemory::~MachVMMemory() 26{ 27} 28 29nub_size_t 30MachVMMemory::PageSize() 31{ 32 if (m_page_size == kInvalidPageSize) 33 { 34 m_err = ::host_page_size( ::mach_host_self(), &m_page_size); 35 if (m_err.Fail()) 36 m_page_size = 0; 37 } 38 return m_page_size; 39} 40 41nub_size_t 42MachVMMemory::MaxBytesLeftInPage(nub_addr_t addr, nub_size_t count) 43{ 44 const nub_size_t page_size = PageSize(); 45 if (page_size > 0) 46 { 47 nub_size_t page_offset = (addr % page_size); 48 nub_size_t bytes_left_in_page = page_size - page_offset; 49 if (count > bytes_left_in_page) 50 count = bytes_left_in_page; 51 } 52 return count; 53} 54 55int 56MachVMMemory::GetMemoryRegionInfo(task_t task, nub_addr_t address, DNBRegionInfo *region_info) 57{ 58 MachVMRegion vmRegion(task); 59 60 if (vmRegion.GetRegionForAddress(address)) 61 { 62 region_info->addr = vmRegion.StartAddress(); 63 region_info->size = vmRegion.GetByteSize(); 64 region_info->permissions = vmRegion.GetDNBPermissions(); 65 return 1; 66 } 67 region_info->addr = 0; 68 region_info->size = 0; 69 region_info->permissions = 0; 70 return 0; 71} 72 73nub_size_t 74MachVMMemory::Read(task_t task, nub_addr_t address, void *data, nub_size_t data_count) 75{ 76 if (data == NULL || data_count == 0) 77 return 0; 78 79 nub_size_t total_bytes_read = 0; 80 nub_addr_t curr_addr = address; 81 uint8_t *curr_data = (uint8_t*)data; 82 while (total_bytes_read < data_count) 83 { 84 mach_vm_size_t curr_size = MaxBytesLeftInPage(curr_addr, data_count - total_bytes_read); 85 mach_msg_type_number_t curr_bytes_read = 0; 86 vm_offset_t vm_memory = NULL; 87 m_err = ::mach_vm_read (task, curr_addr, curr_size, &vm_memory, &curr_bytes_read); 88 89 // We end up being asked to read memory at 0x0 a lot without that being a real error, so that ends up just 90 // causing a lot of useless log spam. Only complain on failing reads if the address is not 0x0. 91 if (DNBLogCheckLogBit(LOG_MEMORY) || (m_err.Fail() && curr_addr != 0)) 92 m_err.LogThreaded("::mach_vm_read ( task = 0x%4.4x, addr = 0x%8.8llx, size = %llu, data => %8.8p, dataCnt => %i )", task, (uint64_t)curr_addr, (uint64_t)curr_size, vm_memory, curr_bytes_read); 93 94 if (m_err.Success()) 95 { 96 if (curr_bytes_read != curr_size) 97 { 98 if (DNBLogCheckLogBit(LOG_MEMORY)) 99 m_err.LogThreaded("::mach_vm_read ( task = 0x%4.4x, addr = 0x%8.8llx, size = %llu, data => %8.8p, dataCnt=>%i ) only read %u of %llu bytes", task, (uint64_t)curr_addr, (uint64_t)curr_size, vm_memory, curr_bytes_read, curr_bytes_read, (uint64_t)curr_size); 100 } 101 ::memcpy (curr_data, (void *)vm_memory, curr_bytes_read); 102 ::vm_deallocate (mach_task_self (), vm_memory, curr_bytes_read); 103 total_bytes_read += curr_bytes_read; 104 curr_addr += curr_bytes_read; 105 curr_data += curr_bytes_read; 106 } 107 else 108 { 109 break; 110 } 111 } 112 return total_bytes_read; 113} 114 115 116nub_size_t 117MachVMMemory::Write(task_t task, nub_addr_t address, const void *data, nub_size_t data_count) 118{ 119 MachVMRegion vmRegion(task); 120 121 nub_size_t total_bytes_written = 0; 122 nub_addr_t curr_addr = address; 123 const uint8_t *curr_data = (const uint8_t*)data; 124 125 126 while (total_bytes_written < data_count) 127 { 128 if (vmRegion.GetRegionForAddress(curr_addr)) 129 { 130 mach_vm_size_t curr_data_count = data_count - total_bytes_written; 131 mach_vm_size_t region_bytes_left = vmRegion.BytesRemaining(curr_addr); 132 if (region_bytes_left == 0) 133 { 134 break; 135 } 136 if (curr_data_count > region_bytes_left) 137 curr_data_count = region_bytes_left; 138 139 if (vmRegion.SetProtections(curr_addr, curr_data_count, VM_PROT_READ | VM_PROT_WRITE)) 140 { 141 nub_size_t bytes_written = WriteRegion(task, curr_addr, curr_data, curr_data_count); 142 if (bytes_written <= 0) 143 { 144 // Error should have already be posted by WriteRegion... 145 break; 146 } 147 else 148 { 149 total_bytes_written += bytes_written; 150 curr_addr += bytes_written; 151 curr_data += bytes_written; 152 } 153 } 154 else 155 { 156 DNBLogThreadedIf(LOG_MEMORY_PROTECTIONS, "Failed to set read/write protections on region for address: [0x%8.8llx-0x%8.8llx)", (uint64_t)curr_addr, (uint64_t)(curr_addr + curr_data_count)); 157 break; 158 } 159 } 160 else 161 { 162 DNBLogThreadedIf(LOG_MEMORY_PROTECTIONS, "Failed to get region for address: 0x%8.8llx", (uint64_t)address); 163 break; 164 } 165 } 166 167 return total_bytes_written; 168} 169 170 171nub_size_t 172MachVMMemory::WriteRegion(task_t task, const nub_addr_t address, const void *data, const nub_size_t data_count) 173{ 174 if (data == NULL || data_count == 0) 175 return 0; 176 177 nub_size_t total_bytes_written = 0; 178 nub_addr_t curr_addr = address; 179 const uint8_t *curr_data = (const uint8_t*)data; 180 while (total_bytes_written < data_count) 181 { 182 mach_msg_type_number_t curr_data_count = MaxBytesLeftInPage(curr_addr, data_count - total_bytes_written); 183 m_err = ::mach_vm_write (task, curr_addr, (pointer_t) curr_data, curr_data_count); 184 if (DNBLogCheckLogBit(LOG_MEMORY) || m_err.Fail()) 185 m_err.LogThreaded("::mach_vm_write ( task = 0x%4.4x, addr = 0x%8.8llx, data = %8.8p, dataCnt = %u )", task, (uint64_t)curr_addr, curr_data, curr_data_count); 186 187#if !defined (__i386__) && !defined (__x86_64__) 188 vm_machine_attribute_val_t mattr_value = MATTR_VAL_CACHE_FLUSH; 189 190 m_err = ::vm_machine_attribute (task, curr_addr, curr_data_count, MATTR_CACHE, &mattr_value); 191 if (DNBLogCheckLogBit(LOG_MEMORY) || m_err.Fail()) 192 m_err.LogThreaded("::vm_machine_attribute ( task = 0x%4.4x, addr = 0x%8.8llx, size = %u, attr = MATTR_CACHE, mattr_value => MATTR_VAL_CACHE_FLUSH )", task, (uint64_t)curr_addr, curr_data_count); 193#endif 194 195 if (m_err.Success()) 196 { 197 total_bytes_written += curr_data_count; 198 curr_addr += curr_data_count; 199 curr_data += curr_data_count; 200 } 201 else 202 { 203 break; 204 } 205 } 206 return total_bytes_written; 207} 208