lldb/tools/debugserver/source/MacOSX/MachVMMemory.cpp

   1 //===-- MachVMMemory.cpp ----------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 //  Created by Greg Clayton on 6/26/07.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "MachVMMemory.h"
  14 #include "DNBLog.h"
  15 #include "MachVMRegion.h"
  16 #include <dlfcn.h>
  17 #include <mach/mach_vm.h>
  18 #include <mach/shared_region.h>
  19 #include <sys/sysctl.h>
  20
  21 #if defined(WITH_FBS) || defined(WITH_BKS)
  22 extern "C" {
  23 #import <System/sys/kern_memorystatus.h>
  24 }
  25 #endif
  26
  27 static const vm_size_t kInvalidPageSize = ~0;
  28
  29 MachVMMemory::MachVMMemory() : m_page_size(kInvalidPageSize), m_err(0) {}
  30
  31 MachVMMemory::~MachVMMemory() = default;
  32
  33 nub_size_t MachVMMemory::PageSize(task_t task) {
  34   if (m_page_size == kInvalidPageSize) {
  35 #if defined(TASK_VM_INFO) && TASK_VM_INFO >= 22
  36     if (task != TASK_NULL) {
  37       kern_return_t kr;
  38       mach_msg_type_number_t info_count = TASK_VM_INFO_COUNT;
  39       task_vm_info_data_t vm_info;
  40       kr = task_info(task, TASK_VM_INFO, (task_info_t)&vm_info, &info_count);
  41       if (kr == KERN_SUCCESS) {
  42         DNBLogThreadedIf(
  43             LOG_TASK,
  44             "MachVMMemory::PageSize task_info returned page size of 0x%x",
  45             (int)vm_info.page_size);
  46         m_page_size = vm_info.page_size;
  47         return m_page_size;
  48       } else {
  49         DNBLogThreadedIf(LOG_TASK, "MachVMMemory::PageSize task_info call "
  50                                    "failed to get page size, TASK_VM_INFO %d, "
  51                                    "TASK_VM_INFO_COUNT %d, kern return %d",
  52                          TASK_VM_INFO, TASK_VM_INFO_COUNT, kr);
  53       }
  54     }
  55 #endif
  56     m_err = ::host_page_size(::mach_host_self(), &m_page_size);
  57     if (m_err.Fail())
  58       m_page_size = 0;
  59   }
  60   return m_page_size;
  61 }
  62
  63 nub_size_t MachVMMemory::MaxBytesLeftInPage(task_t task, nub_addr_t addr,
  64                                             nub_size_t count) {
  65   const nub_size_t page_size = PageSize(task);
  66   if (page_size > 0) {
  67     nub_size_t page_offset = (addr % page_size);
  68     nub_size_t bytes_left_in_page = page_size - page_offset;
  69     if (count > bytes_left_in_page)
  70       count = bytes_left_in_page;
  71   }
  72   return count;
  73 }
  74
  75 #define MAX_STACK_ALLOC_DISPOSITIONS                                           \
  76   (16 * 1024 / sizeof(int)) // 16K of allocations
  77
  78 std::vector<nub_addr_t> get_dirty_pages(task_t task, mach_vm_address_t addr,
  79                                         mach_vm_size_t size) {
  80   std::vector<nub_addr_t> dirty_pages;
  81
  82   int pages_to_query = size / vm_page_size;
  83   // Don't try to fetch too many pages' dispositions in a single call or we
  84   // could blow our stack out.
  85   mach_vm_size_t dispositions_size =
  86       std::min(pages_to_query, (int)MAX_STACK_ALLOC_DISPOSITIONS);
  87   int dispositions[dispositions_size];
  88
  89   mach_vm_size_t chunk_count =
  90       ((pages_to_query + MAX_STACK_ALLOC_DISPOSITIONS - 1) /
  91        MAX_STACK_ALLOC_DISPOSITIONS);
  92
  93   for (mach_vm_size_t cur_disposition_chunk = 0;
  94        cur_disposition_chunk < chunk_count; cur_disposition_chunk++) {
  95     mach_vm_size_t dispositions_already_queried =
  96         cur_disposition_chunk * MAX_STACK_ALLOC_DISPOSITIONS;
  97
  98     mach_vm_size_t chunk_pages_to_query = std::min(
  99         pages_to_query - dispositions_already_queried, dispositions_size);
 100     mach_vm_address_t chunk_page_aligned_start_addr =
 101         addr + (dispositions_already_queried * vm_page_size);
 102
 103     kern_return_t kr = mach_vm_page_range_query(
 104         task, chunk_page_aligned_start_addr,
 105         chunk_pages_to_query * vm_page_size, (mach_vm_address_t)dispositions,
 106         &chunk_pages_to_query);
 107     if (kr != KERN_SUCCESS)
 108       return dirty_pages;
 109     for (mach_vm_size_t i = 0; i < chunk_pages_to_query; i++) {
 110       uint64_t dirty_addr = chunk_page_aligned_start_addr + (i * vm_page_size);
 111       if (dispositions[i] & VM_PAGE_QUERY_PAGE_DIRTY)
 112         dirty_pages.push_back(dirty_addr);
 113     }
 114   }
 115   return dirty_pages;
 116 }
 117
 118 nub_bool_t MachVMMemory::GetMemoryRegionInfo(task_t task, nub_addr_t address,
 119                                              DNBRegionInfo *region_info) {
 120   MachVMRegion vmRegion(task);
 121
 122   if (vmRegion.GetRegionForAddress(address)) {
 123     region_info->addr = vmRegion.StartAddress();
 124     region_info->size = vmRegion.GetByteSize();
 125     region_info->permissions = vmRegion.GetDNBPermissions();
 126     region_info->dirty_pages =
 127         get_dirty_pages(task, vmRegion.StartAddress(), vmRegion.GetByteSize());
 128     region_info->vm_types = vmRegion.GetMemoryTypes();
 129   } else {
 130     region_info->addr = address;
 131     region_info->size = 0;
 132     if (vmRegion.GetError().Success()) {
 133       // vmRegion.GetRegionForAddress() return false, indicating that "address"
 134       // wasn't in a valid region, but the "vmRegion" info was successfully
 135       // read from the task which means the info describes the next valid
 136       // region from which we can infer the size of this invalid region
 137       mach_vm_address_t start_addr = vmRegion.StartAddress();
 138       if (address < start_addr)
 139         region_info->size = start_addr - address;
 140     }
 141     // If we can't get any info about the size from the next region it means
 142     // we asked about an address that was past all mappings, so the size
 143     // of this region will take up all remaining address space.
 144     if (region_info->size == 0)
 145       region_info->size = INVALID_NUB_ADDRESS - region_info->addr;
 146
 147     // Not readable, writeable or executable
 148     region_info->permissions = 0;
 149   }
 150   return true;
 151 }
 152
 153 static uint64_t GetPhysicalMemory() {
 154   // This doesn't change often at all. No need to poll each time.
 155   static uint64_t physical_memory = 0;
 156   static bool calculated = false;
 157   if (calculated)
 158     return physical_memory;
 159
 160   size_t len = sizeof(physical_memory);
 161   sysctlbyname("hw.memsize", &physical_memory, &len, NULL, 0);
 162
 163   calculated = true;
 164   return physical_memory;
 165 }
 166
 167 nub_bool_t MachVMMemory::GetMemoryProfile(
 168     DNBProfileDataScanType scanType, task_t task, struct task_basic_info ti,
 169     cpu_type_t cputype, nub_process_t pid, vm_statistics64_data_t &vminfo,
 170     uint64_t &physical_memory, uint64_t &anonymous,
 171     uint64_t &phys_footprint, uint64_t &memory_cap)
 172 {
 173   if (scanType & eProfileHostMemory)
 174     physical_memory = GetPhysicalMemory();
 175
 176   if (scanType & eProfileMemory) {
 177     static mach_port_t localHost = mach_host_self();
 178     mach_msg_type_number_t count = HOST_VM_INFO64_COUNT;
 179     host_statistics64(localHost, HOST_VM_INFO64, (host_info64_t)&vminfo,
 180                       &count);
 181
 182     kern_return_t kr;
 183     mach_msg_type_number_t info_count;
 184     task_vm_info_data_t vm_info;
 185
 186     info_count = TASK_VM_INFO_COUNT;
 187     kr = task_info(task, TASK_VM_INFO_PURGEABLE, (task_info_t)&vm_info, &info_count);
 188     if (kr == KERN_SUCCESS) {
 189       if (scanType & eProfileMemoryAnonymous) {
 190         anonymous = vm_info.internal + vm_info.compressed - vm_info.purgeable_volatile_pmap;
 191       }
 192
 193       phys_footprint = vm_info.phys_footprint;
 194     }
 195   }
 196
 197 #if defined(WITH_FBS) || defined(WITH_BKS)
 198   if (scanType & eProfileMemoryCap) {
 199     memorystatus_memlimit_properties_t memlimit_properties;
 200     memset(&memlimit_properties, 0, sizeof(memlimit_properties));
 201     if (memorystatus_control(MEMORYSTATUS_CMD_GET_MEMLIMIT_PROPERTIES, pid, 0, &memlimit_properties, sizeof(memlimit_properties)) == 0) {
 202         memory_cap = memlimit_properties.memlimit_active;
 203     }
 204   }
 205 #endif
 206
 207   return true;
 208 }
 209
 210 nub_size_t MachVMMemory::Read(task_t task, nub_addr_t address, void *data,
 211                               nub_size_t data_count) {
 212   if (data == NULL || data_count == 0)
 213     return 0;
 214
 215   nub_size_t total_bytes_read = 0;
 216   nub_addr_t curr_addr = address;
 217   uint8_t *curr_data = (uint8_t *)data;
 218   while (total_bytes_read < data_count) {
 219     mach_vm_size_t curr_size =
 220         MaxBytesLeftInPage(task, curr_addr, data_count - total_bytes_read);
 221     mach_msg_type_number_t curr_bytes_read = 0;
 222     vm_offset_t vm_memory = 0;
 223     m_err = ::mach_vm_read(task, curr_addr, curr_size, &vm_memory,
 224                            &curr_bytes_read);
 225
 226     if (DNBLogCheckLogBit(LOG_MEMORY))
 227       m_err.LogThreaded("::mach_vm_read ( task = 0x%4.4x, addr = 0x%8.8llx, "
 228                         "size = %llu, data => %8.8p, dataCnt => %i )",
 229                         task, (uint64_t)curr_addr, (uint64_t)curr_size,
 230                         vm_memory, curr_bytes_read);
 231
 232     if (m_err.Success()) {
 233       if (curr_bytes_read != curr_size) {
 234         if (DNBLogCheckLogBit(LOG_MEMORY))
 235           m_err.LogThreaded(
 236               "::mach_vm_read ( task = 0x%4.4x, addr = 0x%8.8llx, size = %llu, "
 237               "data => %8.8p, dataCnt=>%i ) only read %u of %llu bytes",
 238               task, (uint64_t)curr_addr, (uint64_t)curr_size, vm_memory,
 239               curr_bytes_read, curr_bytes_read, (uint64_t)curr_size);
 240       }
 241       ::memcpy(curr_data, (void *)vm_memory, curr_bytes_read);
 242       ::vm_deallocate(mach_task_self(), vm_memory, curr_bytes_read);
 243       total_bytes_read += curr_bytes_read;
 244       curr_addr += curr_bytes_read;
 245       curr_data += curr_bytes_read;
 246     } else {
 247       break;
 248     }
 249   }
 250   return total_bytes_read;
 251 }
 252
 253 nub_size_t MachVMMemory::Write(task_t task, nub_addr_t address,
 254                                const void *data, nub_size_t data_count) {
 255   MachVMRegion vmRegion(task);
 256
 257   nub_size_t total_bytes_written = 0;
 258   nub_addr_t curr_addr = address;
 259   const uint8_t *curr_data = (const uint8_t *)data;
 260
 261   while (total_bytes_written < data_count) {
 262     if (vmRegion.GetRegionForAddress(curr_addr)) {
 263       mach_vm_size_t curr_data_count = data_count - total_bytes_written;
 264       mach_vm_size_t region_bytes_left = vmRegion.BytesRemaining(curr_addr);
 265       if (region_bytes_left == 0) {
 266         break;
 267       }
 268       if (curr_data_count > region_bytes_left)
 269         curr_data_count = region_bytes_left;
 270
 271       if (vmRegion.SetProtections(curr_addr, curr_data_count,
 272                                   VM_PROT_READ | VM_PROT_WRITE)) {
 273         nub_size_t bytes_written =
 274             WriteRegion(task, curr_addr, curr_data, curr_data_count);
 275         if (bytes_written <= 0) {
 276           // Status should have already be posted by WriteRegion...
 277           break;
 278         } else {
 279           total_bytes_written += bytes_written;
 280           curr_addr += bytes_written;
 281           curr_data += bytes_written;
 282         }
 283       } else {
 284         DNBLogThreadedIf(
 285             LOG_MEMORY_PROTECTIONS, "Failed to set read/write protections on "
 286                                     "region for address: [0x%8.8llx-0x%8.8llx)",
 287             (uint64_t)curr_addr, (uint64_t)(curr_addr + curr_data_count));
 288         break;
 289       }
 290     } else {
 291       DNBLogThreadedIf(LOG_MEMORY_PROTECTIONS,
 292                        "Failed to get region for address: 0x%8.8llx",
 293                        (uint64_t)address);
 294       break;
 295     }
 296   }
 297
 298   return total_bytes_written;
 299 }
 300
 301 nub_size_t MachVMMemory::WriteRegion(task_t task, const nub_addr_t address,
 302                                      const void *data,
 303                                      const nub_size_t data_count) {
 304   if (data == NULL || data_count == 0)
 305     return 0;
 306
 307   nub_size_t total_bytes_written = 0;
 308   nub_addr_t curr_addr = address;
 309   const uint8_t *curr_data = (const uint8_t *)data;
 310   while (total_bytes_written < data_count) {
 311     mach_msg_type_number_t curr_data_count =
 312         static_cast<mach_msg_type_number_t>(MaxBytesLeftInPage(
 313             task, curr_addr, data_count - total_bytes_written));
 314     m_err =
 315         ::mach_vm_write(task, curr_addr, (pointer_t)curr_data, curr_data_count);
 316     if (DNBLogCheckLogBit(LOG_MEMORY) || m_err.Fail())
 317       m_err.LogThreaded("::mach_vm_write ( task = 0x%4.4x, addr = 0x%8.8llx, "
 318                         "data = %8.8p, dataCnt = %u )",
 319                         task, (uint64_t)curr_addr, curr_data, curr_data_count);
 320
 321 #if !defined(__i386__) && !defined(__x86_64__)
 322     vm_machine_attribute_val_t mattr_value = MATTR_VAL_CACHE_FLUSH;
 323
 324     m_err = ::vm_machine_attribute(task, curr_addr, curr_data_count,
 325                                    MATTR_CACHE, &mattr_value);
 326     if (DNBLogCheckLogBit(LOG_MEMORY) || m_err.Fail())
 327       m_err.LogThreaded("::vm_machine_attribute ( task = 0x%4.4x, addr = "
 328                         "0x%8.8llx, size = %u, attr = MATTR_CACHE, mattr_value "
 329                         "=> MATTR_VAL_CACHE_FLUSH )",
 330                         task, (uint64_t)curr_addr, curr_data_count);
 331 #endif
 332
 333     if (m_err.Success()) {
 334       total_bytes_written += curr_data_count;
 335       curr_addr += curr_data_count;
 336       curr_data += curr_data_count;
 337     } else {
 338       break;
 339     }
 340   }
 341   return total_bytes_written;
 342 }