shmget(2)							System Calls Manual							 shmget(2)

NAME

       shmget() - get shared memory segment

SYNOPSIS

DESCRIPTION

       returns the shared memory identifier associated with key.

       A shared memory identifier and associated data structure and shared memory segment of size size bytes (see glossary(9)) are created for key
       if one of the following is true:

	      o  key is equal to This call creates a new identifier, subject to available resources.  The identifier will  never  be  returned	by
		 another  call	to until it has been released by a call to The identifier should be used among the calling process and its descen-
		 dents; however, it is not a requirement.  The resource can be accessed by any process having the proper permissions.

	      o  key does not already have a shared memory identifier associated with it, and (shmflg & is "true".  If is set in shmflg the shared
		 memory segment created can only be shared by processes of the same executable type.  That is, an application compiled as a 32-bit
		 process will be able to share the same memory segment with other 32-bit processes,  and  an  application  compiled  as  a  64-bit
		 process  will	be  able  to  share the same memory segment with other 64-bit processes.  If a 64-bit bit process want to create a
		 shared memory segment which can also be shared with 32-bit processes, the 64-bit process must specify in addition to  in  shmflg.
		 The  32-bit  process does not need to specify On Itanium(R)-based platforms, if the Adaptive Address Space feature is being used,
		 then additional rules may apply.  See the section below on Adaptive Address Space.

       Upon creation, the data structure associated with the new shared memory identifier is initialized as follows:

	      o  and are set equal to the effective user ID and effective group ID, respectively, of the calling process.

	      o  the low-order 9 bits of are set equal to the low-order 9 bits of shmflg.  is set equal to the value of size.

	      o  and are set equal to 0.

	      o  is set equal to the current time.

       Specifying in a call to along with forces the shared memory segment to be allocated from the global quadrant and not from the  local  quad-
       rants.  If this is not possible, will fail.  Refer to setmemwindow(1M) for more information.

       Specifying  in  a  call	to along with can improve the performance of co-operating processes in cases where these processes are accessing a
       large number of shared memory segments.	This flag is treated as a hint.

       The flags and involve the placement of physical memory.	This is important only on Cache Coherent Non-Uniform Memory Architecture  (ccNUMA)
       systems.   They	will have no effect otherwise.	For more information regarding ccNUMA and locality domains, see mpctl(2).  These flags are
       hints to the system.  If memory of the desired type is not available, the next most suitable memory is returned instead.

       If is set in shmflg, physical memory will come from interleaved memory.	Interleaved memory is a hardware construct which combines the mem-
       ory  from  several  locality domains into one region of memory.	This memory is striped together with a very fine granularity.  Interleaved
       memory is a good place to put shared objects, the kernel, and objects that could be accessed from any part of  the  system.   This  is  the
       default behavior for shared memory segments created with this call.

       If  is  set in shmflg, physical memory for this mapping will always be allocated from the locality domain where the call to was made.  Note
       that this flag implicitly uses the current locality domain, so the caller should be aware of locality domain configurations  and  bindings.
       See mpctl(2).

       If is set in shmflg, physical memory will come from the locality domain of the first processor to read or write that memory.  If the shared
       memory is paged out and then back in again, physical memory will come from the locality domain of the processor bringing in that memory.

   System V Shared Memory Under Adaptive Address Space
       Itanium-based platforms have the capability to create two types of processes: MGAS (Mostly Global Address Space), which is the default, and
       MPAS (Mostly Private Address Space).  See ld(1) and chatr(1).

       If  64-bit  MPAS  and 64-bit MGAS processes want to share a mapping among themselves without incurring the cost of aliasing, then (shmflg &
       should be "true", but (shmflg & should be "false".  64-bit MPAS processes should also specify the flag to the shmat(2) call.  Such  a  map-
       ping cannot be shared with 32-bit MGAS processes.

       See the for details.

EXAMPLES

       The following call to returns a unique shmid for the newly created shared memory segment of 4096 bytes:

RETURN VALUE

       Upon  successful  completion, a non-negative integer, namely a shared memory identifier, is returned.  Otherwise, a value of -1 is returned
       and is set to indicate the error.

ERRORS

       fails if any of the following conditions are encountered:

	      size	     is less than the system-imposed minimum or greater than the system-imposed maximum.

	      A shared memory identifier exists for
			     key but is in 64-bit address space and the process performing the request has been compiled as a  32-bit  executable.
			     In order to avoid receiving this error, both and must be set in shmflg by the 64-bit processes upon segment creation.

	      A shared memory identifier exists for
			     key but operation permission (see glossary(9)) as specified by the low-order 9 bits of shmflg would not be granted.

	      A shared memory identifier exists for
			     key but the size of the segment associated with it is less than size and size is not equal to zero.

	      A shared memory identifier does not exist for
			     key and (shmflg & is "false".

	      A shared memory identifier is to be created but
			     the system-imposed limit on the maximum number of allowed shared memory identifiers system wide would be exceeded.

	      A shared memory identifier and associated shared memory segment
			     are to be created, but the amount of available physical memory is not sufficient to fill the request.

	      A shared memory segment with
			     or specified was to be created; however, there is not enough space in the global quadrant.

	      A shared memory identifier exists for
			     key but ((shmflg & && (shmflg & is "true".

SEE ALSO

       chatr(1), ld(1), ipcrm(1), ipcs(1), mpctl(2), shmctl(2), shmop(2), ftok(3C), privileges(5).

       in

STANDARDS CONFORMANCE

																	 shmget(2)