Initial commit

CMakeLists.txt

@@ -0,0 +1,40 @@
+cmake_minimum_required(VERSION 2.8)
+
+if(NOT DEFINED CMAKE_TOOLCHAIN_FILE)
+ if(DEFINED ENV{VITASDK})
+ set(CMAKE_TOOLCHAIN_FILE "$ENV{VITASDK}/share/vita.toolchain.cmake" CACHE PATH "toolchain file")
+ else()
+ message(FATAL_ERROR "Please define VITASDK to point to your SDK path!")
+ endif()
+endif()
+
+project(kubridge)
+include("${VITASDK}/share/vita.cmake" REQUIRED)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-q -Wall -O3 -nostdlib")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -fno-exceptions")
+
+add_executable(kubridge
+ main.c
+)
+
+target_link_libraries(kubridge
+ taihenForKernel_stub
+ taihenModuleUtils_stub
+ SceSysclibForDriver_stub
+ SceSysmemForDriver_stub
+ SceThreadmgrForDriver_stub
+)
+
+vita_create_self(kubridge.skprx kubridge CONFIG exports.yml UNSAFE)
+
+vita_create_stubs(stubs kubridge ${CMAKE_SOURCE_DIR}/exports.yml KERNEL)
+
+install(DIRECTORY ${CMAKE_BINARY_DIR}/stubs/
+ DESTINATION lib
+ FILES_MATCHING PATTERN "*.a"
+)
+
+install(FILES kubridge.h
+ DESTINATION include
+)

exports.yml

@@ -0,0 +1,15 @@
+kubridge:
+ attributes: 0
+ version:
+ major: 1
+ minor: 0
+ main:
+ start: module_start
+ stop: module_stop
+ modules:
+ kubridge:
+ syscall: true
+ functions:
+ - kuKernelAllocMemBlock
+ - kuKernelFlushCaches
+ - kuKernelCpuUnrestrictedMemcpy

kubridge.h

@@ -0,0 +1,59 @@
+#ifndef __KUBRDIGE_H__
+#define __KUBRDIGE_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <psp2/types.h>
+#include <psp2/kernel/sysmem.h>
+
+typedef struct SceKernelAddrPair {
+ uint32_t addr; //!< Address
+ uint32_t length; //!< Length
+} SceKernelAddrPair;
+
+typedef struct SceKernelPaddrList {
+ uint32_t size; //!< sizeof(SceKernelPaddrList)
+ uint32_t list_size; //!< Size in elements of the list array
+ uint32_t ret_length; //!< Total physical size of the memory pairs
+ uint32_t ret_count; //!< Number of elements of list filled by ksceKernelGetPaddrList
+ SceKernelAddrPair *list; //!< Array of physical addresses and their lengths pairs
+} SceKernelPaddrList;
+
+typedef struct SceKernelAllocMemBlockKernelOpt {
+ SceSize size; //!< sizeof(SceKernelAllocMemBlockKernelOpt)
+ SceUInt32 field_4;
+ SceUInt32 attr; //!< OR of SceKernelAllocMemBlockAttr
+ SceUInt32 field_C;
+ SceUInt32 paddr;
+ SceSize alignment;
+ SceUInt32 extraLow;
+ SceUInt32 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;
+
+SceUID kuKernelAllocMemBlock(const char *name, SceKernelMemBlockType type, SceSize size, SceKernelAllocMemBlockKernelOpt *opt);
+
+void kuKernelFlushCaches(const void *ptr, SceSize len);
+
+int kuKernelCpuUnrestrictedMemcpy(void *dst, const void *src, SceSize len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

main.c

@@ -0,0 +1,84 @@
+#include <psp2kern/kernel/cpu.h>
+#include <psp2kern/kernel/modulemgr.h>
+#include <psp2kern/kernel/sysmem.h>
+#include <psp2kern/kernel/threadmgr.h>
+#include <taihen.h>
+
+int module_get_export_func(SceUID pid, const char *modname, uint32_t libnid, uint32_t funcnid, uintptr_t *func);
+
+void (* _ksceKernelCpuDcacheWritebackInvalidateRange)(const void *ptr, SceSize len);
+void (* _ksceKernelCpuIcacheInvalidateRange)(const void *ptr, SceSize len);
+void (* _ksceKernelCpuIcacheAndL2WritebackInvalidateRange)(const void *ptr, SceSize len);
+
+void kuKernelFlushCaches(const void *ptr, SceSize len) {
+ uintptr_t ptr_aligned;
+ ptr_aligned = (uintptr_t)ptr & ~0x1F;
+ len = (((uintptr_t)ptr + len + 0x1F) & ~0x1F) - ptr_aligned;
+ _ksceKernelCpuDcacheWritebackInvalidateRange((void *)ptr_aligned, len);
+ // _ksceKernelCpuIcacheAndL2WritebackInvalidateRange((void *)ptr_aligned, len);
+ _ksceKernelCpuIcacheInvalidateRange((void *)ptr_aligned, len);
+}
+
+SceUID kuKernelAllocMemBlock(const char *name, SceKernelMemBlockType type, SceSize size, SceKernelAllocMemBlockKernelOpt *opt) {
+ char k_name[32];
+ SceKernelAllocMemBlockKernelOpt k_opt;
+ uint32_t state;
+ int res;
+
+ ENTER_SYSCALL(state);
+
+ res = ksceKernelStrncpyUserToKernel(k_name, (uintptr_t)name, sizeof(k_name));
+ if (res < 0)
+ goto error;
+
+ res = ksceKernelMemcpyUserToKernel(&k_opt, (uintptr_t)opt, sizeof(k_opt));
+ if (res < 0)
+ goto error;
+
+ res = ksceKernelAllocMemBlock(k_name, type, size, &k_opt);
+ if (res < 0)
+ goto error;
+
+ res = ksceKernelCreateUserUid(ksceKernelGetProcessId(), res);
+
+error:
+ EXIT_SYSCALL(state);
+ return res;
+}
+
+int kuKernelCpuUnrestrictedMemcpy(void *dst, const void *src, SceSize len) {
+ int prev_dacr;
+
+ asm volatile("mrc p15, 0, %0, c3, c0, 0" : "=r" (prev_dacr));
+ asm volatile("mcr p15, 0, %0, c3, c0, 0" :: "r" (0x15450FC3));
+
+ for (int i = 0; i < len; i++) {
+ uint32_t val;
+ __asm__ volatile ("ldrbt %0, [%1]" : "=r" (val) : "r" (src + i));
+ __asm__ volatile ("strbt %0, [%1]" :: "r" (val), "r" (dst + i));
+ }
+
+ asm volatile("mcr p15, 0, %0, c3, c0, 0" :: "r" (prev_dacr));
+ return 0;
+}
+
+void _start() __attribute__ ((weak, alias("module_start")));
+int module_start(SceSize args, void *argp) {
+ int res;
+
+ res = module_get_export_func(KERNEL_PID, "SceSysmem", TAI_ANY_LIBRARY, 0x6BA2E51C, (uintptr_t *)&_ksceKernelCpuDcacheWritebackInvalidateRange);
+ if (res < 0)
+ module_get_export_func(KERNEL_PID, "SceSysmem", TAI_ANY_LIBRARY, 0x4F442396, (uintptr_t *)&_ksceKernelCpuDcacheWritebackInvalidateRange);
+ res = module_get_export_func(KERNEL_PID, "SceSysmem", TAI_ANY_LIBRARY, 0xF4C7F578, (uintptr_t *)&_ksceKernelCpuIcacheInvalidateRange);
+ if (res < 0)
+ module_get_export_func(KERNEL_PID, "SceSysmem", TAI_ANY_LIBRARY, 0x2E637B1D, (uintptr_t *)&_ksceKernelCpuIcacheInvalidateRange);
+ res = module_get_export_func(KERNEL_PID, "SceSysmem", TAI_ANY_LIBRARY, 0x19F17BD0, (uintptr_t *)&_ksceKernelCpuIcacheAndL2WritebackInvalidateRange);
+ if (res < 0)
+ module_get_export_func(KERNEL_PID, "SceSysmem", TAI_ANY_LIBRARY, 0x73E895EA, (uintptr_t *)&_ksceKernelCpuIcacheAndL2WritebackInvalidateRange);
+
+ return SCE_KERNEL_START_SUCCESS;
+}
+
+int module_stop(SceSize args, void *argp) {
+ return SCE_KERNEL_STOP_SUCCESS;
+}