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 
19 MachVMMemory::MachVMMemory() :
20     m_page_size    (kInvalidPageSize),
21     m_err        (0)
22 {
23 }
24 
25 MachVMMemory::~MachVMMemory()
26 {
27 }
28 
29 nub_size_t
30 MachVMMemory::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 
41 nub_size_t
42 MachVMMemory::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 
55 int
56 MachVMMemory::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 
73 nub_size_t
74 MachVMMemory::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         if (DNBLogCheckLogBit(LOG_MEMORY) || m_err.Fail())
89             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);
90 
91         if (m_err.Success())
92         {
93             if (curr_bytes_read != curr_size)
94             {
95                 if (DNBLogCheckLogBit(LOG_MEMORY))
96                     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);
97             }
98             ::memcpy (curr_data, (void *)vm_memory, curr_bytes_read);
99             ::vm_deallocate (mach_task_self (), vm_memory, curr_bytes_read);
100             total_bytes_read += curr_bytes_read;
101             curr_addr += curr_bytes_read;
102             curr_data += curr_bytes_read;
103         }
104         else
105         {
106             break;
107         }
108     }
109     return total_bytes_read;
110 }
111 
112 
113 nub_size_t
114 MachVMMemory::Write(task_t task, nub_addr_t address, const void *data, nub_size_t data_count)
115 {
116     MachVMRegion vmRegion(task);
117 
118     nub_size_t total_bytes_written = 0;
119     nub_addr_t curr_addr = address;
120     const uint8_t *curr_data = (const uint8_t*)data;
121 
122 
123     while (total_bytes_written < data_count)
124     {
125         if (vmRegion.GetRegionForAddress(curr_addr))
126         {
127             mach_vm_size_t curr_data_count = data_count - total_bytes_written;
128             mach_vm_size_t region_bytes_left = vmRegion.BytesRemaining(curr_addr);
129             if (region_bytes_left == 0)
130             {
131                 break;
132             }
133             if (curr_data_count > region_bytes_left)
134                 curr_data_count = region_bytes_left;
135 
136             if (vmRegion.SetProtections(curr_addr, curr_data_count, VM_PROT_READ | VM_PROT_WRITE))
137             {
138                 nub_size_t bytes_written = WriteRegion(task, curr_addr, curr_data, curr_data_count);
139                 if (bytes_written <= 0)
140                 {
141                     // Error should have already be posted by WriteRegion...
142                     break;
143                 }
144                 else
145                 {
146                     total_bytes_written += bytes_written;
147                     curr_addr += bytes_written;
148                     curr_data += bytes_written;
149                 }
150             }
151             else
152             {
153                 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));
154                 break;
155             }
156         }
157         else
158         {
159             DNBLogThreadedIf(LOG_MEMORY_PROTECTIONS, "Failed to get region for address: 0x%8.8llx", (uint64_t)address);
160             break;
161         }
162     }
163 
164     return total_bytes_written;
165 }
166 
167 
168 nub_size_t
169 MachVMMemory::WriteRegion(task_t task, const nub_addr_t address, const void *data, const nub_size_t data_count)
170 {
171     if (data == NULL || data_count == 0)
172         return 0;
173 
174     nub_size_t total_bytes_written = 0;
175     nub_addr_t curr_addr = address;
176     const uint8_t *curr_data = (const uint8_t*)data;
177     while (total_bytes_written < data_count)
178     {
179         mach_msg_type_number_t curr_data_count = MaxBytesLeftInPage(curr_addr, data_count - total_bytes_written);
180         m_err = ::mach_vm_write (task, curr_addr, (pointer_t) curr_data, curr_data_count);
181         if (DNBLogCheckLogBit(LOG_MEMORY) || m_err.Fail())
182             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);
183 
184 #if !defined (__i386__) && !defined (__x86_64__)
185         vm_machine_attribute_val_t mattr_value = MATTR_VAL_CACHE_FLUSH;
186 
187         m_err = ::vm_machine_attribute (task, curr_addr, curr_data_count, MATTR_CACHE, &mattr_value);
188         if (DNBLogCheckLogBit(LOG_MEMORY) || m_err.Fail())
189             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);
190 #endif
191 
192         if (m_err.Success())
193         {
194             total_bytes_written += curr_data_count;
195             curr_addr += curr_data_count;
196             curr_data += curr_data_count;
197         }
198         else
199         {
200             break;
201         }
202     }
203     return total_bytes_written;
204 }
205