Mmap::Native - interface to posix mmap() and mmunmap() calls
use Mmap::Native;
my $f = $*CWD.add('META6.json'); $f = $f.open;
my $d = mmap Pointer, 50, PROT_READ, MAP_SHARED, $f.native-descriptor, 0;
my $e = blob-from-pointer $d, :50elems, :type(Buf[uint8]);
is $e.decode('utf8'), /'"auth": "zef:massa"'/;Mmap::Native is a raw interface to the C library mmap and munmap calls.
It's mostly used for mmaping Blob objects and other raw C pointers. It's recommended that the library using it present a most Raku-esque interface and hide the mmapping altogether. This is just a low level library.
Remember to always use +| to combine flag values!
Describes the desired memory protection of the mapping (and must not conflict with the open mode of the file). It is either PROT_NONE or the bitwise OR of one or more of the following flags:
| Flag | Description |
|---|---|
| PROT_READ | page can be read |
| PROT_WRITE | page can be written |
| PROT_EXEC | page can be executed |
| PROT_SEM | page may be used for atomic ops |
| PROT_NONE | page can not be accessed |
| PROT_GROWSDOWN | mprotect flag: extend change to start of growsdown vma |
| PROT_GROWSUP | mprotect flag: extend change to end of growsup vma |
Determines whether updates to the mapping are visible to other processes mapping the same region, and whether updates are carried through to the underlying file. This behavior is determined by including exactly one of the following values:
| Flag | Description |
|---|---|
| MAP_SHARED | Share changes |
| MAP_PRIVATE | Changes are private |
| MAP_SHARED_VALIDATE | share and validate extension flags |
| MAP_TYPE | Mask for type of mapping |
| MAP_FIXED | Interpret addr exactly |
| MAP_ANONYMOUS | don't use a file |
| MAP_GROWSDOWN | stack-like segment |
| MAP_DENYWRITE | ETXTBSY |
| MAP_EXECUTABLE | mark it as an executable |
| MAP_LOCKED | pages are locked |
| MAP_NORESERVE | don't check for reservations |
| MAP_POPULATE | populate (prefault) pagetables |
| MAP_NONBLOCK | do not block on IO |
| MAP_STACK | give out an address that is best suited for process/thread stacks |
| MAP_HUGETLB | create a huge page mapping |
| MAP_SYNC | perform synchronous page faults for the mapping |
| MAP_FIXED_NOREPLACE | MAP_FIXED which doesn't unmap underlying mapping |
| MAP_UNINITIALIZED | For anonymous mmap, memory could be * uninitialized |
| MLOCK_ONFAULT | Lock pages in range after they are faulted in, do not prefault |
| MS_ASYNC | sync memory asynchronously |
| MS_INVALIDATE | invalidate the caches |
| MS_SYNC | synchronous memory sync |
| MADV_NORMAL | no further special treatment |
| MADV_RANDOM | expect random page references |
| MADV_SEQUENTIAL | expect sequential page references |
| MADV_WILLNEED | will need these pages |
| MADV_DONTNEED | don't need these pages |
| MADV_FREE | free pages only if memory pressure |
| MADV_REMOVE | remove these pages & resources |
| MADV_DONTFORK | don't inherit across fork |
| MADV_DOFORK | do inherit across fork |
| MADV_HWPOISON | poison a page for testing |
| MADV_SOFT_OFFLINE | soft offline page for testing |
| MADV_MERGEABLE | KSM may merge identical pages |
| MADV_UNMERGEABLE | KSM may not merge identical pages |
| MADV_HUGEPAGE | Worth backing with hugepages |
| MADV_NOHUGEPAGE | Not worth backing with hugepages |
| MADV_DONTDUMP | Explicity exclude from the core dump, overrides the coredump filter bits |
| MADV_DODUMP | Clear the MADV_DONTDUMP flag |
| MADV_WIPEONFORK | Zero memory on fork, child only |
| MADV_KEEPONFORK | Undo MADV_WIPEONFORK |
| MADV_COLD | deactivate these pages |
| MADV_PAGEOUT | reclaim these pages |
| MADV_POPULATE_READ | populate (prefault) page tables readable |
| MADV_POPULATE_WRITE | populate (prefault) page tables writable |
| MADV_DONTNEED_LOCKED | like DONTNEED, but drop locked pages too |
| MADV_COLLAPSE | Synchronous hugepage collapse |
sub mmap(
NativeCall::Types::Pointer $addr is rw,
uint64 $len,
int64 $prot,
int64 $flags,
int64 $fd,
int64 $offset
) returns NativeCall::Types::PointerCreates a new mapping in the virtual address space of the calling process. The starting address for the new mapping is specified in $addr. The $length argument specifies the length of the mapping (which must be greater than 0). If $addr is undefined, then the kernel chooses the (page-aligned) address at which to create the mapping; this is the most portable method of creating a new mapping. If $addr is defined, then the kernel takes it as a hint about where to place the mapping; on Linux, the kernel will pick a nearby page boundary and attempt to create the mapping there. If another mapping already exists there, the kernel picks a new address that may or may not depend on the hint. The address of the new mapping is returned as the result of the call. The contents of a file mapping are initialized using length bytes starting at offset $offset in the file (or other object) referred to by the file descriptor $fd. $offset must be a multiple of the page size. After the mmap() call has returned, the file descriptor, $fd, can be closed immediately without invalidating the mapping. The $prot argument describes the desired memory protection of the mapping (and must not conflict with the open mode of the file).
sub munmap(
NativeCall::Types::Pointer $addr is rw,
uint64 $len
) returns uint64Deletes the mappings for the specified address range, and causes further references to addresses within the range to generate invalid memory references. The region is also automatically unmapped when the process is terminated. On the other hand, closing the file descriptor does not unmap the region. The address $addr must be a multiple of the page size (but $length need not be). All pages containing a part of the indicated range are unmapped, and subsequent references to these pages will generate SIGSEGV. It is not an error if the indicated range does not contain any mapped pages.
Humberto Massa humbertomassa@gmail.com
Copyright 2024 Humberto Massa
This library is free software; you can redistribute it and/or modify it under either the Artistic License 2.0 or the LGPL v3.0, at your convenience.