loadcore.h

 
#ifndef LOADCORE_H
#define LOADCORE_H
 
#include <memlmd.h>
#include <mesgled.h>
#include "common_imp.h"
#include "threadman_kernel.h"
 
#define LIBRARY_VERSION_MINOR                   (0)
 
#define LIBRARY_VERSION_MAJOR                   (1)
 
#define LIBRARY_VERSION_NUMBER_CATEGORY_SIZE    (2)
 
#define LIBRARY_ENTRY_TABLE_OLD_LEN             (4)
 
#define LIBRARY_ENTRY_TABLE_NEW_LEN             (5)
 
#define STUB_LIBRARY_ENTRY_TABLE_OLD_LEN        (6)
 
#define STUB_LIBRARY_ENTRY_TABLE_NEW_LEN        (7)
 
#define LOADCORE_LIB_HASH_TABLE_SIZE            (128)
 
#define SCE_BOOT_CALLBACK_FUNCTION_QUEUED       (1)
 
#define SCE_PROTECT_INFO_STATE_IS_ALLOCATED     (1 << 0)
 
#define SCE_PROTECT_INFO_TYPE_FILE_NAME         (0x2)
 
#define SCE_PROTECT_INFO_TYPE_VSH_PARAM         (0x4)
 
#define SCE_PROTECT_INFO_TYPE_DISC_IMAGE        (0x40)
 
#define SCE_PROTECT_INFO_TYPE_NPDRM_DATA        (0x80)
 
#define SCE_PROTECT_INFO_TYPE_USER_PARAM        (0x100)
 
#define SCE_PROTECT_INFO_TYPE_PARAM_SFO         (0x400)
 
#define GET_PROTECT_INFO_STATE(attr)            ((u32)(attr) >> 16)
 
#define SET_PROTECT_INFO_STATE(state, src)      (((state) << 16) | (src))
 
#define REMOVE_PROTECT_INFO_STATE(state, src)   ((~((state) << 16)) & (src))
 
#define GET_PROTECT_INFO_TYPE(attr)             ((attr) & 0xFFFF)
 
#define SET_PROTECT_INFO_TYPE(type, src)        (((type) & 0xFFFF) | (src))
 
enum SceExecFileAttr {
    SCE_EXEC_FILE_COMPRESSED        = 0x1,
    SCE_EXEC_FILE_ELF               = 0x2,
    SCE_EXEC_FILE_GZIP_OVERLAP      = 0x8,
    SCE_EXEC_FILE_KL4E_COMPRESSED   = 0x200
};
 
enum SceExecFileModeAttr {
    SCE_EXEC_FILE_DECRYPT                   = 0,
    SCE_EXEC_FILE_NO_HEADER_COMPRESSION     = 1,
    SCE_EXEC_FILE_NO_COMPRESSION            = 2,
};
 
enum SceExecFileElfType {
    SCE_EXEC_FILE_TYPE_INVALID_ELF   = -1,
    SCE_EXEC_FILE_TYPE_PRX           = 1,
    SCE_EXEC_FILE_TYPE_PRX_2         = 2,
    SCE_EXEC_FILE_TYPE_ELF           = 3,
};
 
enum SceLibAttr {
    SCE_LIB_NO_SPECIAL_ATTR = 0x0,
    SCE_LIB_AUTO_EXPORT = 0x1,
    SCE_LIB_WEAK_EXPORT = 0x2,
    SCE_LIB_NOLINK_EXPORT = 0x4,
    SCE_LIB_WEAK_IMPORT = 0x8,
    SCE_LIB_SYSCALL_EXPORT = 0x4000,
    SCE_LIB_IS_SYSLIB = 0x8000
};
 
typedef s32 (*SceKernelBootCallbackFunction)(void *data, s32 arg, void *opt);
 
typedef s32 (*SceKernelRebootBeforeForKernel)(void *arg1, s32 arg2, s32 arg3, s32 arg4);
typedef s32 (*SceKernelRebootPhaseForKernel)(s32 arg1, void *arg2, s32 arg3, s32 arg4);
 
typedef struct {
    u32 call;
    u32 delaySlot;
} DirectCall;
 
typedef struct {
    u32 returnAddr;
    u32 syscall;
} Syscall;
 
typedef union {
    DirectCall dc;
    Syscall sc;
} SceStub;
 
typedef struct {
    u32 *addr;
    u32 nid;
} SceVariableStub;
 
typedef struct {
    const char *libName; //0
    u8   version[LIBRARY_VERSION_NUMBER_CATEGORY_SIZE]; //4
    s16  attribute; //6
    u8   len; //8
    u8   vStubCount; //9
    u16   stubCount; //10
    u32 *entryTable; //12
    u16  unk16; //16
    u8   unk18; //18
    u8   unk19; //19
} SceResidentLibraryEntryTable;
 
typedef struct {
        const char *libName;  //0
        u8 version[LIBRARY_VERSION_NUMBER_CATEGORY_SIZE]; //4
        u16 attribute; //6
        u8 len; //8
        u8 vStubCount; //9
        u16 stubCount; //10
        u32 *nidTable; //12
        SceStub *stubTable; //16
        SceVariableStub *vStubTable; // 20
    u16 unk24; //24
} SceStubLibraryEntryTable;
 
typedef struct {
    void *bootCBFunc;
    u32 gp;
} SceBootCallback;
 
typedef struct SceStubLibrary {
    u32 unk0; //0
    struct SceStubLibrary *next; //4
    const char *libName; //8
    u8 version[LIBRARY_VERSION_NUMBER_CATEGORY_SIZE]; //12
    u16 attribute; //14
    u8 stubEntryTableLen; //16
    u8 vStubCount; //17
    u16 stubCount; //18
    u32 *nidTable; //20
    SceStub *stubTable; //24
    SceVariableStub *vStubTable; //28
    u16 unk32; //32
    SceStubLibraryEntryTable *libStubTable; //36
    u32 status; //40
    u32 isUserLib; //44
    char *libName2; //48
    u32 libNameInHeap; //52
} SceStubLibrary; //size = 56
 
typedef struct SceResidentLibrary {
    struct SceResidentLibrary *next; //0
    SceResidentLibraryEntryTable *libEntryTable; //4
    u8 version[LIBRARY_VERSION_NUMBER_CATEGORY_SIZE]; //8
    u16  attribute; //10
    u16 stubCount; //12
    u16 vStubCount; //14
    u32 numExports; //16
    u8 unk20; //20
    u8 unk21; //21
    u8 unk22; //22
    s32 unk24; //24
    u32 unk28; //28
    u32 *entryTable; //32
    u32 *exportsBaseAddr; //36
    u32 exportsSize; //40
    u32 midFuncIndex; //44
    u32 unk48; //48
    SceStubLibrary *stubLibs; //52
    u32 sysTableEntry; //56
    u32 isUserLib; //60
    u32 unk64; //64 
    char *libName; //68 
    u32 libNameInHeap; //72
    u16 sysTableEntryStartIndex; //76
    u16 extraExportEntries; //78
} SceResidentLibrary; //size = 80
 
typedef struct {
    u32 addr;
    SceSize size; // 4
    u32 attr; // 8
    SceUID partId; // 12
    s32 unk16;
    s32 unk20;
    s32 unk24;
} SceLoadCoreProtectInfo;
 
typedef struct {
    u8 *modPath; //0
    u8 *modBuf; //4
    SceSize modSize; //8
    s32 unk12; //12
    u32 attr; //16
    s32 bootData; //20
    u32 argSize; //24
    SceUID argPartId; //28
} SceLoadCoreBootModuleInfo;
 
typedef struct { 
    void *memBase; // 0
    u32 memSize; // 4
    u32 loadedModules; // 8
    u32 numModules; // 12
    SceLoadCoreBootModuleInfo *modules; // 16
    s32 unk20; //20
    u8 unk24; //24
    u8 reserved[3]; // ?
    s32 numProtects; // 28
    SceLoadCoreProtectInfo *protects; // 32
    SceUID modProtId;
    SceUID modArgProtId; // 40
    s32 unk44;
    s32 buildVersion;
    s32 unk52;
    char *configFile; // 56
    s32 unk60;
    s32 unk64;
    s32 unk68;
    s32 unk72;
    s32 unk76;
    u32 unk80;
    u32 unk84;
    u32 unk98;
    u32 unk92;
    u32 unk96;
    u32 unk100;
    u32 unk104;
    u32 unk108;
    u32 unk112;
    u32 unk116;
    u32 unk120;
    u32 unk124;
} SceLoadCoreBootInfo; //size = 128
 
#define SCE_KERNEL_MAX_MODULE_SEGMENT   (4) 
typedef struct {
    u32 unk0;
    u32 modeAttribute; //4
    u32 apiType; //8
    u32 unk12;
    SceSize execSize; //16
    SceSize maxAllocSize; //20
    SceUID decompressionMemId; //24
    void *fileBase; //28
    u32 elfType; //32 
    void *topAddr; //36
    u32 entryAddr; //40
    u32 unk44;
    SceSize modCodeSize; //48
    SceSize textSize; //52
    SceSize dataSize; //56
    SceSize bssSize; //60
    u32 partitionId; //64
    u32 isKernelMod; //68
    u32 isDecrypted; //72
    u32 moduleInfoOffset; //76
    SceModuleInfo *moduleInfo; //80
    u32 isCompressed; //84
    u16 modInfoAttribute; //88
    u16 execAttribute; //90
    SceSize decSize; //92
    u32 isDecompressed; //96
    u32 isSignChecked; //100
    char *secureInstallId; // 104
    SceSize overlapSize; //108
    void *exportsInfo; //112
    SceSize exportsSize; //116
    void *importsInfo; //120
    SceSize importsSize; //124
    void *strtabOffset; //128
    u8 numSegments; //132
    u8 padding[3]; //133
    u32 segmentAddr[SCE_KERNEL_MAX_MODULE_SEGMENT]; //136
    u32 segmentSize[SCE_KERNEL_MAX_MODULE_SEGMENT]; //152
    SceUID memBlockId; //168
    u32 segmentAlign[SCE_KERNEL_MAX_MODULE_SEGMENT]; //172
    u32 maxSegAlign; //188
} SceLoadCoreExecFileInfo;
 
#define SCE_MODULE_USER_MODULE  (0x100)
 
// TODO: Change name to something like *_MCB_STATE
#define GET_MCB_STATUS(status)              (status & 0xF)
#define SET_MCB_STATUS(v, m)                (v = (v & ~0xF) | m)
 
enum ModuleMgrMcbStatus {
    MCB_STATUS_NOT_LOADED = 0,
    MCB_STATUS_LOADING = 1,
    MCB_STATUS_LOADED = 2,
    MCB_STATUS_RELOCATED = 3,
    MCB_STATUS_STARTING = 4,
    MCB_STATUS_STARTED = 5,
    MCB_STATUS_STOPPING = 6,
    MCB_STATUS_STOPPED = 7
};
 
typedef struct SceModule {
        struct SceModule *next; //0
        u16 attribute; //4
        u8 version[MODULE_VERSION_NUMBER_CATEGORY_SIZE]; //6
        char modName[SCE_MODULE_NAME_LEN]; //8
        char terminal; //35
        u16 status; //36
        u16 padding; //38
        SceUID secId; //40
        SceUID modId; //44
        SceUID userModThid; //48
        SceUID moduleBlockId; //52
        SceUID mpIdText; //56
        SceUID mpIdData; //60
        void *entTop; //64
        SceSize entSize; //68
        void *stubTop; //72
        SceSize stubSize; //76
        SceKernelThreadEntry moduleStart; //80
        SceKernelThreadEntry moduleStop; //84
        SceKernelThreadEntry moduleBootstart; //88
    SceKernelRebootBeforeForKernel moduleRebootBefore; //92
    SceKernelRebootPhaseForKernel moduleRebootPhase; //96
        u32 entryAddr; //100
        u32 gpValue; //104
        u32 textAddr; //108
        SceSize textSize; //112
        SceSize dataSize; //116
        SceSize bssSize; //120
        u8      nSegments; //124
        u8      padding2[3]; //125
        u32 segmentAddr[SCE_KERNEL_MAX_MODULE_SEGMENT]; //128
        SceSize segmentSize[SCE_KERNEL_MAX_MODULE_SEGMENT]; //144
    u32 segmentAlign[SCE_KERNEL_MAX_MODULE_SEGMENT]; //160
        s32 moduleStartThreadPriority; //176
        SceSize moduleStartThreadStacksize; //180
        SceUInt moduleStartThreadAttr; //184
        s32 moduleStopThreadPriority; //188
        SceSize moduleStopThreadStacksize; //192
        SceUInt moduleStopThreadAttr; //196
        s32 moduleRebootBeforeThreadPriority; //200
        SceSize moduleRebootBeforeThreadStacksize; //204
        SceUInt moduleRebootBeforeThreadAttr; //208
        u32 countRegVal; //212
    u32 segmentChecksum; //216
    u32 textSegmentChecksum; //220
    u32 computeTextSegmentChecksum; //224
} SceModule; //size = 228
 
typedef struct SceSyscallTable {
    struct SceSyscallTable *next;
    s32 seed;
    s32 funcTableSize;
    s32 tableSize;
    void (*syscalls[])();
} SceSyscallTable;
 
typedef struct {
    SceResidentLibrary *registeredLibs[LOADCORE_LIB_HASH_TABLE_SIZE]; //0
    SceSyscallTable *sysCallTable; //512
    u32 sysCallTableSeed; //516
    u32 unk520;
    SceModule *registeredMods; //524
    SceModule *lastRegMod; //528
    u32 regModCount; //532
    u32 secModId; //536
    SceStubLibrary *unLinkedStubLibs; //540
    SceUID loadCoreHeapId; //548
    u32 linkedLoadCoreStubs;
    SceBootCallback *bootCallBacks; //556
} SceLoadCore;
 
 
s32 sceKernelRegisterLibrary(SceResidentLibraryEntryTable *libEntryTable);
 
s32 sceKernelCanReleaseLibrary(SceResidentLibraryEntryTable *libEntryTable);
 
s32 sceKernelLinkLibraryEntries(SceStubLibraryEntryTable *libStubTable, u32 size);
 
s32 sceKernelUnlinkLibraryEntries(SceStubLibraryEntryTable *libStubTable, u32 size);
 
s32 sceKernelLoadModuleBootLoadCore(SceLoadCoreBootModuleInfo *bootModInfo, SceLoadCoreExecFileInfo *execInfo, 
                                    SceUID *modMemId);
 
s32 sceKernelLoadCoreLock(void);
 
void sceKernelLoadCoreUnlock(s32 intrState);
 
s32 sceKernelRegisterLibraryForUser(SceResidentLibraryEntryTable *libEntryTable);
 
s32 sceKernelReleaseLibrary(SceResidentLibraryEntryTable *libEntryTable);
 
s32 sceKernelLinkLibraryEntriesForUser(SceStubLibraryEntryTable *libStubTable, u32 size);
 
s32 sceKernelLinkLibraryEntriesWithModule(SceModule *mod, SceStubLibraryEntryTable *libStubTable, u32 size);
 
u32 sceKernelMaskLibraryEntries(void);
 
SceLoadCore *sceKernelQueryLoadCoreCB(void);
 
s32 sceKernelSetBootCallbackLevel(SceKernelBootCallbackFunction bootCBFunc, u32 flag, s32 *status);
 
u32 sceKernelLoadCoreMode(void);
 
s32 sceKernelCheckPspConfig(u8 *file, u32 size);
 
s32 sceKernelLoadRebootBin(u8 *file, u32 size);
 
s32 sceKernelSegmentChecksum(SceModule *mod);
 
s32 sceKernelCheckExecFile(u8 *buf, SceLoadCoreExecFileInfo *execInfo);
 
s32 sceKernelProbeExecutableObject(u8 *buf, SceLoadCoreExecFileInfo *execInfo);
 
s32 sceKernelLoadExecutableObject(u8 *buf, SceLoadCoreExecFileInfo *execInfo);
 
SceModule *sceKernelCreateModule(void);
 
s32 sceKernelAssignModule(SceModule *mod, SceLoadCoreExecFileInfo *execFileInfo);
 
s32 sceKernelReleaseModule(SceModule *mod);
 
s32 sceKernelGetModuleIdListForKernel(SceUID *modIdList, u32 size, u32 *modCount, u32 userModsOnly);
 
SceModule *sceKernelGetModuleFromUID(SceUID uid);
 
s32 sceKernelDeleteModule(SceModule *mod);
 
SceModule *sceKernelCreateAssignModule(SceLoadCoreExecFileInfo *execFileInfo);
 
s32 sceKernelRegisterModule(SceModule *mod);
 
SceModule *sceKernelFindModuleByName(const char *name);
 
SceModule *sceKernelFindModuleByAddress(u32 addr);
 
s32 sceKernelGetModuleGPByAddressForKernel(u32 addr);
 
SceModule *sceKernelFindModuleByUID(SceUID uid);
 
SceUID sceKernelGetModuleListWithAlloc(u32 *modCount);
 
#endif