3dc8583c96
Add a more general purpose qMemoryRegionInfo packet which can describe various attributes about a memory region. Currently it will return the start address, size, and permissions (read, write, executable) for the memory region. It may be possible to add additional attributes in the future such as whether the region is designated as stack memory or jitted code a la vmmap. I still haven't implemented the lldb side of the code to use this packet yet so there may be unexpected behavior - but the basic implementation looks about right. I'll hook it up to lldb soon and fix any problems that crop up. llvm-svn: 144175
204 lines
7.2 KiB
C++
204 lines
7.2 KiB
C++
//===-- MachVMRegion.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 "MachVMRegion.h"
|
|
#include <mach/mach_vm.h>
|
|
#include "DNBLog.h"
|
|
#include <assert.h>
|
|
|
|
MachVMRegion::MachVMRegion(task_t task) :
|
|
m_task(task),
|
|
m_addr(INVALID_NUB_ADDRESS),
|
|
m_err(),
|
|
m_start(INVALID_NUB_ADDRESS),
|
|
m_size(0),
|
|
m_depth(-1),
|
|
m_curr_protection(0),
|
|
m_protection_addr(INVALID_NUB_ADDRESS),
|
|
m_protection_size(0)
|
|
{
|
|
memset(&m_data, 0, sizeof(m_data));
|
|
}
|
|
|
|
MachVMRegion::~MachVMRegion()
|
|
{
|
|
// Restore any original protections and clear our vars
|
|
Clear();
|
|
}
|
|
|
|
void
|
|
MachVMRegion::Clear()
|
|
{
|
|
RestoreProtections();
|
|
m_addr = INVALID_NUB_ADDRESS;
|
|
m_err.Clear();
|
|
m_start = INVALID_NUB_ADDRESS;
|
|
m_size = 0;
|
|
m_depth = -1;
|
|
memset(&m_data, 0, sizeof(m_data));
|
|
m_curr_protection = 0;
|
|
m_protection_addr = INVALID_NUB_ADDRESS;
|
|
m_protection_size = 0;
|
|
}
|
|
|
|
bool
|
|
MachVMRegion::SetProtections(mach_vm_address_t addr, mach_vm_size_t size, vm_prot_t prot)
|
|
{
|
|
if (ContainsAddress(addr))
|
|
{
|
|
mach_vm_size_t prot_size = size;
|
|
mach_vm_address_t end_addr = EndAddress();
|
|
if (prot_size > (end_addr - addr))
|
|
prot_size = end_addr - addr;
|
|
|
|
if (prot_size > 0)
|
|
{
|
|
if (prot == (m_curr_protection & VM_PROT_ALL))
|
|
{
|
|
DNBLogThreadedIf(LOG_MEMORY_PROTECTIONS | LOG_VERBOSE, "MachVMRegion::%s: protections (%u) already sufficient for task 0x%4.4x at address 0x%8.8llx) ", __FUNCTION__, prot, m_task, (uint64_t)addr);
|
|
// Protections are already set as requested...
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
m_err = ::mach_vm_protect (m_task, addr, prot_size, 0, prot);
|
|
if (DNBLogCheckLogBit(LOG_MEMORY_PROTECTIONS))
|
|
m_err.LogThreaded("::mach_vm_protect ( task = 0x%4.4x, addr = 0x%8.8llx, size = %llu, set_max = %i, prot = %u )", m_task, (uint64_t)addr, (uint64_t)prot_size, 0, prot);
|
|
if (m_err.Fail())
|
|
{
|
|
// Try again with the ability to create a copy on write region
|
|
m_err = ::mach_vm_protect (m_task, addr, prot_size, 0, prot | VM_PROT_COPY);
|
|
if (DNBLogCheckLogBit(LOG_MEMORY_PROTECTIONS) || m_err.Fail())
|
|
m_err.LogThreaded("::mach_vm_protect ( task = 0x%4.4x, addr = 0x%8.8llx, size = %llu, set_max = %i, prot = %u )", m_task, (uint64_t)addr, (uint64_t)prot_size, 0, prot | VM_PROT_COPY);
|
|
}
|
|
if (m_err.Success())
|
|
{
|
|
m_curr_protection = prot;
|
|
m_protection_addr = addr;
|
|
m_protection_size = prot_size;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DNBLogThreadedIf(LOG_MEMORY_PROTECTIONS | LOG_VERBOSE, "%s: Zero size for task 0x%4.4x at address 0x%8.8llx) ", __FUNCTION__, m_task, (uint64_t)addr);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
MachVMRegion::RestoreProtections()
|
|
{
|
|
if (m_curr_protection != m_data.protection && m_protection_size > 0)
|
|
{
|
|
m_err = ::mach_vm_protect (m_task, m_protection_addr, m_protection_size, 0, m_data.protection);
|
|
if (DNBLogCheckLogBit(LOG_MEMORY_PROTECTIONS) || m_err.Fail())
|
|
m_err.LogThreaded("::mach_vm_protect ( task = 0x%4.4x, addr = 0x%8.8llx, size = %llu, set_max = %i, prot = %u )", m_task, (uint64_t)m_protection_addr, (uint64_t)m_protection_size, 0, m_data.protection);
|
|
if (m_err.Success())
|
|
{
|
|
m_protection_size = 0;
|
|
m_protection_addr = INVALID_NUB_ADDRESS;
|
|
m_curr_protection = m_data.protection;
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_err.Clear();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
MachVMRegion::GetRegionForAddress(nub_addr_t addr)
|
|
{
|
|
// Restore any original protections and clear our vars
|
|
Clear();
|
|
m_addr = addr;
|
|
m_start = addr;
|
|
m_depth = 1024;
|
|
mach_msg_type_number_t info_size = kRegionInfoSize;
|
|
assert(sizeof(info_size) == 4);
|
|
m_err = ::mach_vm_region_recurse (m_task, &m_start, &m_size, &m_depth, (vm_region_recurse_info_t)&m_data, &info_size);
|
|
if (DNBLogCheckLogBit(LOG_MEMORY_PROTECTIONS) || m_err.Fail())
|
|
m_err.LogThreaded("::mach_vm_region_recurse ( task = 0x%4.4x, address => 0x%8.8llx, size => %llu, nesting_depth => %d, info => %p, infoCnt => %d) addr = 0x%8.8llx ", m_task, (uint64_t)m_start, (uint64_t)m_size, m_depth, &m_data, info_size, (uint64_t)addr);
|
|
if (m_err.Fail())
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (DNBLogCheckLogBit(LOG_MEMORY_PROTECTIONS))
|
|
{
|
|
DNBLogThreaded("info = { prot = %u, "
|
|
"max_prot = %u, "
|
|
"inheritance = 0x%8.8x, "
|
|
"offset = 0x%8.8llx, "
|
|
"user_tag = 0x%8.8x, "
|
|
"ref_count = %u, "
|
|
"shadow_depth = %u, "
|
|
"ext_pager = %u, "
|
|
"share_mode = %u, "
|
|
"is_submap = %d, "
|
|
"behavior = %d, "
|
|
"object_id = 0x%8.8x, "
|
|
"user_wired_count = 0x%4.4x }",
|
|
m_data.protection,
|
|
m_data.max_protection,
|
|
m_data.inheritance,
|
|
(uint64_t)m_data.offset,
|
|
m_data.user_tag,
|
|
m_data.ref_count,
|
|
m_data.shadow_depth,
|
|
m_data.external_pager,
|
|
m_data.share_mode,
|
|
m_data.is_submap,
|
|
m_data.behavior,
|
|
m_data.object_id,
|
|
m_data.user_wired_count);
|
|
}
|
|
}
|
|
|
|
m_curr_protection = m_data.protection;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
MachVMRegion::GetRegionDescription (char *outbuf, nub_size_t outbufsize)
|
|
{
|
|
if (m_addr == INVALID_NUB_ADDRESS || m_start == INVALID_NUB_ADDRESS || m_size == 0)
|
|
return false;
|
|
snprintf (outbuf, outbufsize, "start:%llx,size:%llx", m_start, m_size);
|
|
outbuf[outbufsize - 1] = '\0';
|
|
|
|
char tmpbuf[128];
|
|
strcpy (tmpbuf, ",permissions:");
|
|
if ((m_data.protection & VM_PROT_READ) == VM_PROT_READ)
|
|
strcat (tmpbuf, "r");
|
|
if ((m_data.protection & VM_PROT_WRITE) == VM_PROT_WRITE)
|
|
strcat (tmpbuf, "w");
|
|
if ((m_data.protection & VM_PROT_EXECUTE) == VM_PROT_EXECUTE)
|
|
strcat (tmpbuf, "x");
|
|
strlcat (outbuf, tmpbuf, outbufsize);
|
|
|
|
// It would be nice if we could figure out whether the memory region is stack memory or jitted code memory as well
|
|
|
|
outbuf[outbufsize - 1] = '\0';
|
|
return true;
|
|
}
|