From 3ce72f87d35b68750d19f29be3d804f840ed9740 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Mon, 27 Jan 2025 01:40:02 +0100 Subject: [PATCH] Another batch of log cleanup --- Core/HLE/sceCtrl.cpp | 17 +++---- Core/HLE/sceIo.cpp | 69 +++++++++++---------------- Core/HLE/sceKernel.cpp | 12 +++-- Core/HLE/sceKernelInterrupt.cpp | 1 + Core/HLE/sceKernelModule.cpp | 2 +- Core/HLE/sceKernelSemaphore.cpp | 3 +- Core/HLE/sceKernelTime.cpp | 32 ++++++------- Core/HLE/scePower.cpp | 59 +++++++++--------------- Core/HLE/sceRtc.cpp | 7 ++- Core/HLE/sceUmd.cpp | 82 +++++++++++++-------------------- 10 files changed, 116 insertions(+), 168 deletions(-) diff --git a/Core/HLE/sceCtrl.cpp b/Core/HLE/sceCtrl.cpp index a38981c04d..ef387ea43d 100644 --- a/Core/HLE/sceCtrl.cpp +++ b/Core/HLE/sceCtrl.cpp @@ -503,32 +503,27 @@ static int sceCtrlReadBufferPositive(u32 ctrlDataPtr, u32 nBufs) int done = __CtrlReadBuffer(ctrlDataPtr, nBufs, false, false); hleEatCycles(330); if (done != 0) { - DEBUG_LOG(Log::sceCtrl, "%d=sceCtrlReadBufferPositive(%08x, %i)", done, ctrlDataPtr, nBufs); - } - else - { + return hleLogDebug(Log::sceCtrl, done); + } else { waitingThreads.push_back(__KernelGetCurThread()); __KernelWaitCurThread(WAITTYPE_CTRL, CTRL_WAIT_POSITIVE, ctrlDataPtr, 0, false, "ctrl buffer waited"); - DEBUG_LOG(Log::sceCtrl, "sceCtrlReadBufferPositive(%08x, %i) - waiting", ctrlDataPtr, nBufs); + return hleLogDebug(Log::sceCtrl, done, "waiting"); } - return done; } static int sceCtrlReadBufferNegative(u32 ctrlDataPtr, u32 nBufs) { int done = __CtrlReadBuffer(ctrlDataPtr, nBufs, true, false); hleEatCycles(330); - if (done != 0) - { - DEBUG_LOG(Log::sceCtrl, "%d=sceCtrlReadBufferNegative(%08x, %i)", done, ctrlDataPtr, nBufs); + if (done != 0) { + return hleLogDebug(Log::sceCtrl, done); } else { waitingThreads.push_back(__KernelGetCurThread()); __KernelWaitCurThread(WAITTYPE_CTRL, CTRL_WAIT_NEGATIVE, ctrlDataPtr, 0, false, "ctrl buffer waited"); - DEBUG_LOG(Log::sceCtrl, "sceCtrlReadBufferNegative(%08x, %i) - waiting", ctrlDataPtr, nBufs); + return hleLogDebug(Log::sceCtrl, done, "waiting"); } - return done; } static int sceCtrlPeekBufferPositive(u32 ctrlDataPtr, u32 nBufs) diff --git a/Core/HLE/sceIo.cpp b/Core/HLE/sceIo.cpp index 3a8e9b9a45..c5ca4e8a26 100644 --- a/Core/HLE/sceIo.cpp +++ b/Core/HLE/sceIo.cpp @@ -1129,14 +1129,16 @@ static bool __IoRead(int &result, int id, u32 data_addr, int size, int &us) { static u32 sceIoRead(int id, u32 data_addr, int size) { u32 error; FileNode *f = __IoGetFd(id, error); - if (id > 2 && f != NULL) { + if (!f) { + return hleLogError(Log::sceIo, error, "bad file descriptor"); + } + + if (id > 2) { if (!__KernelIsDispatchEnabled()) { - DEBUG_LOG(Log::sceIo, "sceIoRead(%d, %08x, %x): dispatch disabled", id, data_addr, size); - return SCE_KERNEL_ERROR_CAN_NOT_WAIT; + return hleLogError(Log::sceIo, SCE_KERNEL_ERROR_CAN_NOT_WAIT, "dispatch disabled"); } if (__IsInInterrupt()) { - DEBUG_LOG(Log::sceIo, "sceIoRead(%d, %08x, %x): inside interrupt", id, data_addr, size); - return SCE_KERNEL_ERROR_ILLEGAL_CONTEXT; + return hleLogError(Log::sceIo, SCE_KERNEL_ERROR_ILLEGAL_CONTEXT, "inside interrupt"); } } @@ -1144,12 +1146,10 @@ static u32 sceIoRead(int id, u32 data_addr, int size) { int us; bool complete = __IoRead(result, id, data_addr, size, us); if (!complete) { - DEBUG_LOG(Log::sceIo, "sceIoRead(%d, %08x, %x): deferring result", id, data_addr, size); - __IoSchedSync(f, id, us); __KernelWaitCurThread(WAITTYPE_IO, id, 0, 0, false, "io read"); f->waitingSyncThreads.push_back(__KernelGetCurThread()); - return 0; + return hleLogDebug(Log::sceIo, 0, "deferring result"); } else if (result >= 0) { return hleDelayResult(hleLogDebug(Log::ME, result), "io read", us); } else { @@ -1257,12 +1257,10 @@ static u32 sceIoWrite(int id, u32 data_addr, int size) { FileNode *f = __IoGetFd(id, error); if (id > 2 && f != NULL) { if (!__KernelIsDispatchEnabled()) { - DEBUG_LOG(Log::sceIo, "sceIoWrite(%d, %08x, %x): dispatch disabled", id, data_addr, size); - return SCE_KERNEL_ERROR_CAN_NOT_WAIT; + return hleLogError(Log::sceIo, SCE_KERNEL_ERROR_CAN_NOT_WAIT, "dispatch disabled"); } if (__IsInInterrupt()) { - DEBUG_LOG(Log::sceIo, "sceIoWrite(%d, %08x, %x): inside interrupt", id, data_addr, size); - return SCE_KERNEL_ERROR_ILLEGAL_CONTEXT; + return hleLogError(Log::sceIo, SCE_KERNEL_ERROR_ILLEGAL_CONTEXT, "inside interrupt"); } } @@ -1270,18 +1268,16 @@ static u32 sceIoWrite(int id, u32 data_addr, int size) { int us; bool complete = __IoWrite(result, id, data_addr, size, us); if (!complete) { - DEBUG_LOG(Log::sceIo, "sceIoWrite(%d, %08x, %x): deferring result", id, data_addr, size); - __IoSchedSync(f, id, us); __KernelWaitCurThread(WAITTYPE_IO, id, 0, 0, false, "io write"); f->waitingSyncThreads.push_back(__KernelGetCurThread()); - return 0; + return hleLogDebug(Log::sceIo, 0, "deferring result"); } else if (result >= 0) { if (__KernelIsDispatchEnabled()) { // If we wrote to stdout, return an error (even though we did log it) rather than delaying. // On actual hardware, it would just return this... we just want the log output. if (__IsInInterrupt()) { - return SCE_KERNEL_ERROR_ILLEGAL_CONTEXT; + return hleLogError(Log::sceIo, SCE_KERNEL_ERROR_ILLEGAL_CONTEXT); } return hleDelayResult(hleLogDebug(Log::sceIo, result), "io write", us); } else { @@ -1426,11 +1422,10 @@ static s64 __IoLseek(SceUID id, s64 offset, int whence) { static s64 sceIoLseek(int id, s64 offset, int whence) { s64 result = __IoLseek(id, offset, whence); if (result >= 0 || result == -1) { - DEBUG_LOG(Log::sceIo, "%lli = sceIoLseek(%d, %llx, %i)", result, id, offset, whence); // Educated guess at timing. hleEatCycles(1400); hleReSchedule("io seek"); - return result; + return hleLogDebug(Log::sceIo, result); } else { return hleLogError(Log::sceIo, result, "bad file descriptor"); } @@ -1439,11 +1434,10 @@ static s64 sceIoLseek(int id, s64 offset, int whence) { static u32 sceIoLseek32(int id, int offset, int whence) { s32 result = (s32) __IoLseek(id, offset, whence); if (result >= 0 || result == -1) { - DEBUG_LOG(Log::sceIo, "%i = sceIoLseek32(%d, %x, %i)", result, id, offset, whence); // Educated guess at timing. hleEatCycles(1400); hleReSchedule("io seek"); - return result; + return hleLogDebug(Log::sceIo, result); } else { return hleLogError(Log::sceIo, result, "bad file descriptor"); } @@ -1744,8 +1738,7 @@ static u32 sceIoDevctl(const char *name, int cmd, u32 argAddr, int argLen, u32 o case 0x01F100A6: case 0x01F100A8: case 0x01F100A9: - ERROR_LOG_REPORT(Log::sceIo, "UNIMPL sceIoDevctl(\"%s\", %08x, %08x, %i, %08x, %i)", name, cmd, argAddr, argLen, outPtr, outLen); - return 0; + return hleReportError(Log::sceIo, 0, "UNIMPL sceIoDevctl(\"%s\", %08x, %08x, %i, %08x, %i)", name, cmd, argAddr, argLen, outPtr, outLen); } // This should really send it on to a FileSystem implementation instead. @@ -1790,7 +1783,7 @@ static u32 sceIoDevctl(const char *name, int cmd, u32 argAddr, int argLen, u32 o } return hleNoLog(0); } else { - return SCE_KERNEL_ERROR_ERRNO_INVALID_ARGUMENT; + return hleLogError(Log::sceIo, SCE_KERNEL_ERROR_ERRNO_INVALID_ARGUMENT); } } else { return hleLogError(Log::sceIo, ERROR_MEMSTICK_DEVCTL_BAD_PARAMS); @@ -1811,8 +1804,7 @@ static u32 sceIoDevctl(const char *name, int cmd, u32 argAddr, int argLen, u32 o if (slot != (size_t)-1) { memStickCallbacks.erase(memStickCallbacks.begin() + slot); - DEBUG_LOG(Log::sceIo, "sceIoDevctl: Unregistered memstick callback %i", cbId); - return hleLogDebug(Log::sceIo, 0); + return hleLogDebug(Log::sceIo, 0, "sceIoDevctl: Unregistered memstick callback %i", cbId); } else { return hleLogError(Log::sceIo, SCE_KERNEL_ERROR_ERRNO_INVALID_ARGUMENT); } @@ -1855,7 +1847,7 @@ static u32 sceIoDevctl(const char *name, int cmd, u32 argAddr, int argLen, u32 o deviceSize.NotifyWrite("ms0:02425818"); } - return 0; + return hleLogDebug(Log::sceIo, 0); } else { return hleLogError(Log::sceIo, ERROR_MEMSTICK_DEVCTL_BAD_PARAMS); } @@ -1936,20 +1928,18 @@ static u32 sceIoDevctl(const char *name, int cmd, u32 argAddr, int argLen, u32 o MemoryStick_SetFatState((MemStickFatState)Memory::Read_U32(argAddr)); return hleLogDebug(Log::sceIo, 0); } else { - ERROR_LOG(Log::sceIo, "Failed 0x02415823 fat"); - return -1; + return hleLogError(Log::sceIo, -1, "Failed 0x02415823 fat"); } break; case 0x02425823: // Check if FAT enabled // If the values added together are >= 0x80000000, or less than outPtr, invalid address. if (((int)outPtr + outLen) < (int)outPtr) { - ERROR_LOG(Log::sceIo, "sceIoDevctl: fatms0: 0x02425823 command, bad address"); - return SCE_KERNEL_ERROR_ILLEGAL_ADDR; + return hleLogError(Log::sceIo, SCE_KERNEL_ERROR_ILLEGAL_ADDR, "sceIoDevctl: fatms0: 0x02425823 command, bad address"); } else if (!Memory::IsValidAddress(outPtr)) { // Technically, only checks for NULL, crashes for many bad addresses. - ERROR_LOG(Log::sceIo, "sceIoDevctl: fatms0: 0x02425823 command, no output address"); - return hleLogError(Log::sceIo, SCE_KERNEL_ERROR_ERRNO_INVALID_ARGUMENT); + ERROR_LOG(Log::sceIo, "sceIoDevctl: "); + return hleLogError(Log::sceIo, SCE_KERNEL_ERROR_ERRNO_INVALID_ARGUMENT, "fatms0: 0x02425823 command, no output address"); } else { // Does not care about outLen, even if it's 0. // Note: writes 1 when inserted, 0 when not inserted. @@ -1960,7 +1950,7 @@ static u32 sceIoDevctl(const char *name, int cmd, u32 argAddr, int argLen, u32 o case 0x02425824: // Check if write protected if (MemoryStick_State() != PSP_MEMORYSTICK_STATE_INSERTED) { - return SCE_KERNEL_ERROR_ERRNO_DEVICE_NOT_FOUND; + return hleLogError(Log::sceIo, SCE_KERNEL_ERROR_ERRNO_DEVICE_NOT_FOUND); } if (Memory::IsValidAddress(outPtr) && outLen == 4) { Memory::Write_U32(0, outPtr); @@ -2030,7 +2020,7 @@ static u32 sceIoDevctl(const char *name, int cmd, u32 argAddr, int argLen, u32 o if (PSP_CoreParameter().collectDebugOutput) *PSP_CoreParameter().collectDebugOutput += data; } - return 0; + return hleNoLog(0); case EMULATOR_DEVCTL__IS_EMULATOR: if (Memory::IsValidAddress(outPtr)) Memory::Write_U32(1, outPtr); @@ -2399,15 +2389,13 @@ public: }; static u32 sceIoDopen(const char *path) { - DEBUG_LOG(Log::sceIo, "sceIoDopen(\"%s\")", path); - double startTime = time_now_d(); bool listingExists = false; auto listing = pspFileSystem.GetDirListing(path, &listingExists); if (!listingExists) { - return SCE_KERNEL_ERROR_ERRNO_FILE_NOT_FOUND; + return hleLogError(Log::sceIo, SCE_KERNEL_ERROR_ERRNO_FILE_NOT_FOUND); } DirListing *dir = new DirListing(); @@ -2464,7 +2452,7 @@ static u32 sceIoDopen(const char *path) { } // TODO: The result is delayed only from the memstick, it seems. - return id; + return hleLogDebug(Log::sceIo, id); } // For some reason strncpy will fill up the entire output buffer. No reason to do that, @@ -2537,8 +2525,7 @@ static u32 sceIoDread(int id, u32 dirent_addr) { } static u32 sceIoDclose(int id) { - DEBUG_LOG(Log::sceIo, "sceIoDclose(%d)", id); - return kernelObjects.Destroy(id); + return hleLogDebug(Log::sceIo, kernelObjects.Destroy(id)); } int __IoIoctl(u32 id, u32 cmd, u32 indataPtr, u32 inlen, u32 outdataPtr, u32 outlen, int &usec) { @@ -2700,7 +2687,7 @@ int __IoIoctl(u32 id, u32 cmd, u32 indataPtr, u32 inlen, u32 outdataPtr, u32 out if (Memory::IsValidAddress(outdataPtr) && size <= outlen) { // sceIoRead does its own delaying (and deferring.) usec = 0; - return sceIoRead(id, outdataPtr, size); + return hleCall(IoFileMgrForUser, u32, sceIoRead, id, outdataPtr, size); } else { return SCE_KERNEL_ERROR_ERRNO_INVALID_ARGUMENT; } diff --git a/Core/HLE/sceKernel.cpp b/Core/HLE/sceKernel.cpp index 2c30e6c917..c2f664062d 100644 --- a/Core/HLE/sceKernel.cpp +++ b/Core/HLE/sceKernel.cpp @@ -332,6 +332,7 @@ void sceKernelExitGame() Core_Stop(); g_OSD.Show(OSDType::MESSAGE_INFO, "sceKernelExitGame()", 0.0f, "kernelexit"); + hleNoLogVoid(); } void sceKernelExitGameWithStatus() @@ -341,6 +342,7 @@ void sceKernelExitGameWithStatus() Core_Stop(); g_OSD.Show(OSDType::MESSAGE_INFO, "sceKernelExitGameWithStatus()"); + hleNoLogVoid(); } u32 sceKernelDevkitVersion() @@ -418,7 +420,7 @@ int sceKernelDcacheWritebackAll() gpu->InvalidateCache(0, -1, GPU_INVALIDATE_ALL); hleEatCycles(3524); hleReSchedule("dcache writeback all"); - return 0; + return hleNoLog(0); } int sceKernelDcacheWritebackRange(u32 addr, int size) @@ -427,13 +429,13 @@ int sceKernelDcacheWritebackRange(u32 addr, int size) NOTICE_LOG(Log::CPU,"sceKernelDcacheWritebackRange(%08x, %i)", addr, size); #endif if (size < 0) - return SCE_KERNEL_ERROR_INVALID_SIZE; + return hleLogError(Log::sceKernel, SCE_KERNEL_ERROR_INVALID_SIZE); if (size > 0 && addr != 0) { gpu->InvalidateCache(addr, size, GPU_INVALIDATE_HINT); } hleEatCycles(165); - return 0; + return hleNoLog(0); } int sceKernelDcacheWritebackInvalidateRange(u32 addr, int size) @@ -442,13 +444,13 @@ int sceKernelDcacheWritebackInvalidateRange(u32 addr, int size) NOTICE_LOG(Log::CPU,"sceKernelDcacheInvalidateRange(%08x, %i)", addr, size); #endif if (size < 0) - return SCE_KERNEL_ERROR_INVALID_SIZE; + return hleLogError(Log::sceKernel, SCE_KERNEL_ERROR_INVALID_SIZE); if (size > 0 && addr != 0) { gpu->InvalidateCache(addr, size, GPU_INVALIDATE_HINT); } hleEatCycles(165); - return 0; + return hleNoLog(0); } int sceKernelDcacheWritebackInvalidateAll() diff --git a/Core/HLE/sceKernelInterrupt.cpp b/Core/HLE/sceKernelInterrupt.cpp index 352e59ab12..da9b275ec5 100644 --- a/Core/HLE/sceKernelInterrupt.cpp +++ b/Core/HLE/sceKernelInterrupt.cpp @@ -431,6 +431,7 @@ void __KernelReturnFromInterrupt() else __KernelSwitchToThread(threadBeforeInterrupt, "left interrupt"); } + hleNoLogVoid(); } void __RegisterIntrHandler(u32 intrNumber, IntrHandler* handler) diff --git a/Core/HLE/sceKernelModule.cpp b/Core/HLE/sceKernelModule.cpp index c962cbee96..50ab9537f2 100644 --- a/Core/HLE/sceKernelModule.cpp +++ b/Core/HLE/sceKernelModule.cpp @@ -2030,7 +2030,7 @@ int __KernelGPUReplay() { } // Return 0 for normal looping, 1 for break. - return result == GPURecord::ReplayResult::Break ? 1 : 0; + return hleNoLog(result == GPURecord::ReplayResult::Break ? 1 : 0); } int sceKernelLoadExec(const char *filename, u32 paramPtr) { diff --git a/Core/HLE/sceKernelSemaphore.cpp b/Core/HLE/sceKernelSemaphore.cpp index 98c26429d5..5d8e9709cc 100644 --- a/Core/HLE/sceKernelSemaphore.cpp +++ b/Core/HLE/sceKernelSemaphore.cpp @@ -198,8 +198,7 @@ int sceKernelCancelSema(SceUID id, int newCount, u32 numWaitThreadsPtr) } else { - DEBUG_LOG(Log::sceKernel, "sceKernelCancelSema(%i, %i, %08x): invalid semaphore", id, newCount, numWaitThreadsPtr); - return error; + return hleLogError(Log::sceKernel, error, "invalid semaphore"); } } diff --git a/Core/HLE/sceKernelTime.cpp b/Core/HLE/sceKernelTime.cpp index 60f16286d8..7b2e6f0f19 100644 --- a/Core/HLE/sceKernelTime.cpp +++ b/Core/HLE/sceKernelTime.cpp @@ -86,7 +86,7 @@ u32 sceKernelGetSystemTimeLow() if (PSP_CoreParameter().compat.flags().KernelGetSystemTimeLowEatMoreCycles) hleEatCycles(70000); hleReSchedule("system time"); - return (u32)t; + return hleNoLog((u32)t); } u64 sceKernelGetSystemTimeWide() @@ -95,7 +95,7 @@ u64 sceKernelGetSystemTimeWide() VERBOSE_LOG(Log::sceKernel,"%i=sceKernelGetSystemTimeWide()",(u32)t); hleEatCycles(250); hleReSchedule("system time"); - return t; + return hleNoLog(t); } int sceKernelUSec2SysClock(u32 usec, u32 clockPtr) @@ -104,14 +104,14 @@ int sceKernelUSec2SysClock(u32 usec, u32 clockPtr) if (Memory::IsValidAddress(clockPtr)) Memory::Write_U64((usec & 0xFFFFFFFFL), clockPtr); hleEatCycles(165); - return 0; + return hleNoLog(0); } u64 sceKernelUSec2SysClockWide(u32 usec) { VERBOSE_LOG(Log::sceKernel, "sceKernelUSec2SysClockWide(%i)", usec); hleEatCycles(150); - return usec; + return hleNoLog(usec); } int sceKernelSysClock2USec(u32 sysclockPtr, u32 highPtr, u32 lowPtr) @@ -121,11 +121,11 @@ int sceKernelSysClock2USec(u32 sysclockPtr, u32 highPtr, u32 lowPtr) u32 highResult = (u32)(time / 1000000); u32 lowResult = (u32)(time % 1000000); if (Memory::IsValidAddress(highPtr)) - Memory::Write_U32(highResult, highPtr); + Memory::WriteUnchecked_U32(highResult, highPtr); if (Memory::IsValidAddress(lowPtr)) - Memory::Write_U32(lowResult, lowPtr); + Memory::WriteUnchecked_U32(lowResult, lowPtr); hleEatCycles(415); - return 0; + return hleNoLog(0); } int sceKernelSysClock2USecWide(u32 lowClock, u32 highClock, u32 lowPtr, u32 highPtr) @@ -133,40 +133,38 @@ int sceKernelSysClock2USecWide(u32 lowClock, u32 highClock, u32 lowPtr, u32 high u64 sysClock = lowClock | ((u64)highClock << 32); DEBUG_LOG(Log::sceKernel, "sceKernelSysClock2USecWide(clock = %llu, lo = %08x, hi = %08x)", sysClock, lowPtr, highPtr); if (Memory::IsValidAddress(lowPtr)) { - Memory::Write_U32((u32)(sysClock / 1000000), lowPtr); + Memory::WriteUnchecked_U32((u32)(sysClock / 1000000), lowPtr); if (Memory::IsValidAddress(highPtr)) - Memory::Write_U32((u32)(sysClock % 1000000), highPtr); + Memory::WriteUnchecked_U32((u32)(sysClock % 1000000), highPtr); } else if (Memory::IsValidAddress(highPtr)) - Memory::Write_U32((int) sysClock, highPtr); + Memory::WriteUnchecked_U32((int) sysClock, highPtr); hleEatCycles(385); - return 0; + return hleNoLog(0); } u32 sceKernelLibcClock() { u32 retVal = (u32) CoreTiming::GetGlobalTimeUs(); - DEBUG_LOG(Log::sceKernel, "%i = sceKernelLibcClock", retVal); hleEatCycles(330); hleReSchedule("libc clock"); - return retVal; + return hleLogDebug(Log::sceKernel, retVal); } u32 sceKernelLibcTime(u32 outPtr) { u32 t = (u32) start_time + (u32) (CoreTiming::GetGlobalTimeUs() / 1000000ULL); - DEBUG_LOG(Log::sceKernel, "%i = sceKernelLibcTime(%08X)", t, outPtr); // The PSP sure takes its sweet time on this function. hleEatCycles(3385); if (Memory::IsValidAddress(outPtr)) - Memory::Write_U32(t, outPtr); + Memory::WriteUnchecked_U32(t, outPtr); else if (outPtr != 0) return 0; hleReSchedule("libc time"); - return t; + return hleLogDebug(Log::sceKernel, t); } u32 sceKernelLibcGettimeofday(u32 timeAddr, u32 tzAddr) @@ -182,7 +180,7 @@ u32 sceKernelLibcGettimeofday(u32 timeAddr, u32 tzAddr) hleEatCycles(1885); hleReSchedule("libc timeofday"); - return 0; + return hleNoLog(0); } std::string KernelTimeNowFormatted() { diff --git a/Core/HLE/scePower.cpp b/Core/HLE/scePower.cpp index 5e475b8792..eea91ef1a7 100644 --- a/Core/HLE/scePower.cpp +++ b/Core/HLE/scePower.cpp @@ -170,59 +170,49 @@ void __PowerDoState(PointerWrap &p) { } static int scePowerGetBatteryLifePercent() { - DEBUG_LOG(Log::HLE, "100=scePowerGetBatteryLifePercent"); - return 100; + return hleLogDebug(Log::HLE, 100); } static int scePowerGetBatteryLifeTime() { - DEBUG_LOG(Log::HLE, "0=scePowerGetBatteryLifeTime()"); // 0 means we're on AC power. - return 0; + return hleLogDebug(Log::HLE, 0); } static int scePowerGetBatteryTemp() { - DEBUG_LOG(Log::HLE, "0=scePowerGetBatteryTemp()"); // 0 means celsius temperature of the battery - return 0; + return hleLogDebug(Log::HLE, 0); } static int scePowerIsPowerOnline() { - DEBUG_LOG(Log::HLE, "1=scePowerIsPowerOnline"); - return 1; + return hleLogDebug(Log::HLE, 1); } static int scePowerIsBatteryExist() { - DEBUG_LOG(Log::HLE, "1=scePowerIsBatteryExist"); - return 1; + return hleLogDebug(Log::HLE, 1); } static int scePowerIsBatteryCharging() { - DEBUG_LOG(Log::HLE, "0=scePowerIsBatteryCharging"); - return 0; + return hleLogDebug(Log::HLE, 0); } static int scePowerGetBatteryChargingStatus() { - DEBUG_LOG(Log::HLE, "0=scePowerGetBatteryChargingStatus"); - return 0; + return hleLogDebug(Log::HLE, 0); } static int scePowerIsLowBattery() { - DEBUG_LOG(Log::HLE, "0=scePowerIsLowBattery"); - return 0; + return hleLogDebug(Log::HLE, 0); } static int scePowerRegisterCallback(int slot, int cbId) { - DEBUG_LOG(Log::HLE, "0=scePowerRegisterCallback(%i, %i)", slot, cbId); - if (slot < -1 || slot >= numberOfCBPowerSlotsPrivate) { - return PSP_POWER_ERROR_INVALID_SLOT; + return hleLogError(Log::HLE, PSP_POWER_ERROR_INVALID_SLOT); } if (slot >= numberOfCBPowerSlots) { - return SCE_KERNEL_ERROR_PRIV_REQUIRED; + return hleLogError(Log::HLE, SCE_KERNEL_ERROR_PRIV_REQUIRED); } // TODO: If cbId is invalid return PSP_POWER_ERROR_INVALID_CB. if (cbId == 0) { - return PSP_POWER_ERROR_INVALID_CB; + return hleLogError(Log::HLE, PSP_POWER_ERROR_INVALID_CB); } int retval = -1; @@ -235,42 +225,40 @@ static int scePowerRegisterCallback(int slot, int cbId) { } } if (retval == -1) { - return PSP_POWER_ERROR_SLOTS_FULL; + return hleLogError(Log::HLE, PSP_POWER_ERROR_SLOTS_FULL); } } else { if (powerCbSlots[slot] == 0) { powerCbSlots[slot] = cbId; retval = 0; } else { - return PSP_POWER_ERROR_TAKEN_SLOT; + return hleLogError(Log::HLE, PSP_POWER_ERROR_TAKEN_SLOT); } } if (retval >= 0) { int arg = PSP_POWER_CB_AC_POWER | PSP_POWER_CB_BATTERY_EXIST | PSP_POWER_CB_BATTERY_FULL; __KernelNotifyCallback(cbId, arg); } - return retval; + return hleLogSuccessOrError(Log::HLE, retval); } static int scePowerUnregisterCallback(int slotId) { DEBUG_LOG(Log::HLE, "0=scePowerUnregisterCallback(%i)", slotId); if (slotId < 0 || slotId >= numberOfCBPowerSlotsPrivate) { - return PSP_POWER_ERROR_INVALID_SLOT; + return hleLogError(Log::HLE, PSP_POWER_ERROR_INVALID_SLOT); } if (slotId >= numberOfCBPowerSlots) { - return SCE_KERNEL_ERROR_PRIV_REQUIRED; + return hleLogError(Log::HLE, SCE_KERNEL_ERROR_PRIV_REQUIRED); } if (powerCbSlots[slotId] != 0) { int cbId = powerCbSlots[slotId]; - DEBUG_LOG(Log::HLE, "0=scePowerUnregisterCallback(%i) (cbid = %i)", slotId, cbId); powerCbSlots[slotId] = 0; + return hleLogDebug(Log::HLE, 0, "(cbid = %i)", cbId); } else { - return PSP_POWER_ERROR_EMPTY_SLOT; + return hleLogError(Log::HLE, PSP_POWER_ERROR_EMPTY_SLOT); } - - return 0; } static int sceKernelPowerLock(int lockType) { @@ -293,6 +281,7 @@ static int sceKernelPowerTick(int flag) { return hleLogDebug(Log::HLE, 0, "UNIMPL"); } +// not a syscall int KernelVolatileMemLock(int type, u32 paddr, u32 psize) { if (type != 0) { return SCE_KERNEL_ERROR_INVALID_MODE; @@ -305,14 +294,13 @@ int KernelVolatileMemLock(int type, u32 paddr, u32 psize) { // It's always available in the emu. // TODO: Should really reserve this properly! if (Memory::IsValidAddress(paddr)) { - Memory::Write_U32(0x08400000, paddr); + Memory::WriteUnchecked_U32(0x08400000, paddr); } if (Memory::IsValidAddress(psize)) { - Memory::Write_U32(0x00400000, psize); + Memory::WriteUnchecked_U32(0x00400000, psize); } volatileMemLocked = true; NotifyMemInfo(MemBlockFlags::ALLOC, 0x08400000, 0x400000, "Volatile memory (locked)"); - return 0; } @@ -331,15 +319,14 @@ static int sceKernelVolatileMemTryLock(int type, u32 paddr, u32 psize) { case SCE_KERNEL_ERROR_POWER_VMEM_IN_USE: // This is OK, let's not ERROR_LOG. - DEBUG_LOG(Log::HLE, "sceKernelVolatileMemTryLock(%i, %08x, %08x) - already locked!", type, paddr, psize); - break; + return hleLogDebug(Log::HLE, error, "(%i, %08x, %08x) - already locked!", type, paddr, psize); default: ERROR_LOG_REPORT(Log::HLE, "%08x=sceKernelVolatileMemTryLock(%i, %08x, %08x) - error", type, paddr, psize, error); break; } - return error; + return hleLogSuccessOrError(Log::HLE, error); } int KernelVolatileMemUnlock(int type) { diff --git a/Core/HLE/sceRtc.cpp b/Core/HLE/sceRtc.cpp index 2ae40a1762..bbefe8bb92 100644 --- a/Core/HLE/sceRtc.cpp +++ b/Core/HLE/sceRtc.cpp @@ -271,8 +271,7 @@ static bool __RtcValidatePspTime(const ScePspDateTime &t) static u32 sceRtcGetTickResolution() { - DEBUG_LOG(Log::sceRtc, "sceRtcGetTickResolution()"); - return 1000000; + return hleLogDebug(Log::sceRtc, 1000000); } static u32 sceRtcGetCurrentTick(u32 tickPtr) @@ -284,7 +283,7 @@ static u32 sceRtcGetCurrentTick(u32 tickPtr) Memory::Write_U64(curTick, tickPtr); hleEatCycles(300); hleReSchedule("rtc current tick"); - return 0; + return hleNoLog(0); } static u64 sceRtcGetAccumulativeTime() @@ -292,7 +291,7 @@ static u64 sceRtcGetAccumulativeTime() DEBUG_LOG(Log::sceRtc, "sceRtcGetAccumulativeTime()"); hleEatCycles(300); hleReSchedule("rtc accumulative time"); - return __RtcGetCurrentTick(); + return hleNoLog(__RtcGetCurrentTick()); } static u32 sceRtcGetCurrentClock(u32 pspTimePtr, int tz) { diff --git a/Core/HLE/sceUmd.cpp b/Core/HLE/sceUmd.cpp index 3e1b610195..19437fa327 100644 --- a/Core/HLE/sceUmd.cpp +++ b/Core/HLE/sceUmd.cpp @@ -258,29 +258,27 @@ static void __UmdEndCallback(SceUID threadID, SceUID prevCallbackId) } } -static int sceUmdCheckMedium() -{ +static int sceUmdCheckMedium() { + int retVal = 0; if (UMDInserted) { - DEBUG_LOG(Log::sceIo, "1=sceUmdCheckMedium()"); - return 1; //non-zero: disc in drive + retVal = 1; //non-zero: disc in drive } - DEBUG_LOG(Log::sceIo, "0=sceUmdCheckMedium()"); - return 0; + return hleLogDebug(Log::sceKernel, retVal); } -static u32 sceUmdGetDiscInfo(u32 infoAddr) -{ +static u32 sceUmdGetDiscInfo(u32 infoAddr) { DEBUG_LOG(Log::sceIo, "sceUmdGetDiscInfo(%08x)", infoAddr); if (Memory::IsValidAddress(infoAddr)) { auto info = PSPPointer::Create(infoAddr); if (info->size != 8) - return PSP_ERROR_UMD_INVALID_PARAM; + return hleLogError(Log::sceIo, PSP_ERROR_UMD_INVALID_PARAM); info->type = PSP_UMD_TYPE_GAME; - return 0; - } else - return PSP_ERROR_UMD_INVALID_PARAM; + return hleLogDebug(Log::sceIo, 0); + } else { + return hleLogError(Log::sceIo, PSP_ERROR_UMD_INVALID_PARAM); + } } static int sceUmdActivate(u32 mode, const char *name) { @@ -299,17 +297,15 @@ static int sceUmdDeactivate(u32 mode, const char *name) { // Why 18? No idea. if (mode > 18) - return PSP_ERROR_UMD_INVALID_PARAM; + return hleLogError(Log::sceIo, PSP_ERROR_UMD_INVALID_PARAM); __KernelUmdDeactivate(); if (mode == 1) { - DEBUG_LOG(Log::sceIo, "0=sceUmdDeactivate(%d, %s)", mode, name); + return hleLogDebug(Log::sceIo, 0); } else { - ERROR_LOG(Log::sceIo, "UNTESTED 0=sceUmdDeactivate(%d, %s)", mode, name); + return hleLogError(Log::sceIo, 0, "UNTESTED mode != 1"); } - - return 0; } static u32 sceUmdRegisterUMDCallBack(u32 cbId) @@ -323,39 +319,33 @@ static u32 sceUmdRegisterUMDCallBack(u32 cbId) // There's only ever one. driveCBId = cbId; } - DEBUG_LOG(Log::sceIo, "%d=sceUmdRegisterUMDCallback(id=%08x)", retVal, cbId); - return retVal; + return hleLogDebug(Log::sceIo, retVal); } static int sceUmdUnRegisterUMDCallBack(int cbId) { - int retVal; - if (cbId != driveCBId) { - retVal = PSP_ERROR_UMD_INVALID_PARAM; + return hleLogError(Log::sceIo, PSP_ERROR_UMD_INVALID_PARAM); } else { + int retVal; if (sceKernelGetCompiledSdkVersion() > 0x3000000) { retVal = 0; } else { retVal = cbId; } driveCBId = 0; + return hleLogDebug(Log::sceIo, retVal); } - DEBUG_LOG(Log::sceIo, "%08x=sceUmdUnRegisterUMDCallBack(id=%08x)", retVal, cbId); - return retVal; } -static u32 sceUmdGetDriveStat() -{ +static u32 sceUmdGetDriveStat() { if (!UMDInserted) { - WARN_LOG(Log::sceIo, "sceUmdGetDriveStat: UMD is taking out for switch UMD"); - return PSP_UMD_NOT_PRESENT; + return hleLogWarning(Log::sceIo, PSP_UMD_NOT_PRESENT, "sceUmdGetDriveStat: UMD is taking out for switch UMD"); } //u32 retVal = PSP_UMD_INITED | PSP_UMD_READY | PSP_UMD_PRESENT; u32 retVal = __KernelUmdGetState(); // This one can be very spammy. - VERBOSE_LOG(Log::sceIo,"0x%02x=sceUmdGetDriveStat()", retVal); - return retVal; + return hleLogVerbose(Log::sceIo, retVal, "0x%02x=sceUmdGetDriveStat()", retVal); } static void __UmdStatTimeout(u64 userdata, int cyclesLate) @@ -405,7 +395,7 @@ static int sceUmdWaitDriveStat(u32 stat) { DEBUG_LOG(Log::sceIo, "sceUmdWaitDriveStat(stat = %08x): waiting", stat); umdWaitingThreads.push_back(__KernelGetCurThread()); __KernelWaitCurThread(WAITTYPE_UMD, 1, stat, 0, 0, "umd stat waited"); - return 0; + return hleLogDebug(Log::sceIo, 0); } return hleLogSuccessI(Log::sceIo, 0); @@ -424,11 +414,10 @@ static int sceUmdWaitDriveStatWithTimer(u32 stat, u32 timeout) { hleEatCycles(520); if ((stat & __KernelUmdGetState()) == 0) { - DEBUG_LOG(Log::sceIo, "sceUmdWaitDriveStatWithTimer(stat = %08x, timeout = %d): waiting", stat, timeout); __UmdWaitStat(timeout); umdWaitingThreads.push_back(__KernelGetCurThread()); __KernelWaitCurThread(WAITTYPE_UMD, 1, stat, 0, false, "umd stat waited with timer"); - return 0; + return hleLogDebug(Log::sceIo, 0, "waiting"); } else { hleReSchedule("umd stat checked"); } @@ -450,7 +439,6 @@ static int sceUmdWaitDriveStatCB(u32 stat, u32 timeout) { hleEatCycles(520); hleCheckCurrentCallbacks(); if ((stat & __KernelUmdGetState()) == 0) { - DEBUG_LOG(Log::sceIo, "sceUmdWaitDriveStatCB(stat = %08x, timeout = %d): waiting", stat, timeout); if (timeout == 0) { timeout = 8000; } @@ -458,6 +446,7 @@ static int sceUmdWaitDriveStatCB(u32 stat, u32 timeout) { __UmdWaitStat(timeout); umdWaitingThreads.push_back(__KernelGetCurThread()); __KernelWaitCurThread(WAITTYPE_UMD, 1, stat, 0, true, "umd stat waited"); + return hleLogSuccessI(Log::sceIo, 0, "waiting"); } else { hleReSchedule("umd stat waited"); } @@ -465,10 +454,7 @@ static int sceUmdWaitDriveStatCB(u32 stat, u32 timeout) { return hleLogSuccessI(Log::sceIo, 0); } -static u32 sceUmdCancelWaitDriveStat() -{ - DEBUG_LOG(Log::sceIo, "0=sceUmdCancelWaitDriveStat()"); - +static u32 sceUmdCancelWaitDriveStat() { for (size_t i = 0; i < umdWaitingThreads.size(); ++i) { const SceUID threadID = umdWaitingThreads[i]; CoreTiming::UnscheduleEvent(umdStatTimeoutEvent, threadID); @@ -476,13 +462,11 @@ static u32 sceUmdCancelWaitDriveStat() } umdWaitingThreads.clear(); - return 0; + return hleLogDebug(Log::sceIo, 0); } -static u32 sceUmdGetErrorStat() -{ - DEBUG_LOG(Log::sceIo,"%i=sceUmdGetErrorStat()", umdErrorStat); - return umdErrorStat; +static u32 sceUmdGetErrorStat() { + return hleLogError(Log::sceIo, umdErrorStat); } void __UmdReplace(const Path &filepath) { @@ -510,26 +494,22 @@ bool getUMDReplacePermit() { return g_UMDReplacePermit; } -static u32 sceUmdReplaceProhibit() -{ - DEBUG_LOG(Log::sceIo, "sceUmdReplaceProhibit()"); +static u32 sceUmdReplaceProhibit() { if (g_UMDReplacePermit) { INFO_LOG(Log::sceIo, "sceUmdReplaceProhibit() - prohibited"); g_UMDReplacePermit = false; System_Notify(SystemNotification::SWITCH_UMD_UPDATED); } - return 0; + return hleLogDebug(Log::sceIo, 0); } -static u32 sceUmdReplacePermit() -{ - DEBUG_LOG(Log::sceIo, "sceUmdReplacePermit()"); +static u32 sceUmdReplacePermit() { if (!g_UMDReplacePermit) { INFO_LOG(Log::sceIo, "sceUmdReplacePermit() - permitted"); g_UMDReplacePermit = true; System_Notify(SystemNotification::SWITCH_UMD_UPDATED); } - return 0; + return hleLogDebug(Log::sceIo, 0); } const HLEFunction sceUmdUser[] =