path: root/static/netbsd/man2/mremap.2

.\"	$NetBSD: mremap.2,v 1.10 2023/10/25 18:23:10 riastradh Exp $
.\"
.\" Copyright (c) 2007 Thomas Klausner and Joerg Sonnenberger
.\" All rights reserved.
.\"
.\" Redistribution and use in source and binary forms, with or without
.\" modification, are permitted provided that the following conditions
.\" are met:
.\" 1. Redistributions of source code must retain the above copyright
.\"    notice, this list of conditions and the following disclaimer.
.\" 2. Redistributions in binary form must reproduce the above copyright
.\"    notice, this list of conditions and the following disclaimer in the
.\"    documentation and/or other materials provided with the distribution.
.\"
.\" THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND
.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE
.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
.\" SUCH DAMAGE.
.\"
.\" ------------------------------------------------------------
.Dd May 2, 2018
.Dt MREMAP 2
.Os
.Sh NAME
.Nm mremap
.Nd re-map a virtual memory address
.\" ------------------------------------------------------------
.Sh LIBRARY
.Lb libc
.Sh SYNOPSIS
.In sys/mman.h
.Ft void *
.Fn mremap "void *oldp" "size_t oldsize" "void *newp" "size_t newsize" \
"int flags"
.\" ------------------------------------------------------------
.Sh DESCRIPTION
The
.Fn mremap
function resizes the mapped range (see
.Xr mmap 2 )
starting at
.Ar oldp
and having size
.Ar oldsize
to
.Ar newsize .
The following arguments can be
.Dv OR Ap ed
together in the
.Ar flags
argument:
.Bl -tag -width XXMAPXALIGNEDXnXX
.It Dv MAP_ALIGNED Ns Pq Ar n
The allocation should be aligned to the given boundary, i.e. ensure
that the lowest
.Ar n
bits of the address are zero.
The parameter
.Ar n
should be the base 2 logarithm of the desired alignment (e.g., to
request alignment to 16K, use 14 as the value for n).
The alignment must be equal to or greater than the platform's page
size as returned by
.Xr sysconf 3
with the
.Dv _SC_PAGESIZE
request.
.It Dv MAP_FIXED
.Ar newp
is tried and
.Fn mremap
fails if that address can't be used as new base address for the range.
Otherwise,
.Ar oldp
and
.Ar newp
are used as hints for the position, factoring in the given alignment.
.It Dv MAP_REMAPDUP
Duplicate the mapping.
Both address ranges reference the same pages, but can have different protection flags.
.El
.Sh RETURN VALUES
.Fn mremap
returns the new address or
.Dv MAP_FAILED ,
if the remap failed.
.Sh EXAMPLES
The following example program creates a two mappings for the same
memory range, one RW- and one R-X.
.Bd -literal
#include <sys/types.h>
#include <sys/mman.h>

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <err.h>

static int
return_1(void)
{
	return 1;
}

static void
return_1_end(void)
{
}

static int
return_2(void)
{
	return 2;
}

static void
return_2_end(void)
{
}

int
main(int argc, char *argv[])
{
        void *maprw, *maprx;
	int rv;
	size_t page = (size_t)sysconf(_SC_PAGESIZE);

	// Create the first mapping that has no protections, but intended
	// protections only
	maprw = mmap(NULL, page,
	    PROT_MPROTECT(PROT_EXEC|PROT_WRITE|PROT_READ),
            MAP_ANON|MAP_PRIVATE, -1, 0);
	if (maprw == MAP_FAILED)
		err(EXIT_FAILURE, "mmap failed");

        // Create the second mapping for the same physical space, which
	// again has no protections.
	maprx = mremap(maprw, page, NULL, page, MAP_REMAPDUP);
	if (maprx == MAP_FAILED)
		err(EXIT_FAILURE, "mremap failed");

	// Set the first mapping read/write
        if (mprotect(maprw, page, PROT_READ|PROT_WRITE) == -1)
		err(EXIT_FAILURE, "mprotect(rw) failed");

	// Set the second mapping read/execute
        if (mprotect(maprx, page, PROT_READ|PROT_EXEC) == -1)
		err(EXIT_FAILURE, "mprotect(rx) failed");

#define XS(a) (size_t)((uintptr_t)(a ## _end) - (uintptr_t)(a))

	// Copy and run the first function
	memcpy(maprw, return_1, XS(return_1));
	__builtin___clear_cache(maprw, (void *)((uintptr_t)maprw + page));
	rv = ((int (*)(void))maprx)();
	printf("%d\en", rv);

	// Copy and run the second function
	memcpy(maprw, return_2, XS(return_2));
	__builtin___clear_cache(maprw, (void *)((uintptr_t)maprw + page));
	rv = ((int (*)(void))maprx)();
	printf("%d\en", rv);

	return EXIT_SUCCESS;
}
.Ed
.Sh COMPATIBILITY
The semantics of
.Fn mremap
differ from the one provided by glibc on Linux in that the
.Ar newp
argument was added and a different set of
.Ar flags
are implemented.
.Sh ERRORS
The
.Fn mremap
function fails if:
.Bl -tag -width Er
.It Bq Er E2BIG
A request to extend
.Fa oldp
failed because of address overflow.
.It Bq Er EINVAL
If
.Fa oldp
or
.Fa newp
are not page aligned, or
.Fa oldsize
or
.Fa newsize
are not a multiple of the page size, or if
.Fa oldp +
.Fa oldsize
or
.Fa newp +
.Fa newsize
wrap around, or if an invalid alignment was requested in the
.Fa flags
argument, or if the request was to extend
.Fa oldp
and the extension address space either did not fit, was already occupied,
or had set permissions.
.It Bq Er ENOENT
If the
.Fa oldp
segmented was not already mapped.
.It Bq Er ENOMEM
If there was either no space to allocate/move memory,
or if a fixed allocation was requested in the
.Fa flags
that could not be accommodated.
.El
.Sh SEE ALSO
.Xr mmap 2 ,
.Xr munmap 2
.Sh HISTORY
The
.Fn mremap
system call appeared in
.Nx 5.0 .
It was based on the code that supports
.Fn mremap
compatibility for Linux binaries.
.Sh BUGS
If a mapping is created by
.Xr mmap 2
with
.Dv MAP_PRIVATE
and then duplicated by
.Nm
with
.Dv MAP_REMAPDUP ,
calling
.Xr fork 2
destroys the coupling between the original and duplicate mapping.
Workarounds:
.Bl -dash
.It
Create the original mapping with
.Dv MAP_SHARED .
.It
Use
.Xr minherit 2
with
.Dv MAP_INHERIT_NONE
on the writable mapping.
.It
Don't use
.Xr fork 2 ;
use
.Xr posix_spawn 2 .
.El
.Pp
See
.Lk https://gnats.NetBSD.org/55177 "PR lib/55177"
for details.