//===-- 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_err.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);
    
    const bool failed = m_err.Fail();
    const bool log_protections = DNBLogCheckLogBit(LOG_MEMORY_PROTECTIONS);

    if (log_protections || failed)
        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 (failed)
        return false;
    if (log_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;
    
    // We make a request for an address and got no error back, but this
    // doesn't mean that "addr" is in the range. The data in this object will 
    // be valid though, so you could see where the next region begins. So we
    // return false, yet leave "m_err" with a successfull return code.
    if ((addr < m_start) || (addr >= (m_start + m_size)))
        return false;

    return true;
}

uint32_t
MachVMRegion::GetDNBPermissions () const
{
    if (m_addr == INVALID_NUB_ADDRESS || m_start == INVALID_NUB_ADDRESS || m_size == 0)
      return 0;
    uint32_t dnb_permissions = 0;
    
    if ((m_data.protection & VM_PROT_READ) == VM_PROT_READ)
        dnb_permissions |= eMemoryPermissionsReadable;
    if ((m_data.protection & VM_PROT_WRITE) == VM_PROT_WRITE)
        dnb_permissions |= eMemoryPermissionsWritable;
    if ((m_data.protection & VM_PROT_EXECUTE) == VM_PROT_EXECUTE)
        dnb_permissions |= eMemoryPermissionsExecutable;
    return dnb_permissions;
}