NAME

Mmap::Native - interface to posix mmap() and mmunmap() calls

SYNOPSIS

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"'/;

DESCRIPTION

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.

CONSTANTS

Remember to always use +| to combine flag values!

The `$prot` argument flags

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

The `$flags` argument

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

FUNCTIONS

sub mmap

sub mmap(
    NativeCall::Types::Pointer $addr is rw,
    uint64 $len,
    int64 $prot,
    int64 $flags,
    int64 $fd,
    int64 $offset
) returns NativeCall::Types::Pointer

Creates 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

sub munmap(
    NativeCall::Types::Pointer $addr is rw,
    uint64 $len
) returns uint64

Deletes 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.

AUTHOR

Humberto Massa humbertomassa@gmail.com

COPYRIGHT AND LICENSE

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.