munmap

NAME

       mmap, munmap - map or unmap files or devices into memory

SYNOPSIS

       #include <sys/types.h>
       #include <sys/mman.h>

       caddr_t  mmap(caddr_t  addr,  size_t  len,  int prot , int
       flags, int fd, off_t offset );
       int munmap(caddr_t addr, size_t len);

DESCRIPTION

       WARNING: This is a BSD man page.  Linux 0.99.11 can't  map
       files, and can't do other things documented here.

       The  mmap  function  causes the pages starting at addr and
       continuing for at most len bytes to  be  mapped  from  the
       object  described  by  fd, starting at byte offset offset.
       If offset or len is not a multiple of  the  pagesize,  the
       mapped region may extend past the specified range.

       If  addr  is non-zero, it is used as a hint to the system.
       (As a convenience to the system, the actual address of the
       region  may differ from the address supplied.)  If addr is
       zero, an address will be  selected  by  the  system.   The
       actual starting address of the region is returned.  A suc-
       cessful mmap deletes any previous mapping in the allocated
       address range.

       The  protections  (region  accessibility) are specified in
       the prot argument by or'ing the following values:

       PROT_EXEC
               Pages may be executed.

       PROT_READ
               Pages may be read.

       PROT_WRITE
               Pages may be written.

               The flags parameter  specifies  the  type  of  the
               mapped object, mapping options and whether modifi-
               cations made to the mapped copy of  the  page  are
               private  to  the  process or are to be shared with
               other  references.   Sharing,  mapping  type   and
               options  are  specified  in  the flags argument by
               or;ing the following values:

       MAP_ANON
               Map anonymous memory not associated with any  spe-
               cific file.  The file descriptor used for creating
               MAP_ANON regions is used only for naming, and  may
               be  specified  as -1 if no name is associated with
               the region.

       MAP_FILE
               Mapped from a regular  file  or  character-special
               device memory.

       MAP_FIXED
               Do  not  permit  the  system to select a different
               address than the one specified.  If the  specified
               address  cannot  be  used,  mmap  will  fail.   If
               MAP_FIXED is specified, addr must be a multiple of
               the  pagesize.  Use of this option is discouraged.

       MAP_HASSEMAPHORE
               Notify the kernel  that  the  region  may  contain
               semaphores and that special handling may be neces-
               sary.

       MAP_INHERIT
               Permit regions to be inherited across exec(2) sys-
               tem calls.

       MAP_PRIVATE
               Modifications are private.

       MAP_SHARED
               Modifications are shared.

               The  munmap  system  call deletes the mappings for
               the specified address range,  and  causes  further
               references to addresses within the range to gener-
               ate invalid memory references.

               The current design does not  allow  a  process  to
               specify the location of swap space.  In the future
               we  may  define  an   additional   mapping   type,
               MAP_SWAP,  in  which  the file descriptor argument
               specifies a  file  or  device  to  which  swapping
               should be done.

RETURN VALUES

       Upon  successful completion, mmap returns a pointer to the
       mapped region.  Otherwise, a value of -1 is  returned  and
       errno is set to indicate the error.

ERRORS

       For mmap:

       EACCES  The  flag  PROT_READ  was specified as part of the
               prot parameter and fd was not  open  for  reading.
               The  flags  PROT_WRITE,  MAP_SHARED  and MAP_WRITE
               were specified as  part  of  the  flags  and  prot
               parameters and fd was not open for writing.

       EBADF   Fd is not a valid open file descriptor.

       EINVAL  One  of  MAP_ANON or MAP_FILE was not specified as
               part of the flags parameter.  MAP_FIXED was speci-
               fied  and the addr parameter was not page aligned.
               did not reference a regular or  character  special
               file.

       ENOMEM  MAP_FIXED  was  specified  and  the addr parameter
               wasn't  available.   MAP_ANON  was  specified   an
               insufficient memory was available.

BUGS

       This  is  a  BSD  man page.  Many of the details explained
       here are not implemented under Linux.  Please consult  the
       Linux  kernel source code for complete details on the cur-
       rent implementation of the mmap function.

SEE ALSO

       getpagesize(2), phys(2)