Skip to main content

​
Overview

The memory API provides functions for allocating and managing memory on the PlayStation 3. It includes direct memory allocation, virtual memory mapping, and memory containers for resource management.

​
Direct Memory Allocation

​
sysMemoryAllocate

Allocate a block of memory. 
s32 sysMemoryAllocate(size_t size, u64 flags, sys_mem_addr_t *alloc_addr);
​
size
size_t
required
Size of memory block in bytes
​
flags
u64
required
Page size and access rights flags (OR combination):
  • SYS_MEMORY_PAGE_SIZE_1M or SYS_MEMORY_PAGE_SIZE_64K
  • SYS_MEMORY_ACCESS_RIGHT_PPU_THR, SYS_MEMORY_ACCESS_RIGHT_SPU_THR, etc.
​
alloc_addr
sys_mem_addr_t*
required
Pointer to storage for allocated memory address
​
return
s32
Zero on success, error code otherwise
Example: 
sys_mem_addr_t addr;
u64 flags = SYS_MEMORY_PAGE_SIZE_1M | SYS_MEMORY_ACCESS_RIGHT_ANY;

s32 ret = sysMemoryAllocate(1024 * 1024, flags, &addr);
if (ret == 0) {
    // Use memory at addr
    sysMemoryFree(addr);
}

​
sysMemoryFree

Free previously allocated memory. 
s32 sysMemoryFree(sys_mem_addr_t start_addr);
​
start_addr
sys_mem_addr_t
required
Address returned by sysMemoryAllocate
​
return
s32
Zero on success, error code otherwise

​
Virtual Memory Mapping

​
sysMMapperAllocateAddress

Allocate a virtual address range. 
s32 sysMMapperAllocateAddress(size_t size,
                               u64 flags,
                               size_t alignment,
                               sys_mem_addr_t *alloc_addr);
​
size
size_t
required
Size of virtual address range
​
flags
u64
required
Page size flags
​
alignment
size_t
required
Address alignment requirement
​
alloc_addr
sys_mem_addr_t*
required
Pointer to storage for allocated virtual address
​
return
s32
Zero on success, error code otherwise

​
sysMMapperFreeAddress

Free a virtual address range. 
s32 sysMMapperFreeAddress(sys_mem_addr_t start_addr);
​
start_addr
sys_mem_addr_t
required
Virtual address to free
​
return
s32
Zero on success, error code otherwise

​
sysMMapperSearchAndMap

Search for and map a memory region to a virtual address. 
s32 sysMMapperSearchAndMap(sys_mem_addr_t start_addr,
                            sys_mem_id_t mem_id,
                            u64 flags,
                            sys_mem_addr_t *alloc_addr);
​
start_addr
sys_mem_addr_t
required
Starting virtual address for search
​
mem_id
sys_mem_id_t
required
Memory object ID to map
​
flags
u64
required
Access rights and protection flags
​
alloc_addr
sys_mem_addr_t*
required
Pointer to storage for mapped address
​
return
s32
Zero on success, error code otherwise

​
sysMMapperAllocateMemory

Allocate a memory object for mapping. 
s32 sysMMapperAllocateMemory(size_t size, u64 flags, sys_mem_id_t *mem_id);
​
size
size_t
required
Size of memory object
​
flags
u64
required
Page size flags
​
mem_id
sys_mem_id_t*
required
Pointer to storage for memory object ID
​
return
s32
Zero on success, error code otherwise

​
sysMMapperFreeMemory

Free a memory object. 
s32 sysMMapperFreeMemory(sys_mem_id_t mem_id);
​
mem_id
sys_mem_id_t
required
Memory object ID to free
​
return
s32
Zero on success, error code otherwise

​
sysMMapperMapMemory

Map a memory object to a virtual address. 
s32 sysMMapperMapMemory(sys_mem_addr_t start_addr,
                        sys_mem_id_t mem_id,
                        u64 flags);
​
start_addr
sys_mem_addr_t
required
Virtual address where memory should be mapped
​
mem_id
sys_mem_id_t
required
Memory object ID
​
flags
u64
required
Access rights flags
​
return
s32
Zero on success, error code otherwise

​
sysMMapperUnmapMemory

Unmap memory from a virtual address. 
s32 sysMMapperUnmapMemory(sys_mem_addr_t start_addr, sys_mem_id_t *mem_id);
​
start_addr
sys_mem_addr_t
required
Virtual address to unmap
​
mem_id
sys_mem_id_t*
Pointer to storage for unmapped memory object ID
​
return
s32
Zero on success, error code otherwise

​
Memory Containers

Memory containers are used for resource management and limiting memory usage.

​
sysMemContainerCreate

Create a memory container. 
s32 sysMemContainerCreate(sys_mem_container_t *container, size_t size);
​
container
sys_mem_container_t*
required
Pointer to storage for container ID
​
size
size_t
required
Maximum size of container in bytes
​
return
s32
Zero on success, error code otherwise
Example: 
sys_mem_container_t container;
s32 ret = sysMemContainerCreate(&container, 10 * 1024 * 1024); // 10MB limit
if (ret == 0) {
    sys_mem_addr_t addr;
    u64 flags = SYS_MEMORY_PAGE_SIZE_1M | SYS_MEMORY_ACCESS_RIGHT_ANY;
    
    // Allocate from container
    sysMemAllocateFromContainer(1024 * 1024, container, flags, &addr);
    
    // Use memory...
    
    sysMemoryFree(addr);
    sysMemContainerDestroy(container);
}

​
sysMemContainerDestroy

Destroy a memory container. 
s32 sysMemContainerDestroy(sys_mem_container_t container);
​
container
sys_mem_container_t
required
Container ID to destroy
​
return
s32
Zero on success, error code otherwise

​
sysMemAllocateFromContainer

Allocate memory from a container. 
s32 sysMemAllocateFromContainer(size_t size,
                                 sys_mem_container_t container,
                                 u64 flags,
                                 sys_mem_addr_t *alloc_addr);
​
size
size_t
required
Size to allocate
​
container
sys_mem_container_t
required
Container ID
​
flags
u64
required
Page size and access rights flags
​
alloc_addr
sys_mem_addr_t*
required
Pointer to storage for allocated address
​
return
s32
Zero on success, error code otherwise

​
sysMMapperAllocateMemoryFromContainer

Allocate a memory object from a container. 
s32 sysMMapperAllocateMemoryFromContainer(size_t size,
                                           sys_mem_container_t container,
                                           u64 flags,
                                           sys_mem_id_t *mem_id);
​
size
size_t
required
Size of memory object
​
container
sys_mem_container_t
required
Container ID
​
flags
u64
required
Page size flags
​
mem_id
sys_mem_id_t*
required
Pointer to storage for memory object ID
​
return
s32
Zero on success, error code otherwise

​
Constants

​
Page Size Flags

​
SYS_MEMORY_PAGE_SIZE_1M
u64
Use 1MB page size (0x0000000000000400ULL)
​
SYS_MEMORY_PAGE_SIZE_64K
u64
Use 64KB page size (0x0000000000000200ULL)

​
Access Rights Flags

​
SYS_MEMORY_ACCESS_RIGHT_PPU_THR
u64
PPU thread access (0x0000000000000008ULL)
​
SYS_MEMORY_ACCESS_RIGHT_SPU_THR
u64
SPU thread access (0x0000000000000002ULL)
​
SYS_MEMORY_ACCESS_RIGHT_HANDLER
u64
Handler access (0x0000000000000004ULL)
​
SYS_MEMORY_ACCESS_RIGHT_RAW_SPU
u64
Raw SPU access (0x0000000000000001ULL)
​
SYS_MEMORY_ACCESS_RIGHT_ANY
u64
All access rights (OR of all above)

​
Protection Flags

​
SYS_MEMORY_PROT_READ_ONLY
u64
Read-only access (0x0000000000080000ULL)
​
SYS_MEMORY_PROT_READ_WRITE
u64
Read-write access (0x0000000000040000ULL)

​
Header Files

#include <sys/memory.h>  // Memory allocation functions
#include <lv2/memory.h>  // Memory mapping functions

Build docs developers (and LLMs) love

Get started for freeTalk to us