sysmem.h

Go to the documentation of this file.

 
#ifndef _PSP2KERN_KERNEL_SYSMEM_H_
#define _PSP2KERN_KERNEL_SYSMEM_H_
 
#include <vitasdk/build_utils.h>
#include <psp2kern/types.h>
#include <psp2kern/kernel/sysmem/address_space.h>
#include <psp2kern/kernel/sysmem/uid_class.h>
#include <psp2kern/kernel/sysmem/uid_guid.h>
#include <psp2kern/kernel/sysmem/uid_puid.h>
#include <psp2kern/kernel/sysmem/uid_entryheap.h>
#include <psp2kern/kernel/sysmem/fixedheap.h>
#include <psp2kern/kernel/sysmem/nameheap.h>
#include <psp2kern/kernel/sysmem/heap.h>
#include <psp2kern/kernel/sysmem/data_transfers.h>
#include <psp2kern/kernel/sysmem/memtype.h>
#include <psp2common/kernel/sysmem.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum SceKernelMemoryRefPerm {
    SCE_KERNEL_MEMORY_REF_PERM_ANY      = 0,
    SCE_KERNEL_MEMORY_REF_PERM_USER_R   = 0x01,
    SCE_KERNEL_MEMORY_REF_PERM_USER_W   = 0x02,
    SCE_KERNEL_MEMORY_REF_PERM_USER_X   = 0x04,
    SCE_KERNEL_MEMORY_REF_PERM_KERN_R   = 0x10,
    SCE_KERNEL_MEMORY_REF_PERM_KERN_W   = 0x20,
    SCE_KERNEL_MEMORY_REF_PERM_KERN_X   = 0x40,
} SceKernelMemoryRefPerm;
 
// specific to 3.60
typedef struct SceKernelAllocMemBlockKernelOpt {
    SceSize size;                   
    SceUInt32 field_4;
    SceUInt32 attr;                 
    SceUInt32 field_C;
    SceUInt32 paddr;
    SceSize alignment;
    SceSize extraLow;
    SceSize extraHigh;
    SceUInt32 mirror_blockid;
    SceUID pid;
    SceKernelPaddrList *paddr_list;
    SceUInt32 field_2C;
    SceUInt32 field_30;
    SceUInt32 field_34;
    SceUInt32 field_38;
    SceUInt32 field_3C;
    SceUInt32 field_40;
    SceUInt32 field_44;
    SceUInt32 field_48;
    SceUInt32 field_4C;
    SceUInt32 field_50;
    SceUInt32 field_54;
} SceKernelAllocMemBlockKernelOpt;
VITASDK_BUILD_ASSERT_EQ(0x58, SceKernelAllocMemBlockKernelOpt); // size is from FW 3.60
 
typedef SceKernelAllocMemBlockKernelOpt SceKernelAllocMemBlockOptKernel;
 
SceUID ksceKernelAllocMemBlock(const char *name, SceKernelMemBlockType type, SceSize size, SceKernelAllocMemBlockKernelOpt *opt);
 
int ksceKernelFreeMemBlock(SceUID uid);
 
int ksceKernelGetMemBlockBase(SceUID uid, void **base);
 
int ksceKernelGetMemBlockType(SceUID uid, unsigned int *type);
 
SceUID ksceKernelFindMemBlockByAddr(const void *addr, SceSize size);
 
SceUID ksceKernelFindProcMemBlockByAddr(SceUID pid, const void *addr, SceSize size);
 
int ksceKernelGetMemBlockAllocMapSize(SceUID memid, SceSize *alloc_map_size);
 
int ksceKernelMapMemBlock(SceUID uid);
 
int ksceKernelMapMemBlockWithFlag(SceUID uid, int flag);
 
int ksceKernelRemapMemBlock(SceUID uid, SceKernelMemBlockType type);
 
int ksceKernelUnmapMemBlock(SceUID uid);
 
SceUID ksceKernelUserMap(const char *name, int permission, const void *user_buf, SceSize size, void **kernel_page, SceSize *kernel_size, SceUInt32 *kernel_offset);
 
SceUID ksceKernelProcUserMap(SceUID pid, const char *name, int permission, const void *user_buf, SceSize size, void **kernel_page, SceSize *kernel_size, SceUInt32 *kernel_offset);
 
SceUID ksceKernelUserMapWithFlags(const char *name, int permission, int flags, const void *user_buf, SceSize size, void **kernel_page, SceSize *kernel_size, unsigned int *kernel_offset);
 
int ksceKernelUserUnmap(SceUID uid);
 
int ksceKernelLockRange(void *addr, SceSize size);
 
int ksceKernelLockRangeProc(ScePID pid, void *addr, SceSize size);
 
int ksceKernelLockRangeWithMode(SceKernelMemoryRefPerm perm, void *addr, SceSize size);
 
int ksceKernelUnlockRange(void *addr, SceSize size);
 
int ksceKernelUnlockRangeProc(ScePID pid, void *addr, SceSize size);
 
int ksceKernelUnlockRangeWithMode(SceKernelMemoryRefPerm perm, void *addr, SceSize size);
 
 
SceUID ksceKernelAllocPartitionMemBlock(SceUID part, const char *name, SceKernelMemBlockType type, SceSize size, const SceKernelAllocMemBlockOptKernel *pOpt);
int ksceKernelFreeSimpleMemBlock(void *a1);
 
 
/* Macros for backwards compatibility */
#define ksceKernelFindMemBlockByAddrForPid(pid, addr, size) ksceKernelFindProcMemBlockByAddr(pid, addr, size)
 
#define ksceKernelMapBlockUserVisible(uid) ksceKernelMapMemBlock(uid)
#define ksceKernelRemapBlock(uid, type) ksceKernelRemapMemBlock(uid, type)
 
#define ksceKernelMapUserBlock(name, permission, flags, user_buf, size, kernel_page, kernel_size, kernel_offset) ksceKernelUserMapWithFlags(name, permission, flags, user_buf, size, kernel_page, kernel_size, kernel_offset)
#define ksceKernelMapUserBlockDefaultType(name, permission, user_buf, size, kernel_page, kernel_size, kernel_offset) ksceKernelUserMap(name, permission, user_buf, size, kernel_page, kernel_size, kernel_offset)
#define ksceKernelMapUserBlockDefaultTypeForPid(pid, name, permission, user_buf, size, kernel_page, kernel_size, kernel_offset) ksceKernelProcUserMap(pid, name, permission, user_buf, size, kernel_page, kernel_size, kernel_offset)
#define ksceKernelMemBlockRelease(uid) ksceKernelUserUnmap(uid)
 
#define ksceKernelMemRangeRetain(addr, size) ksceKernelLockRange(addr, size)
#define ksceKernelMemRangeRetainForPid(pid, addr, size) ksceKernelLockRangeProc(pid, addr, size)
#define ksceKernelMemRangeRetainWithPerm(perm, addr, size) ksceKernelLockRangeWithMode(perm, addr, size)
 
#define ksceKernelMemRangeRelease(addr, size) ksceKernelUnlockRange(addr, size)
#define ksceKernelMemRangeReleaseForPid(pid, addr, size) ksceKernelUnlockRangeProc(pid, addr, size)
#define ksceKernelMemRangeReleaseWithPerm(perm, addr, size) ksceKernelUnlockRangeWithMode(perm, addr, size)
 
typedef enum SceKernelHeapMemoryMappingAction {
    SCE_KERNEL_HEAP_MEMORY_MAPPING_ACTION_NONE  = 0,
    SCE_KERNEL_HEAP_MEMORY_MAPPING_ACTION_MAP   = 1,
    SCE_KERNEL_HEAP_MEMORY_MAPPING_ACTION_UNMAP = 2
} SceKernelHeapMemoryMappingAction;
 
typedef struct SceKernelHeapMemoryOpt {
    SceSize size; 
    SceUInt32 mapping_action; 
    SceSize alignment; 
    void *mapped_base; 
    SceSize mapped_size; 
} SceKernelHeapMemoryOpt;
VITASDK_BUILD_ASSERT_EQ(0x14, SceKernelHeapMemoryOpt); // size is from FW 0.990-3.60
 
typedef struct SceKernelAllocMemBlockInfo {
    SceSize size; 
    void *mapped_base; 
    SceSize mapped_size; 
    SceKernelMemoryType memory_type; 
    SceUInt32 access; 
} SceKernelAllocMemBlockInfo;
VITASDK_BUILD_ASSERT_EQ(0x14, SceKernelAllocMemBlockInfo); // size is from FW 3.60
 
typedef struct SceUIDPhyMemPartObject SceUIDPhyMemPartObject;
 
typedef struct SceKernelMemBlockInfoCore {
    SceKernelMemBlockType type; 
    SceUID guid; 
    const char *name; 
    void *mapped_base; 
    SceSize mapped_size; 
    SceSize alloc_map_size; 
    SceSize extra_low; 
    SceSize extra_high; 
    SceUInt32 paging_type; 
    SceUID partition_guid; 
    SceUIDPhyMemPartObject *phy_mem_part; 
} SceKernelMemBlockInfoCore;
VITASDK_BUILD_ASSERT_EQ(0x2C, SceKernelMemBlockInfoCore); // size is from FW 3.60
 
typedef struct SceKernelMemBlockInfoEx {
    SceSize size; 
    SceKernelMemBlockInfoCore core_info;
    SceSize physical_range_count; 
    SceSize physical_range_count_written; 
    void *physical_addresses[16]; 
    SceSize physical_sizes[16]; 
} SceKernelMemBlockInfoEx;
VITASDK_BUILD_ASSERT_EQ(0xB8, SceKernelMemBlockInfoEx); // size is from FW 3.60
 
typedef struct SceKernelObject SceKernelObject;
 
SceUID ksceGUIDCreate(SceClass *object_class, const char *name, SceUID reference_guid, SceKernelObject **object);
 
int ksceGUIDGetClass(SceUID guid, SceClass **object_class);
 
int ksceGUIDGetName(SceUID guid, const char **name);
 
int ksceGUIDGetObject(SceUID guid, SceKernelObject **object);
 
SceUID ksceGUIDKernelCreate(SceClass *object_class, const char *name, SceKernelObject **object);
 
const char *ksceGUIDName(SceUID guid);
 
SceUID ksceGUIDOpenByName(const char *name);
 
int ksceGUIDReferObjectWithLevel(SceUID guid, SceUInt32 visibility_level, SceKernelObject **object);
 
int ksceGUIDReferObjectWithSubclass(SceUID guid, SceClass *object_class, SceKernelObject **object);
 
int ksceGUIDSetName(SceUID guid, const char *name);
 
void *ksceKernelAllocHeapMemoryWithOpt(SceUID heap_id, SceSize size, SceKernelHeapMemoryOpt *opt);
 
SceUID ksceKernelAllocMemBlockWithInfo(const char *name, SceKernelMemBlockType type, SceSize vsize, const SceKernelAllocMemBlockOptKernel *opt, SceKernelAllocMemBlockInfo *info);
void *ksceKernelAllocUncacheHeapMemory(SceSize size);
void *ksceKernelAllocUncacheHeapMemoryWithOption(SceSize size, SceKernelHeapMemoryOpt *opt);
 
int ksceKernelCountFillValue64FromUser(const SceUInt64 *ptr, SceUInt64 value, SceSize byte_size);
 
int ksceKernelCountFillValue64FromUserProc(ScePID pid, const SceUInt64 *ptr, SceUInt64 value, SceSize byte_size);
 
int ksceKernelCountFillValueFromUser(const SceUInt32 *ptr, SceUInt32 value, SceSize byte_size);
 
int ksceKernelCountFillValueFromUserProc(ScePID pid, const SceUInt32 *ptr, SceUInt32 value, SceSize byte_size);
 
int ksceKernelDecRefCountMemBlock(SceUID uid);
 
int ksceKernelFreeUncacheHeapMemory(void *ptr);
int ksceKernelGetMemBlockInfo(SceUID uid, SceUInt32 visibility_level, SceKernelMemBlockInfoEx *info);
 
int ksceKernelGetMemBlockMappedBase(SceUID uid, void **base);
 
int ksceKernelGetMemBlockMemtypeByAddr(const void *addr);
 
int ksceKernelGetMemBlockPARange(SceUID uid, SceKernelPARange *pa_range);
 
int ksceKernelGetMemBlockPAVector(SceUID uid, SceKernelPAVector *pa_vector);
 
int ksceKernelGetMemBlockVBase(SceUID uid, void **base);
 
int ksceKernelGetPhysicalMemoryType(const void *vaddr);
 
int ksceKernelIncRefCountMemBlock(SceUID uid);
int ksceKernelIsAccessibleRange(SceUInt32 permission, const void *va, SceSize len);
int ksceKernelIsAccessibleRangeProc(ScePID pid, SceUInt32 permission, const void *va, SceSize len);
 
int ksceKernelIsEqualAccessibleRangeProcBySW(ScePID pid, SceUInt32 permission, const void *va, SceSize len);
 
int ksceKernelMemBlockGetInfoEx(SceUID uid, SceKernelMemBlockInfoEx *info);
 
int ksceKernelMemBlockType2Memtype(SceKernelMemBlockType type);
 
int ksceKernelMemBlockTypeGetPrivileges(SceKernelMemBlockType type);
 
int ksceKernelProcModeVAtoPA(ScePID pid, SceUInt32 permission, const void *va, void **pa);
int ksceKernelVARangeToPARangeByHW(const SceKernelVARange *v_range, SceKernelPARange *pa_range);
int ksceKernelVARangeToPARangeBySW(const SceKernelVARange *v_range, SceKernelPARange *pa_range);
int ksceKernelVARangeToPAVectorByHW(const SceKernelVARange *v_range, SceKernelPAVector *pa_vector);
int ksceKernelVARangeToPAVectorBySW(const SceKernelVARange *v_range, SceKernelPAVector *pa_vector);
int ksceKernelVAtoPABySW(const void *va, void **pa);
 
int kscePUIDGetClass(ScePID pid, SceUID puid, SceClass **object_class);
 
int kscePUIDGetName(ScePID pid, SceUID puid, const char **name);
 
int kscePUIDGetObject(ScePID pid, SceUID puid, SceKernelObject **object);
 
SceUID kscePUIDOpenByGUIDWithFlags(ScePID pid, SceUID guid, SceUInt32 flags);
 
SceUID kscePUIDOpenByName(ScePID pid, const char *name);
 
SceUID kscePUIDOpenByNameWithClass(ScePID pid, const char *name, SceClass *object_class);
 
int kscePUIDSetName(ScePID pid, SceUID puid, const char *name);
 
SceUID kscePUIDtoGUIDWithClass(ScePID pid, SceUID puid, SceClass *object_class);
 
#ifdef __cplusplus
}
#endif
 
#endif /* _PSP2KERN_KERNEL_SYSMEM_H_ */