1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
//===-- MachVMMemory.cpp ----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Created by Greg Clayton on 6/26/07.
//
//===----------------------------------------------------------------------===//
#include "MachVMMemory.h"
#include "MachVMRegion.h"
#include "DNBLog.h"
#include <mach/mach_vm.h>
MachVMMemory::MachVMMemory() :
m_page_size (kInvalidPageSize),
m_err (0)
{
}
MachVMMemory::~MachVMMemory()
{
}
nub_size_t
MachVMMemory::PageSize()
{
if (m_page_size == kInvalidPageSize)
{
m_err = ::host_page_size( ::mach_host_self(), &m_page_size);
if (m_err.Fail())
m_page_size = 0;
}
return m_page_size;
}
nub_size_t
MachVMMemory::MaxBytesLeftInPage(nub_addr_t addr, nub_size_t count)
{
const nub_size_t page_size = PageSize();
if (page_size > 0)
{
nub_size_t page_offset = (addr % page_size);
nub_size_t bytes_left_in_page = page_size - page_offset;
if (count > bytes_left_in_page)
count = bytes_left_in_page;
}
return count;
}
nub_bool_t
MachVMMemory::GetMemoryRegionInfo(task_t task, nub_addr_t address, DNBRegionInfo *region_info)
{
MachVMRegion vmRegion(task);
if (vmRegion.GetRegionForAddress(address))
{
region_info->addr = vmRegion.StartAddress();
region_info->size = vmRegion.GetByteSize();
region_info->permissions = vmRegion.GetDNBPermissions();
}
else
{
region_info->addr = address;
region_info->size = 0;
if (vmRegion.GetError().Success())
{
// vmRegion.GetRegionForAddress() return false, indicating that "address"
// wasn't in a valid region, but the "vmRegion" info was successfully
// read from the task which means the info describes the next valid
// region from which we can infer the size of this invalid region
mach_vm_address_t start_addr = vmRegion.StartAddress();
if (address < start_addr)
region_info->size = start_addr - address;
}
// If we can't get any infor about the size from the next region, just fill
// 1 in as the byte size
if (region_info->size == 0)
region_info->size = 1;
// Not readable, writeable or executable
region_info->permissions = 0;
}
return true;
}
nub_size_t
MachVMMemory::Read(task_t task, nub_addr_t address, void *data, nub_size_t data_count)
{
if (data == NULL || data_count == 0)
return 0;
nub_size_t total_bytes_read = 0;
nub_addr_t curr_addr = address;
uint8_t *curr_data = (uint8_t*)data;
while (total_bytes_read < data_count)
{
mach_vm_size_t curr_size = MaxBytesLeftInPage(curr_addr, data_count - total_bytes_read);
mach_msg_type_number_t curr_bytes_read = 0;
vm_offset_t vm_memory = NULL;
m_err = ::mach_vm_read (task, curr_addr, curr_size, &vm_memory, &curr_bytes_read);
// We end up being asked to read memory at 0x0 a lot without that being a real error, so that ends up just
// causing a lot of useless log spam. Only complain on failing reads if the address is not 0x0.
if (DNBLogCheckLogBit(LOG_MEMORY) || (m_err.Fail() && curr_addr != 0))
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);
if (m_err.Success())
{
if (curr_bytes_read != curr_size)
{
if (DNBLogCheckLogBit(LOG_MEMORY))
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);
}
::memcpy (curr_data, (void *)vm_memory, curr_bytes_read);
::vm_deallocate (mach_task_self (), vm_memory, curr_bytes_read);
total_bytes_read += curr_bytes_read;
curr_addr += curr_bytes_read;
curr_data += curr_bytes_read;
}
else
{
break;
}
}
return total_bytes_read;
}
nub_size_t
MachVMMemory::Write(task_t task, nub_addr_t address, const void *data, nub_size_t data_count)
{
MachVMRegion vmRegion(task);
nub_size_t total_bytes_written = 0;
nub_addr_t curr_addr = address;
const uint8_t *curr_data = (const uint8_t*)data;
while (total_bytes_written < data_count)
{
if (vmRegion.GetRegionForAddress(curr_addr))
{
mach_vm_size_t curr_data_count = data_count - total_bytes_written;
mach_vm_size_t region_bytes_left = vmRegion.BytesRemaining(curr_addr);
if (region_bytes_left == 0)
{
break;
}
if (curr_data_count > region_bytes_left)
curr_data_count = region_bytes_left;
if (vmRegion.SetProtections(curr_addr, curr_data_count, VM_PROT_READ | VM_PROT_WRITE))
{
nub_size_t bytes_written = WriteRegion(task, curr_addr, curr_data, curr_data_count);
if (bytes_written <= 0)
{
// Error should have already be posted by WriteRegion...
break;
}
else
{
total_bytes_written += bytes_written;
curr_addr += bytes_written;
curr_data += bytes_written;
}
}
else
{
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));
break;
}
}
else
{
DNBLogThreadedIf(LOG_MEMORY_PROTECTIONS, "Failed to get region for address: 0x%8.8llx", (uint64_t)address);
break;
}
}
return total_bytes_written;
}
nub_size_t
MachVMMemory::WriteRegion(task_t task, const nub_addr_t address, const void *data, const nub_size_t data_count)
{
if (data == NULL || data_count == 0)
return 0;
nub_size_t total_bytes_written = 0;
nub_addr_t curr_addr = address;
const uint8_t *curr_data = (const uint8_t*)data;
while (total_bytes_written < data_count)
{
mach_msg_type_number_t curr_data_count = MaxBytesLeftInPage(curr_addr, data_count - total_bytes_written);
m_err = ::mach_vm_write (task, curr_addr, (pointer_t) curr_data, curr_data_count);
if (DNBLogCheckLogBit(LOG_MEMORY) || m_err.Fail())
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);
#if !defined (__i386__) && !defined (__x86_64__)
vm_machine_attribute_val_t mattr_value = MATTR_VAL_CACHE_FLUSH;
m_err = ::vm_machine_attribute (task, curr_addr, curr_data_count, MATTR_CACHE, &mattr_value);
if (DNBLogCheckLogBit(LOG_MEMORY) || m_err.Fail())
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);
#endif
if (m_err.Success())
{
total_bytes_written += curr_data_count;
curr_addr += curr_data_count;
curr_data += curr_data_count;
}
else
{
break;
}
}
return total_bytes_written;
}
|
