我的书签
添加书签
移除书签MEM
Since:
1.0
Version:
1.0
Summary
Files
Data Structures
Describes limitations and attributes of system-level shared memory. |
|
Describes system resource information about the shared memory. |
Macros
Indicates the return value of functions such as mmap() when the operation fails. |
|
Indicates the mapping attribute that the updates to the mapping are visible to other processes mapping the same file and are carried through to the underlying file. This macro is used as an input parameter passed to functions such as . |
|
Indicates the mapping attribute that the updates to the mapping are not visible to other mapping processes and are not carried through to the underlying file. This macro is used as an input parameter passed to functions such as mmap(). |
|
Indicates the mapping attribute that specifies the mapping as fixed mapping. This macro is used as an input parameter passed to functions such as . |
|
Indicates the mapping attribute that specifies the mapping as anonymous mapping without a specified file or device. This macro is used as an input parameter passed to functions such as mmap(). |
|
Indicates the mapping attribute that specifies the mapping as anonymous mapping without a specified file or device. This macro is the synonym for MAP_ANON and is used as an input parameter passed to functions such as . |
|
Indicates that no permission is granted to the current process for accessing the mapping area. This macro is used as an input parameter passed to functions such as mmap(). |
|
Indicates that the current process is granted the read permission on the mapping area. This macro is used as an input parameter passed to functions such as . |
|
Indicates that the current process is granted the write permission on the mapping area. This macro is used as an input parameter passed to functions such as mmap(). |
|
Indicates that the current process is granted the execute permission on the mapping area. This macro is used as an input parameter passed to functions such as . |
|
Indicates the remapping attribute that allows the mapping to be relocated to a new address. This macro is used as an input parameter passed to functions such as mremap(). |
|
Indicates the remapping attribute that specifies the mapping as fixed mapping. This macro is used as an input parameter passed to functions such as . |
|
Indicates that the shared memory segment is readable. This macro is used for setting the shmflg parameter passed to functions such as shmget(). |
|
Indicates that the shared memory segment is writable. This macro is used for setting the shmflg parameter passed to functions such as . |
|
Indicates that the attached shared memory segment is read-only. This macro is used for setting the shmflg parameter passed to functions such as shmat(). |
|
Indicates that the shared memory address can be rounded to a value meeting the requirement (). This macro is used for setting the shmflg parameter passed to functions such as shmat(). |
|
Indicates that the memory segment can be remapped. This macro is used for setting the shmflg parameter passed to functions such as . |
|
Indicates that the attached shared memory segment is executable. This macro is used for setting the shmflg parameter passed to functions such as shmat(). |
|
Locks the shared memory segment in memory so that it cannot be swapped to the swap partition. This macro is used for setting the shmflg parameter passed to functions such as . |
|
Unlocks the shared memory segment. This macro is used for setting the shmflg parameter passed to functions such as shmget(). |
|
Obtains a shmid_ds data structure. This macro is used for setting the cmd parameter passed to . |
|
Obtains a shm_info data structure that includes system resource information about this shared memory segment. This macro is used for setting the cmd parameter passed to . |
|
SHM_STAT_ANY (15 | (IPC_STAT & 0x100)) |
Obtains a data structure without permission check. This macro is used for setting the cmd parameter passed to shmctl(). |
Functions
|
Dynamically allocates a block of uninitialized memory with the specified size. |
|
calloc (size_t nmemb, size_t size) |
Dynamically allocates multiple blocks of memory with the specified size. |
|
Changes the size of a previously allocated memory block pointed to by ptr to the specified size. |
|
free (void ptr) |
|
|
Allocates a block of memory with the specified size based on the given alignment mode. |
|
malloc_usable_size (void ptr) |
|
(void addr, size_t length, int prot, int flags, int fd, off_t offset) |
Creates a mapping between the virtual address space of the calling process and a file or device. |
munmap (void addr, size_t length) |
Removes all mappings for the specified virtual address space. |
|
Sets protection attributes for the memory pages contained in the memory region starting from addr with the specified length. |
|
mremap (void old_address, size_t old_size, size_t new_size, int flags,…) |
|
|
Attaches the shared memory segment identified by shmid to the address space of the current process. |
|
shmctl (int shmid, int cmd, struct buf) |
Performs a control operation specified by the cmd parameter on the shared memory segment identified by shmid. |
shmdt (const void *shmaddr) |
Detaches the shared memory segment attached to the address pointed to by shmaddr from the address space of the calling process. |
|
Obtains or creates a shared memory segment with the specified size based on the ID specified by key. |
Details
calloc()
Description:
Dynamically allocates multiple blocks of memory with the specified size.
Parameters:
| nmemb | Indicates the number of memory blocks to allocate. |
| size | Indicates the size of the memory block to allocate, in bytes. |
Returns:
Returns the pointer to the allocated memory block if the operation is successful; returns NULL and sets errno to a value in the following table if the operation fails or nmemb or size is set to 0.
free()
Description:
Frees the memory space pointed to by ptr.
Parameters:
| ptr | Indicates the pointer to a memory block previously allocated with malloc, or realloc. |
malloc()
void* malloc (size_t size)
Description:
Dynamically allocates a block of uninitialized memory with the specified size.
The allocated memory can be initialized by calling memset().
Parameters:
| size | Indicates the size of the memory block to allocate, in bytes. |
Returns:
Returns the pointer to the allocated memory block if the operation is successful; returns NULL and sets errno to a value in the following table if the operation fails or size is set to 0.
malloc_usable_size()
size_t malloc_usable_size (void * ptr)
Description:
Obtains the size of the memory block pointed to by ptr.
Parameters:
| ptr | Indicates the pointer to a block of memory previously allocated by functions such as . |
Returns:
Returns the number of usable bytes in the block of allocated memory pointed to by ptr; returns 0 if ptr is NULL.
See also:
memalign()
Description:
Allocates a block of memory with the specified size based on the given alignment mode.
The value of alignment must be a power of two.
Parameters:
| alignment | Indicates the alignment size of the allocated memory. |
| size | Indicates the size of the memory block to allocate, in bytes. |
Returns:
Returns the pointer to the allocated memory block if the operation is successful; returns NULL and sets errno to a value in the following table if the operation fails.
mmap()
Description:
Creates a mapping between the virtual address space of the calling process and a file or device.
The start address for the mapping is specified by addr, and the length to map is specified by length. The contents of the mapping are initialized starting at offset with the specified length in the file referred to by the file descriptor fd.
Parameters:
Attention:
If the file mapping is successful, fd cannot be closed before the mapping is deleted. (This rule does not conform to the Portable Operating System Interface (POSIX) standard. You should pay special attention to this rule.)
Returns:
Returns the pointer to the address where the mapping is placed if the operation is successful; returns and sets errno to a value in the following table if the operation fails.
The file descriptor specified by fd refers to a non-regular file. The file descriptor specified by fd is invalid. and PROT_WRITE are specified, but the file identified by fd is not opened in mode. PROT_WRITE is specified, but the file is append-only. |
|
The file descriptor specified by fd is invalid, and is not specified in flags. |
|
The length and offset are too large, addr is not page-aligned, or the length is 0. Neither MAP_SHARED nor is specified in flags, or both are specified. |
|
PROT_EXEC is specified in prot, but the mapped area belongs to a file on a file system that was mounted non-executable, or the file seal does not allow this operation. |
int mprotect (void * addr, size_t len, int prot )
Description:
Sets protection attributes for the memory pages contained in the memory region starting from addr with the specified length.
The address specified by addr must be page-aligned. If the process attempts to access memory in a manner that violates the protection attributes, an access exception will occur, and the process will be terminated.
Parameters:
Returns:
Returns 0 if the operation is successful; returns -1 and sets errno to a value in the following table if the operation fails.
The memory region cannot be granted the specified permission. This error can occur, for example, when you use mmap to map a file with prot set to and then use this function to set prot to PROT_WRITE. |
|
addr is an invalid pointer or it points to an address that is not a multiple of the page size. |
|
Internal kernel structures cannot be allocated due to insufficient memory, or addresses in the specified range are invalid for the address space of the process. The total number of mappings with different attributes exceeds the maximum number allowed by the system if the protection attribute of the memory region is changed. |
mremap()
void* mremap (void * old_address, size_t old_size, size_t new_size, int flags, ... )
Description:
Remaps a virtual memory region.
This function expands or shrinks an existing memory mapping, and may also move the mapping at the same time depending on the settings of flags and the available virtual address space.
Parameters:
Returns:
Returns the pointer to the new mapping address if the operation is successful; returns MAP_FAILED and sets errno to a value in the following table if the operation fails.
Some memory addresses in the range from old_address to old_address+old_size are invalid for this process. |
|
old_address is not a multiple of the page size, or a value other than MREMAP_MAYMOVE and is specified in flags. new_size is 0, new_size or new_address is invalid, or MREMAP_FIXED is specified in flags without also specifying . old_size is 0 but old_address does not point to a shared memory mapping; old_size is 0 but MREMAP_MAYMOVE is not specified in flags; or the new memory address range specified by new_address and new_size overlaps the old memory address range specified by old_address and old_size. |
|
munmap()
Description:
After all mappings are removed, any references to addresses within the specified range will generate invalid memory references. The memory region will also be automatically unmapped when the process is terminated. Closing the file descriptor does not remove mappings from the region.
Parameters:
| addr | Indicates the pointer to the start address of the memory region to unmap, which is the return value of . |
| length | Indicates the length of the address range to unmap, which should be the length specified in mmap(). |
Returns:
Returns 0 if the operation is successful; returns -1 and sets errno to a value in the following table if the operation fails.
realloc()
Description:
Changes the size of a previously allocated memory block pointed to by ptr to the specified size.
The contents of the memory block will be retained from the beginning of the memory pointed to by ptr to the lesser of the old and new sizes. If the new size is larger than the old size, the added memory portion will not be initialized. The behavior of this function varies depending on the input parameters:
Parameters:
| ptr | Indicates the pointer to a memory block previously allocated with malloc, or realloc. |
| size | Indicates the new size for the memory block, in bytes. |
Returns:
Returns the pointer to the new memory block if the operation is successful; returns NULL and sets errno to a value in the following table if the operation fails.
shmat()
void* shmat (int shmid, const void * shmaddr, int shmflg )
Description:
Attaches the shared memory segment identified by shmid to the address space of the current process.
Parameters:
| shmid | Identifies the shared memory segment to attach, which is obtained by shmget(). |
| shmaddr | Indicates the space address of the current process to attach. If this parameter is NULL, the system chooses an unused address to attach. |
| shmflg | Indicates the attribute of the shared memory segment to attach, which is the bitwise OR combination of one or more of the following flags: |
Round the attached address. If shmaddr is not NULL and SHM_RND is specified in shmflg, the address is rounded down to the nearest multiple of . |
|
Allow the contents of the attached shared memory segment to be executable. |
|
Set the contents of the attached shared memory segment to be read-only. |
|
Replace any existing mapping in the address range starting at shmaddr and continuing for the size of the segment during the current memory mapping. When SHM_REMAP is not specified, an EINVAL error will be returned if a mapping exists in the address range. |
Returns:
Returns the pointer to the address of the attached shared memory segment if the operation is successful; returns (void *)-1 and sets errno to a value in the following table if the operation fails.
The current process does not have the required permission on the requested mapping type. |
|
The shared memory segment specified by shmid has been removed. |
|
The value of shmid is invalid. shmaddr is not aligned (not page-aligned and SHM_RND is not specified) or its value is invalid. is specified, but shmaddr is NULL. |
|
shmctl()
int shmctl (int shmid, int cmd, struct [shmid_ds]($api-api-SmartVision-Devices-shmid_ds.md) * buf )
Description:
Performs a control operation specified by the cmd parameter on the shared memory segment identified by shmid.
Parameters:
| shmid | Identifies the shared memory segment to attach, which is obtained by shmget(). |
| cmd | Indicates the control operation to perform. The following table describes available values. |
| buf | Indicates the pointer to the buffer for storing the information to set or obtain. |
Copy information from the kernel data structure associated with the shared memory segment identified by shmid into the shmid_ds structure pointed to by buf. |
|
Return a data structure. When SHM_STAT is specified, shmid does not identify a shared memory segment. Instead, it indicates the index to the kernel’s internal array that maintains information about all shared memory segments. |
|
Write the values of some fields in the data structure pointed to by buf to the kernel data structure associated with the specified shared memory segment, updating also its shm_ctimemember. The following fields can be modified: shm_perm.uid, shm_perm.gid, and shm_perm.mode. |
|
Return information about system-wide shared memory limits and parameters in the structure pointed to by buf. The returned structure is of the shminfo type, and a cast is required. |
|
Return a structure that contains information about system resources consumed by the specified shared memory segment. |
Returns:
Returns 0 if the operation is successful; returns -1 and sets errno to a value in the following table if the operation fails.
or SHM_STAT is specified in cmb, but the mode field in shm_perm does not allow any read operation on the shared memory segment identified by shmid. |
|
or IPC_STAT is specified in cmd, but the address pointed to by buf is not accessible. |
|
The value of shmid or cmd is invalid. When is specified in cmd, the value is considered invalid if the index specified by shmid refers to an unused array slot. |
|
IPC_SET or is attempted, but the effective user ID of the calling process is not that of the creator or the owner, and the process is not privileged. |
shmdt()
Description:
Detaches the shared memory segment attached to the address pointed to by shmaddr from the address space of the calling process.
Parameters:
| shmaddr | Indicates the pointer to the address of the shared memory segment to detach. The value of this parameter should be the pointer previously returned by shmat(). |
Returns:
Returns 0 if the operation is successful; returns -1 and sets errno to a value in the following table if the operation fails.
No shared memory segment is attached to shmaddr, or shmaddr is not aligned. |
Description:
Obtains or creates a shared memory segment with the specified size based on the ID specified by key.
If the shared memory segment associated with key does not exist and IPC_CREAT is specified in shmflg or if key has the value , this function creates a shared memory segment with the size equal to the value of size rounded up to a multiple of PAGE_SIZE.
Parameters:
| key | Indicates the key of the shared memory segment. |
| size | Indicates the size of the shared memory segment to create. The actual size is rounded up to a multiple of PAGE_SIZE. |
| shmflg | Indicates the attribute of the shared memory segment, which is the bitwise OR combination of one or more of the following flags: |
Create a new shared memory segment. If this flag is not specified, this function will find the segment with the specified key and check to see whether the user has permission to access the segment. |
|
Used together with IPC_CREAT to ensure that this function is called to create a shared memory segment. The calling fails if the segment already exists. |
Returns:
Returns the ID of the shared memory segment if the operation is successful; returns -1 and sets errno to a value in the following table if the operation fails.
The current process does not have the permission to obtain the specified shared memory segment. |
|
IPC_EXCL and are specified, but the shared memory segment associated with key already exists. |
|
The size specified for the shared memory segment to create is less than the value of shmmin in shminfo or greater than the value of shmmax. The shared memory segment associated with key already exists, but the value of size is greater than the size of the segment. |
|
Allocating a segment of the requested size would cause the system to exceed the system-wide limit on shared memory (shmall in shminfo). |
