trusty (3) posix_typed_mem_open.3posix.gz

Provided by: manpages-posix-dev_2.16-1_all bug

NAME
       posix_typed_mem_open - open a typed memory object (ADVANCED REALTIME)


SYNOPSIS
       #include <sys/mman.h>

       int posix_typed_mem_open(const char *name, int oflag, int tflag);


DESCRIPTION
       The  posix_typed_mem_open()  function  shall  establish  a  connection  between  the  typed memory object
       specified by the string pointed to by  name  and  a  file  descriptor.  It  shall  create  an  open  file
       description  that  refers  to the typed memory object and a file descriptor that refers to that open file
       description. The file descriptor is used by other functions to refer to that typed memory object.  It  is
       unspecified  whether  the  name  appears  in  the file system and is visible to other functions that take
       pathnames as arguments. The name argument shall conform to the construction rules for a pathname. If name
       begins  with  the  slash  character, then processes calling posix_typed_mem_open() with the same value of
       name shall refer to the same typed memory object. If name does not begin with the  slash  character,  the
       effect  is  implementation-defined.  The  interpretation of slash characters other than the leading slash
       character in name is implementation-defined.

       Each typed memory object supported in a system shall be identified by a name which specifies not only its
       associated  typed memory pool, but also the path or port by which it is accessed. That is, the same typed
       memory pool accessed via several different ports shall have several different  corresponding  names.  The
       binding between names and typed memory objects is established in an implementation-defined manner. Unlike
       shared memory objects, there is no way within IEEE Std 1003.1-2001 for a program to create a typed memory
       object.

       The  value of tflag shall determine how the typed memory object behaves when subsequently mapped by calls
       to mmap(). At most, one of the following flags defined in <sys/mman.h> may be specified:

       POSIX_TYPED_MEM_ALLOCATE
              Allocate on mmap().

       POSIX_TYPED_MEM_ALLOCATE_CONTIG
              Allocate contiguously on mmap().

       POSIX_TYPED_MEM_MAP_ALLOCATABLE
              Map on mmap(), without affecting allocatability.

       If tflag has the flag POSIX_TYPED_MEM_ALLOCATE  specified,  any  subsequent  call  to  mmap()  using  the
       returned  file descriptor shall result in allocation and mapping of typed memory from the specified typed
       memory pool. The allocated memory may be a contiguous previously unallocated area  of  the  typed  memory
       pool  or  several  non-contiguous  previously  unallocated  areas  (mapped to a contiguous portion of the
       process address space).  If tflag has the flag POSIX_TYPED_MEM_ALLOCATE_CONTIG specified, any  subsequent
       call  to  mmap()  using  the  returned file descriptor shall result in allocation and mapping of a single
       contiguous previously unallocated area of the typed memory pool (also mapped to a contiguous  portion  of
       the   process   address   space).    If   tflag   has  none  of  the  flags  POSIX_TYPED_MEM_ALLOCATE  or
       POSIX_TYPED_MEM_ALLOCATE_CONTIG specified,  any  subsequent  call  to  mmap()  using  the  returned  file
       descriptor  shall  map  an  application-chosen  area  from the specified typed memory pool such that this
       mapped area becomes unavailable for allocation until unmapped by all processes. If  tflag  has  the  flag
       POSIX_TYPED_MEM_MAP_ALLOCATABLE  specified,  any  subsequent  call  to  mmap()  using  the  returned file
       descriptor shall map an application-chosen area from the specified typed memory pool without an effect on
       the  availability  of  that  area for allocation; that is, mapping such an object leaves each byte of the
       mapped area unallocated if it was unallocated prior to the mapping or allocated if it was allocated prior
       to  the  mapping.  The  appropriate  privilege  to  specify  the  POSIX_TYPED_MEM_MAP_ALLOCATABLE flag is
       implementation-defined.

       If successful, posix_typed_mem_open() shall return a file descriptor for the typed memory object that  is
       the  lowest  numbered  file  descriptor not currently open for that process. The open file description is
       new, and therefore the file descriptor shall not share it with any other  processes.  It  is  unspecified
       whether  the  file  offset  is  set.  The  FD_CLOEXEC  file  descriptor flag associated with the new file
       descriptor shall be cleared.

       The behavior of msync(), ftruncate(), and all file  operations  other  than  mmap(),  posix_mem_offset(),
       posix_typed_mem_get_info(),  fstat(),  dup(),  dup2(),  and  close(),  is  unspecified when passed a file
       descriptor connected to a typed memory object by this function.

       The file status flags of the open file description  shall  be  set  according  to  the  value  of  oflag.
       Applications shall specify exactly one of the three access mode values described below and defined in the
       <fcntl.h> header, as the value of oflag.

       O_RDONLY
              Open for read access only.

       O_WRONLY
              Open for write access only.

       O_RDWR Open for read or write access.


RETURN VALUE
       Upon successful completion, the posix_typed_mem_open()  function  shall  return  a  non-negative  integer
       representing  the  lowest numbered unused file descriptor. Otherwise, it shall return -1 and set errno to
       indicate the error.


ERRORS
       The posix_typed_mem_open() function shall fail if:

       EACCES The typed memory object exists and the permissions specified by oflag are denied.

       EINTR  The posix_typed_mem_open() operation was interrupted by a signal.

       EINVAL The  flags  specified  in  tflag  are  invalid  (more  than   one   of   POSIX_TYPED_MEM_ALLOCATE,
              POSIX_TYPED_MEM_ALLOCATE_CONTIG, or POSIX_TYPED_MEM_MAP_ALLOCATABLE is specified).

       EMFILE Too many file descriptors are currently in use by this process.

       ENAMETOOLONG
              The  length  of  the  name  argument  exceeds  {PATH_MAX}  or  a pathname component is longer than
              {NAME_MAX}.

       ENFILE Too many file descriptors are currently open in the system.

       ENOENT The named typed memory object does not exist.

       EPERM  The caller lacks the appropriate privilege to specify the flag POSIX_TYPED_MEM_MAP_ALLOCATABLE  in
              argument tflag.

       The following sections are informative.


EXAMPLES
       None.


APPLICATION USAGE
       None.


RATIONALE
       None.


FUTURE DIRECTIONS
       None.


SEE ALSO
       close()  ,  dup()  ,  exec()  , fcntl() , fstat() , ftruncate() , mmap() , msync() , posix_mem_offset() ,
       posix_typed_mem_get_info() , umask() , the Base Definitions volume  of  IEEE Std 1003.1-2001,  <fcntl.h>,
       <sys/mman.h>


       Portions of this text are reprinted and reproduced in electronic form from IEEE Std 1003.1, 2003 Edition,
       Standard for Information Technology -- Portable Operating System Interface (POSIX), The Open  Group  Base
       Specifications Issue 6, Copyright (C) 2001-2003 by the Institute of Electrical and Electronics Engineers,
       Inc and The Open Group. In the event of any discrepancy between this version and the  original  IEEE  and
       The  Open  Group  Standard,  the  original  IEEE and The Open Group Standard is the referee document. The
       original Standard can be obtained online at http://www.opengroup.org/unix/online.html .