From 469926c5e1c44f8dc40d76f6f58b8c544f976152 Mon Sep 17 00:00:00 2001 From: Nekotekina Date: Sat, 14 Mar 2015 23:28:59 +0300 Subject: [PATCH] _sys_heap*, _sys_malloc+, _sys_strcmp implemented --- rpcs3/Emu/SysCalls/Modules/cellFs.cpp | 2 +- rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp | 168 ++++++++++++------- rpcs3/Emu/SysCalls/Modules/sysPrxForUser.h | 20 +-- 3 files changed, 117 insertions(+), 73 deletions(-) diff --git a/rpcs3/Emu/SysCalls/Modules/cellFs.cpp b/rpcs3/Emu/SysCalls/Modules/cellFs.cpp index 9bbb275ea6..ab5c8ad85c 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellFs.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellFs.cpp @@ -665,7 +665,7 @@ void fsAio(vm::ptr aio, bool write, s32 xid, fs_aio_cb_t func) } // should be executed directly by FS AIO thread - Emu.GetCallbackManager().Async([func, aio, error, xid, result](PPUThread& CPU) + Emu.GetCallbackManager().Async([=](PPUThread& CPU) { func(CPU, aio, error, xid, result); }); diff --git a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp index 9f31519d78..34844ec5e5 100644 --- a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp +++ b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp @@ -766,34 +766,45 @@ std::string ps3_fmt(PPUThread& context, vm::ptr fmt, u32 g_count, u3 return result; } -int _sys_heap_create_heap(const u32 heap_addr, const u32 align, const u32 size) +u32 _sys_heap_create_heap(vm::ptr name, u32 arg2, u32 arg3, u32 arg4) { - sysPrxForUser.Warning("_sys_heap_create_heap(heap_addr=0x%x, align=0x%x, size=0x%x)", heap_addr, align, size); + sysPrxForUser.Warning("_sys_heap_create_heap(name=*0x%x, arg2=0x%x, arg3=0x%x, arg4=0x%x)", name, arg2, arg3, arg4); - std::shared_ptr heap(new HeapInfo(heap_addr, align, size)); - u32 heap_id = Emu.GetIdManager().GetNewID(heap); - sysPrxForUser.Warning("*** sys_heap created: id = %d", heap_id); - return heap_id; + std::shared_ptr heap(new HeapInfo(name.get_ptr())); + + return Emu.GetIdManager().GetNewID(heap); } -u32 _sys_heap_malloc(const u32 heap_id, const u32 size) +s32 _sys_heap_delete_heap(u32 heap) { - sysPrxForUser.Warning("_sys_heap_malloc(heap_id=%d, size=0x%x)", heap_id, size); + sysPrxForUser.Warning("_sys_heap_delete_heap(heap=0x%x)", heap); - std::shared_ptr heap; - if(!Emu.GetIdManager().GetIDData(heap_id, heap)) return CELL_ESRCH; + Emu.GetIdManager().RemoveID(heap); - return (u32)Memory.Alloc(size, 1); + return CELL_OK; } -u32 _sys_heap_memalign(u32 heap_id, u32 align, u32 size) +u32 _sys_heap_malloc(u32 heap, u32 size) { - sysPrxForUser.Warning("_sys_heap_memalign(heap_id=%d, align=0x%x, size=0x%x)", heap_id, align, size); + sysPrxForUser.Warning("_sys_heap_malloc(heap=0x%x, size=0x%x)", heap, size); - std::shared_ptr heap; - if(!Emu.GetIdManager().GetIDData(heap_id, heap)) return CELL_ESRCH; + return Memory.MainMem.AllocAlign(size, 1); +} - return (u32)Memory.Alloc(size, align); +u32 _sys_heap_memalign(u32 heap, u32 align, u32 size) +{ + sysPrxForUser.Warning("_sys_heap_memalign(heap=0x%x, align=0x%x, size=0x%x)", heap, align, size); + + return Memory.MainMem.AllocAlign(size, align); +} + +s32 _sys_heap_free(u32 heap, u32 addr) +{ + sysPrxForUser.Warning("_sys_heap_free(heap=0x%x, addr=0x%x)", heap, addr); + + Memory.MainMem.Free(addr); + + return CELL_OK; } s64 _sys_process_atexitspawn() @@ -815,7 +826,7 @@ s32 sys_interrupt_thread_disestablish(PPUThread& CPU, u32 ih) return _sys_interrupt_thread_disestablish(ih, vm::stackvar>(CPU)); } -int sys_process_is_stack(u32 p) +s32 sys_process_is_stack(u32 p) { sysPrxForUser.Log("sys_process_is_stack(p=0x%x)", p); @@ -829,35 +840,36 @@ s64 sys_prx_exitspawn_with_level() return CELL_OK; } -int sys_spu_elf_get_information(u32 elf_img, vm::ptr entry, vm::ptr nseg) +s32 sys_spu_elf_get_information(u32 elf_img, vm::ptr entry, vm::ptr nseg) { sysPrxForUser.Todo("sys_spu_elf_get_information(elf_img=0x%x, entry_addr=0x%x, nseg_addr=0x%x)", elf_img, entry.addr(), nseg.addr()); return CELL_OK; } -int sys_spu_elf_get_segments(u32 elf_img, vm::ptr segments, int nseg) +s32 sys_spu_elf_get_segments(u32 elf_img, vm::ptr segments, s32 nseg) { sysPrxForUser.Todo("sys_spu_elf_get_segments(elf_img=0x%x, segments_addr=0x%x, nseg=0x%x)", elf_img, segments.addr(), nseg); return CELL_OK; } -int sys_spu_image_import(vm::ptr img, u32 src, u32 type) +s32 sys_spu_image_import(vm::ptr img, u32 src, u32 type) { - sysPrxForUser.Warning("sys_spu_image_import(img=0x%x, src=0x%x, type=%d)", img.addr(), src, type); + sysPrxForUser.Warning("sys_spu_image_import(img=*0x%x, src=0x%x, type=%d)", img, src, type); return spu_image_import(*img, src, type); } -int sys_spu_image_close(vm::ptr img) +s32 sys_spu_image_close(vm::ptr img) { - sysPrxForUser.Warning("sys_spu_image_close(img=0x%x)", img.addr()); + sysPrxForUser.Todo("sys_spu_image_close(img=*0x%x)", img); + return CELL_OK; } -int sys_raw_spu_load(s32 id, vm::ptr path, vm::ptr entry) +s32 sys_raw_spu_load(s32 id, vm::ptr path, vm::ptr entry) { - sysPrxForUser.Warning("sys_raw_spu_load(id=0x%x, path_addr=0x%x('%s'), entry_addr=0x%x)", - id, path.addr(), path.get_ptr(), entry.addr()); + sysPrxForUser.Warning("sys_raw_spu_load(id=%d, path=*0x%x, entry=*0x%x)", id, path, entry); + sysPrxForUser.Warning("*** path = '%s'", path.get_ptr()); vfsFile f(path.get_ptr()); if(!f.IsOpened()) @@ -886,9 +898,9 @@ int sys_raw_spu_load(s32 id, vm::ptr path, vm::ptr entry) return CELL_OK; } -int sys_raw_spu_image_load(int id, vm::ptr img) +s32 sys_raw_spu_image_load(s32 id, vm::ptr img) { - sysPrxForUser.Warning("sys_raw_spu_image_load(id=0x%x, img_addr=0x%x)", id, img.addr()); + sysPrxForUser.Warning("sys_raw_spu_image_load(id=%d, img=*0x%x)", id, img); // TODO: use segment info memcpy(vm::get_ptr(RAW_SPU_BASE_ADDR + RAW_SPU_OFFSET * id), vm::get_ptr(img->addr), 256 * 1024); @@ -897,9 +909,9 @@ int sys_raw_spu_image_load(int id, vm::ptr img) return CELL_OK; } -int sys_get_random_number(vm::ptr addr, u64 size) +s32 sys_get_random_number(vm::ptr addr, u64 size) { - sysPrxForUser.Warning("sys_get_random_number(addr=0x%x, size=%d)", addr.addr(), size); + sysPrxForUser.Warning("sys_get_random_number(addr=*0x%x, size=%d)", addr, size); if (size > 4096) size = 4096; @@ -914,77 +926,89 @@ int sys_get_random_number(vm::ptr addr, u64 size) vm::ptr _sys_memset(vm::ptr dst, s32 value, u32 size) { - sysPrxForUser.Log("_sys_memset(dst_addr=0x%x, value=%d, size=%d)", dst.addr(), value, size); + sysPrxForUser.Log("_sys_memset(dst=*0x%x, value=%d, size=0x%x)", dst, value, size); memset(dst.get_ptr(), value, size); + return dst; } vm::ptr _sys_memcpy(vm::ptr dst, vm::ptr src, u32 size) { - sysPrxForUser.Log("_sys_memcpy(dst_addr=0x%x, src_addr=0x%x, size=%d)", dst.addr(), src.addr(), size); + sysPrxForUser.Log("_sys_memcpy(dst=*0x%x, src=*0x%x, size=0x%x)", dst, src, size); memcpy(dst.get_ptr(), src.get_ptr(), size); + return dst; } s32 _sys_memcmp(vm::ptr buf1, vm::ptr buf2, u32 size) { - sysPrxForUser.Log("_sys_memcmp(buf1_addr=0x%x, buf2_addr=0x%x, size=%d)", buf1.addr(), buf2.addr(), size); + sysPrxForUser.Log("_sys_memcmp(buf1=*0x%x, buf2=*0x%x, size=%d)", buf1, buf2, size); return memcmp(buf1.get_ptr(), buf2.get_ptr(), size); } s64 _sys_strlen(vm::ptr str) { - sysPrxForUser.Log("_sys_strlen(str_addr=0x%x)", str.addr()); + sysPrxForUser.Log("_sys_strlen(str=*0x%x)", str); return strlen(str.get_ptr()); } +s32 _sys_strcmp(vm::ptr str1, vm::ptr str2) +{ + sysPrxForUser.Log("_sys_strcmp(str1=*0x%x, str2=*0x%x)", str1, str2); + + return strcmp(str1.get_ptr(), str2.get_ptr()); +} + s32 _sys_strncmp(vm::ptr str1, vm::ptr str2, s32 max) { - sysPrxForUser.Log("_sys_strncmp(str1_addr=0x%x, str2_addr=0x%x, max=%d)", str1.addr(), str2.addr(), max); + sysPrxForUser.Log("_sys_strncmp(str1=*0x%x, str2=*0x%x, max=%d)", str1, str2, max); return strncmp(str1.get_ptr(), str2.get_ptr(), max); } vm::ptr _sys_strcat(vm::ptr dest, vm::ptr source) { - sysPrxForUser.Log("_sys_strcat(dest_addr=0x%x, source_addr=0x%x)", dest.addr(), source.addr()); + sysPrxForUser.Log("_sys_strcat(dest=*0x%x, source=*0x%x)", dest, source); if (strcat(dest.get_ptr(), source.get_ptr()) != dest.get_ptr()) { - assert(!"strcat(): unexpected result"); + throw "_sys_strcat() failed: unexpected strcat() result"; } + return dest; } vm::ptr _sys_strncat(vm::ptr dest, vm::ptr source, u32 len) { - sysPrxForUser.Log("_sys_strncat(dest_addr=0x%x, source_addr=0x%x, len=%d)", dest.addr(), source.addr(), len); + sysPrxForUser.Log("_sys_strncat(dest=*0x%x, source=*0x%x, len=%d)", dest, source, len); if (strncat(dest.get_ptr(), source.get_ptr(), len) != dest.get_ptr()) { - assert(!"strncat(): unexpected result"); + throw "_sys_strncat() failed: unexpected strncat() result"; } + return dest; } vm::ptr _sys_strcpy(vm::ptr dest, vm::ptr source) { - sysPrxForUser.Log("_sys_strcpy(dest_addr=0x%x, source_addr=0x%x)", dest.addr(), source.addr()); + sysPrxForUser.Log("_sys_strcpy(dest=*0x%x, source=*0x%x)", dest, source); if (strcpy(dest.get_ptr(), source.get_ptr()) != dest.get_ptr()) { - assert(!"strcpy(): unexpected result"); + throw "_sys_strcpy() failed: unexpected strcpy() result"; } + return dest; } vm::ptr _sys_strncpy(vm::ptr dest, vm::ptr source, u32 len) { - sysPrxForUser.Log("_sys_strncpy(dest_addr=0x%x, source_addr=0x%x, len=%d)", dest.addr(), source.addr(), len); + sysPrxForUser.Log("_sys_strncpy(dest=*0x%x, source=*0x%x, len=%d)", dest, source, len); if (!dest || !source) { @@ -993,24 +1017,20 @@ vm::ptr _sys_strncpy(vm::ptr dest, vm::ptr source, u32 l if (strncpy(dest.get_ptr(), source.get_ptr(), len) != dest.get_ptr()) { - assert(!"strncpy(): unexpected result"); + throw "_sys_strncpy() failed: unexpected strncpy() result"; } + return dest; } -vm::ptr spu_printf_agcb; -vm::ptr spu_printf_dgcb; -vm::ptr spu_printf_atcb; -vm::ptr spu_printf_dtcb; +spu_printf_cb_t spu_printf_agcb; +spu_printf_cb_t spu_printf_dgcb; +spu_printf_cb_t spu_printf_atcb; +spu_printf_cb_t spu_printf_dtcb; -s32 _sys_spu_printf_initialize( - vm::ptr agcb, - vm::ptr dgcb, - vm::ptr atcb, - vm::ptr dtcb) +s32 _sys_spu_printf_initialize(spu_printf_cb_t agcb, spu_printf_cb_t dgcb, spu_printf_cb_t atcb, spu_printf_cb_t dtcb) { - sysPrxForUser.Warning("_sys_spu_printf_initialize(agcb_addr=0x%x, dgcb_addr=0x%x, atcb_addr=0x%x, dtcb_addr=0x%x)", - agcb.addr(), dgcb.addr(), atcb.addr(), dtcb.addr()); + sysPrxForUser.Warning("_sys_spu_printf_initialize(agcb=*0x%x, dgcb=*0x%x, atcb=*0x%x, dtcb=*0x%x)", agcb, dgcb, atcb, dtcb); // prx: register some callbacks spu_printf_agcb = agcb; @@ -1079,9 +1099,32 @@ s32 _sys_spu_printf_detach_thread(PPUThread& CPU, u32 thread) return spu_printf_dtcb(CPU, thread); } +u32 _sys_malloc(u32 size) +{ + sysPrxForUser.Warning("_sys_malloc(size=0x%x)", size); + + return Memory.MainMem.AllocAlign(size, 1); +} + +u32 _sys_memalign(u32 align, u32 size) +{ + sysPrxForUser.Warning("_sys_memalign(align=0x%x, size=0x%x)", align, size); + + return Memory.MainMem.AllocAlign(size, align); +} + +s32 _sys_free(u32 addr) +{ + sysPrxForUser.Warning("_sys_free(addr=0x%x)", addr); + + Memory.MainMem.Free(addr); + + return CELL_OK; +} + s32 _sys_snprintf(PPUThread& CPU, vm::ptr dst, u32 count, vm::ptr fmt) // va_args... { - sysPrxForUser.Warning("_sys_snprintf(dst=0x%x, count=%d, fmt=0x%x, ...)", dst, count, fmt); + sysPrxForUser.Warning("_sys_snprintf(dst=*0x%x, count=%d, fmt=*0x%x, ...)", dst, count, fmt); std::string result = ps3_fmt(CPU, fmt, 3, 0, 0); @@ -1103,7 +1146,7 @@ s32 _sys_snprintf(PPUThread& CPU, vm::ptr dst, u32 count, vm::ptr fmt) // va_args... { - sysPrxForUser.Todo("_sys_printf(fmt_addr=0x%x, ...)", fmt.addr()); + sysPrxForUser.Todo("_sys_printf(fmt=*0x%x, ...)", fmt); // probably, assertion failed sysPrxForUser.Warning("_sys_printf: \n%s", fmt.get_ptr()); @@ -1113,7 +1156,7 @@ s32 _sys_printf(vm::ptr fmt) // va_args... s32 sys_process_get_paramsfo(vm::ptr buffer) { - sysPrxForUser.Warning("sys_process_get_paramsfo(buffer=0x%x)", buffer); + sysPrxForUser.Warning("sys_process_get_paramsfo(buffer=*0x%x)", buffer); // prx: load some data (0x40 bytes) previously set by _sys_process_get_paramsfo syscall return _sys_process_get_paramsfo(buffer); @@ -1224,11 +1267,11 @@ Module sysPrxForUser("sysPrxForUser", []() REG_FUNC(sysPrxForUser, sys_prx_load_module_on_memcontainer); REG_FUNC(sysPrxForUser, sys_prx_exitspawn_with_level); - REG_FUNC(sysPrxForUser, _sys_heap_malloc); - //REG_FUNC(sysPrxForUser, _sys_heap_free); - //REG_FUNC(sysPrxForUser, _sys_heap_delete_heap); REG_FUNC(sysPrxForUser, _sys_heap_create_heap); + REG_FUNC(sysPrxForUser, _sys_heap_delete_heap); + REG_FUNC(sysPrxForUser, _sys_heap_malloc); REG_FUNC(sysPrxForUser, _sys_heap_memalign); + REG_FUNC(sysPrxForUser, _sys_heap_free); REG_FUNC(sysPrxForUser, sys_mmapper_allocate_memory); REG_FUNC(sysPrxForUser, sys_mmapper_allocate_memory_from_container); @@ -1258,6 +1301,7 @@ Module sysPrxForUser("sysPrxForUser", []() REG_FUNC(sysPrxForUser, _sys_memcpy); REG_FUNC(sysPrxForUser, _sys_memcmp); REG_FUNC(sysPrxForUser, _sys_strlen); + REG_FUNC(sysPrxForUser, _sys_strcmp); REG_FUNC(sysPrxForUser, _sys_strncmp); REG_FUNC(sysPrxForUser, _sys_strcat); REG_FUNC(sysPrxForUser, _sys_strncat); @@ -1271,6 +1315,10 @@ Module sysPrxForUser("sysPrxForUser", []() REG_FUNC(sysPrxForUser, _sys_spu_printf_attach_thread); REG_FUNC(sysPrxForUser, _sys_spu_printf_detach_thread); + REG_FUNC(sysPrxForUser, _sys_malloc); + REG_FUNC(sysPrxForUser, _sys_memalign); + REG_FUNC(sysPrxForUser, _sys_free); + REG_FUNC(sysPrxForUser, _sys_snprintf); REG_FUNC(sysPrxForUser, _sys_printf); diff --git a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.h b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.h index 19e166545c..41aa474d9f 100644 --- a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.h +++ b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.h @@ -2,25 +2,21 @@ struct HeapInfo { - u32 heap_addr; - u32 align; - u32 size; + const std::string name; - HeapInfo(u32 _heap_addr, u32 _align, u32 _size) - : heap_addr(_heap_addr) - , align(_align) - , size(_size) + HeapInfo(const char* name) + : name(name) { } }; -typedef s32(spu_printf_cb_t)(u32 arg); +using spu_printf_cb_t = vm::ptr; // Aux -extern vm::ptr spu_printf_agcb; -extern vm::ptr spu_printf_dgcb; -extern vm::ptr spu_printf_atcb; -extern vm::ptr spu_printf_dtcb; +extern spu_printf_cb_t spu_printf_agcb; +extern spu_printf_cb_t spu_printf_dgcb; +extern spu_printf_cb_t spu_printf_atcb; +extern spu_printf_cb_t spu_printf_dtcb; // Functions vm::ptr _sys_memset(vm::ptr dst, s32 value, u32 size);