MachVMMemory.cpp revision 55f768792c75eb5f9474edb09ca416c8737eeac0 
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
55nub_bool_t
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    }
66    else
67    {
68        region_info->addr = address;
69        region_info->size = 0;
70        if (vmRegion.GetError().Success())
71        {
72            // vmRegion.GetRegionForAddress() return false, indicating that "address"
73            // wasn't in a valid region, but the "vmRegion" info was successfully
74            // read from the task which means the info describes the next valid
75            // region from which we can infer the size of this invalid region
76            mach_vm_address_t start_addr = vmRegion.StartAddress();
77            if (address < start_addr)
78                region_info->size = start_addr - address;
79        }
80        // If we can't get any infor about the size from the next region, just fill
81        // 1 in as the byte size
82        if (region_info->size == 0)
83            region_info->size = 1;
84
85        // Not readable, writeable or executable
86        region_info->permissions = 0;
87    }
88    return true;
89}
90
91nub_size_t
92MachVMMemory::Read(task_t task, nub_addr_t address, void *data, nub_size_t data_count)
93{
94    if (data == NULL || data_count == 0)
95        return 0;
96
97    nub_size_t total_bytes_read = 0;
98    nub_addr_t curr_addr = address;
99    uint8_t *curr_data = (uint8_t*)data;
100    while (total_bytes_read < data_count)
101    {
102        mach_vm_size_t curr_size = MaxBytesLeftInPage(curr_addr, data_count - total_bytes_read);
103        mach_msg_type_number_t curr_bytes_read = 0;
104        vm_offset_t vm_memory = NULL;
105        m_err = ::mach_vm_read (task, curr_addr, curr_size, &vm_memory, &curr_bytes_read);
106
107        if (DNBLogCheckLogBit(LOG_MEMORY))
108            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);
109
110        if (m_err.Success())
111        {
112            if (curr_bytes_read != curr_size)
113            {
114                if (DNBLogCheckLogBit(LOG_MEMORY))
115                    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);
116            }
117            ::memcpy (curr_data, (void *)vm_memory, curr_bytes_read);
118            ::vm_deallocate (mach_task_self (), vm_memory, curr_bytes_read);
119            total_bytes_read += curr_bytes_read;
120            curr_addr += curr_bytes_read;
121            curr_data += curr_bytes_read;
122        }
123        else
124        {
125            break;
126        }
127    }
128    return total_bytes_read;
129}
130
131
132nub_size_t
133MachVMMemory::Write(task_t task, nub_addr_t address, const void *data, nub_size_t data_count)
134{
135    MachVMRegion vmRegion(task);
136
137    nub_size_t total_bytes_written = 0;
138    nub_addr_t curr_addr = address;
139    const uint8_t *curr_data = (const uint8_t*)data;
140
141
142    while (total_bytes_written < data_count)
143    {
144        if (vmRegion.GetRegionForAddress(curr_addr))
145        {
146            mach_vm_size_t curr_data_count = data_count - total_bytes_written;
147            mach_vm_size_t region_bytes_left = vmRegion.BytesRemaining(curr_addr);
148            if (region_bytes_left == 0)
149            {
150                break;
151            }
152            if (curr_data_count > region_bytes_left)
153                curr_data_count = region_bytes_left;
154
155            if (vmRegion.SetProtections(curr_addr, curr_data_count, VM_PROT_READ | VM_PROT_WRITE))
156            {
157                nub_size_t bytes_written = WriteRegion(task, curr_addr, curr_data, curr_data_count);
158                if (bytes_written <= 0)
159                {
160                    // Error should have already be posted by WriteRegion...
161                    break;
162                }
163                else
164                {
165                    total_bytes_written += bytes_written;
166                    curr_addr += bytes_written;
167                    curr_data += bytes_written;
168                }
169            }
170            else
171            {
172                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));
173                break;
174            }
175        }
176        else
177        {
178            DNBLogThreadedIf(LOG_MEMORY_PROTECTIONS, "Failed to get region for address: 0x%8.8llx", (uint64_t)address);
179            break;
180        }
181    }
182
183    return total_bytes_written;
184}
185
186
187nub_size_t
188MachVMMemory::WriteRegion(task_t task, const nub_addr_t address, const void *data, const nub_size_t data_count)
189{
190    if (data == NULL || data_count == 0)
191        return 0;
192
193    nub_size_t total_bytes_written = 0;
194    nub_addr_t curr_addr = address;
195    const uint8_t *curr_data = (const uint8_t*)data;
196    while (total_bytes_written < data_count)
197    {
198        mach_msg_type_number_t curr_data_count = MaxBytesLeftInPage(curr_addr, data_count - total_bytes_written);
199        m_err = ::mach_vm_write (task, curr_addr, (pointer_t) curr_data, curr_data_count);
200        if (DNBLogCheckLogBit(LOG_MEMORY) || m_err.Fail())
201            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);
202
203#if !defined (__i386__) && !defined (__x86_64__)
204        vm_machine_attribute_val_t mattr_value = MATTR_VAL_CACHE_FLUSH;
205
206        m_err = ::vm_machine_attribute (task, curr_addr, curr_data_count, MATTR_CACHE, &mattr_value);
207        if (DNBLogCheckLogBit(LOG_MEMORY) || m_err.Fail())
208            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);
209#endif
210
211        if (m_err.Success())
212        {
213            total_bytes_written += curr_data_count;
214            curr_addr += curr_data_count;
215            curr_data += curr_data_count;
216        }
217        else
218        {
219            break;
220        }
221    }
222    return total_bytes_written;
223}
224