[go: up one dir, main page]

region 0.3.0

A library for manipulating memory regions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

extern crate mach;

use self::mach::vm_prot::*;

use Protection;
use Region;
use error::*;

fn prot_from_native(protection: vm_prot_t) -> Protection {
  let mut result = Protection::None;

  if (protection & VM_PROT_READ) == VM_PROT_READ {
    result |= Protection::Read;
  }

  if (protection & VM_PROT_WRITE) == VM_PROT_WRITE {
    result |= Protection::Write;
  }

  if (protection & VM_PROT_EXECUTE) == VM_PROT_EXECUTE {
    result |= Protection::Execute;
  }

  result
}

pub fn get_region(base: *const u8) -> Result<Region> {
  extern crate mach;

  // Defines the different share modes available
  const SHARE_MODES: [u8; 3] = [
    mach::vm_region::SM_SHARED,
    mach::vm_region::SM_TRUESHARED,
    mach::vm_region::SM_SHARED_ALIASED,
  ];

  // The address is aligned to the enclosing region
  let mut region_base = base as mach::vm_types::mach_vm_address_t;
  let mut region_size: mach::vm_types::mach_vm_size_t = 0;
  let mut info: mach::vm_region::vm_region_extended_info = unsafe { ::std::mem::zeroed() };

  let result = unsafe {
    // This information is of no interest
    let mut object_name: mach::port::mach_port_t = 0;

    // Query the OS about the memory region
    mach::vm::mach_vm_region(
      mach::traps::mach_task_self(),
      &mut region_base,
      &mut region_size,
      mach::vm_region::VM_REGION_EXTENDED_INFO,
      (&mut info as *mut _) as mach::vm_region::vm_region_info_t,
      &mut mach::vm_region::vm_region_extended_info::count(),
      &mut object_name,
    )
  };

  match result {
    mach::kern_return::KERN_SUCCESS => {
      // `mach_vm_region` begins searching at the specified address, so if
      // there is not a region allocated, it will return the closest one
      // instead. In that case, the memory is not committed.
      if region_base > base as mach::vm_types::mach_vm_address_t {
        Err(Error::Free)
      } else {
        Ok(Region {
          base: region_base as *const _,
          guarded: (info.user_tag == mach::vm_statistics::VM_MEMORY_GUARD),
          protection: prot_from_native(info.protection),
          shared: SHARE_MODES.contains(&info.share_mode),
          size: region_size as usize,
        })
      }
    },
    _ => Err(Error::MachRegion(result)),
  }
}