magic-buffer 0.1.1

a virtual ring buffer implementation that magically wraps around itself
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

// This implementation is based on
// https://github.com/gnzlbg/slice_deque/blob/master/src/mirrored/macos.rs

use crate::MagicBufferError;

use mach2::{
    boolean::boolean_t,
    kern_return::KERN_SUCCESS,
    mach_types::mem_entry_name_port_t,
    memory_object_types::memory_object_size_t,
    traps::mach_task_self,
    vm::{mach_make_memory_entry_64, mach_vm_allocate, mach_vm_deallocate, mach_vm_remap},
    vm_inherit::VM_INHERIT_NONE,
    vm_page_size::vm_page_size,
    vm_prot::{vm_prot_t, VM_PROT_READ, VM_PROT_WRITE},
    vm_statistics::{VM_FLAGS_ANYWHERE, VM_FLAGS_FIXED, VM_FLAGS_OVERWRITE},
    vm_types::mach_vm_address_t,
};

use std::mem::MaybeUninit;

pub(super) unsafe fn magic_buf_min_len() -> usize {
    vm_page_size
}

pub(super) unsafe fn magic_buf_alloc(len: usize) -> Result<*mut u8, MagicBufferError> {
    let task = mach_task_self();

    let mut addr: mach_vm_address_t = 0;
    let result = mach_vm_allocate(task, &mut addr as _, (len * 2) as u64, VM_FLAGS_ANYWHERE);

    if result != KERN_SUCCESS {
        return Err(MagicBufferError::OOM);
    }

    let result = mach_vm_allocate(
        task,
        &mut addr as _,
        len as u64,
        VM_FLAGS_FIXED | VM_FLAGS_OVERWRITE,
    );

    if result != KERN_SUCCESS {
        return Err(MagicBufferError::OOM);
    }

    let mut memory_object_size = len as memory_object_size_t;
    let mut object_handle = MaybeUninit::<mem_entry_name_port_t>::uninit();
    let result = mach_make_memory_entry_64(
        task,
        &mut memory_object_size as _,
        addr as _,
        VM_PROT_READ | VM_PROT_WRITE,
        object_handle.as_mut_ptr(),
        0,
    );

    if result != KERN_SUCCESS {
        let result = mach_vm_deallocate(task, addr, (len * 2) as u64);
        assert_eq!(result, KERN_SUCCESS);
        return Err(MagicBufferError::OOM);
    }

    let mut to = (addr as *mut u8).add(len) as mach_vm_address_t;
    let mut current_prot = MaybeUninit::<vm_prot_t>::uninit();
    let mut out_prot = MaybeUninit::<vm_prot_t>::uninit();
    let result = mach_vm_remap(
        task,
        &mut to as _,
        len as u64,
        0,
        VM_FLAGS_FIXED | VM_FLAGS_OVERWRITE,
        task,
        addr,
        0 as boolean_t,
        current_prot.as_mut_ptr(),
        out_prot.as_mut_ptr(),
        VM_INHERIT_NONE,
    );

    if result != KERN_SUCCESS {
        let result = mach_vm_deallocate(task, addr, (len * 2) as u64);
        assert_eq!(result, KERN_SUCCESS);
        return Err(MagicBufferError::OOM);
    }

    Ok(addr as _)
}

pub(super) unsafe fn magic_buf_free(addr: *mut u8, len: usize) {
    let result = mach_vm_deallocate(mach_task_self(), addr as _, (len * 2) as u64);
    assert_eq!(result, KERN_SUCCESS, "de-allocation failed");
}