[orbis-kernel] store auth info per process

orbis-kernel/include/orbis/AuthInfo.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "orbis-config.hpp"
+
+namespace orbis {
+struct AuthInfo {
+  uint64_t unk0;
+  uint64_t caps[4];
+  uint64_t attrs[4];
+  uint64_t unk[8];
+};
+
+static_assert(sizeof(AuthInfo) == 136);
+} // namespace orbis

orbis-kernel/include/orbis/sys/sysproto.hpp

@@ -11,6 +11,7 @@ using cpuwhich_t = sint;
 using cpulevel_t = sint;
 using SceKernelModule = ModuleHandle;
 
+struct AuthInfo;
 struct MemoryProtection;
 struct ModuleInfo;
 struct ModuleInfoEx;
@@ -676,7 +677,7 @@ SysResult sys_obs_eport_open(Thread *thread /* TODO */);
 SysResult sys_obs_eport_close(Thread *thread /* TODO */);
 SysResult sys_is_in_sandbox(Thread *thread /* TODO */);
 SysResult sys_dmem_container(Thread *thread, uint id);
-SysResult sys_get_authinfo(Thread *thread, pid_t pid, ptr<void> info);
+SysResult sys_get_authinfo(Thread *thread, pid_t pid, ptr<AuthInfo> info);
 SysResult sys_mname(Thread *thread, uint64_t address, uint64_t length,
                     ptr<const char[32]> name);
 SysResult sys_dynlib_dlopen(Thread *thread /* TODO */);

orbis-kernel/include/orbis/thread/Process.hpp

@@ -8,6 +8,7 @@
 #include "../thread/types.hpp"
 #include "ProcessState.hpp"
 #include "orbis/AppInfo.hpp"
+#include "orbis/AuthInfo.hpp"
 #include "orbis/file.hpp"
 #include "orbis/module/Module.hpp"
 #include "orbis/utils/IdMap.hpp"
@@ -55,6 +56,7 @@ struct Process final {
   uint64_t processParamSize = 0;
   const ProcessOps *ops = nullptr;
   AppInfo appInfo{};
+  AuthInfo authInfo{};
 
   std::uint64_t nextTlsSlot = 1;
   std::uint64_t lastTlsOffset = 0;

orbis-kernel/src/sys/sys_sce.cpp

@@ -661,34 +661,8 @@ orbis::SysResult orbis::sys_dmem_container(Thread *thread, uint id) {
   return {};
 }
 orbis::SysResult orbis::sys_get_authinfo(Thread *thread, pid_t pid,
-                                         ptr<void> info) {
-  struct authinfo {
-    uint64_t unk0;
-    uint64_t caps[4];
-    uint64_t attrs[4];
-    uint64_t unk[8];
-  };
-  static_assert(sizeof(authinfo) == 136);
-
-  authinfo result{
-      .unk0 = 0x3100000000000001,
-      .caps =
-          {
-              0x2000038000000000,
-              0x000000000000FF00,
-              0x0000000000000000,
-              0x0000000000000000,
-          },
-      .attrs =
-          {
-              0x4000400040000000,
-              0x4000000000000000,
-              0x0080000000000002,
-              0xF0000000FFFF4000,
-          },
-  };
-
-  return uwrite((ptr<authinfo>)info, result);
+                                         ptr<AuthInfo> info) {
+  return uwrite(info, thread->tproc->authInfo);
 }
 orbis::SysResult orbis::sys_mname(Thread *thread, uint64_t addr, uint64_t len,
                                   ptr<const char[32]> name) {

rpcsx-os/main.cpp

@@ -780,6 +780,44 @@ int main(int argc, const char *argv[]) {
       .unk4 = (isSystem ? orbis::slong(0x80000000'00000000) : 0),
   };
 
+  if (isSystem) {
+    initProcess->authInfo = {
+        .unk0 = 0x3100000000000001,
+        .caps =
+            {
+                -1u,
+                -1u,
+                -1u,
+                -1u,
+            },
+        .attrs =
+            {
+                0x4000400040000000,
+                0x4000000000000000,
+                0x0080000000000002,
+                0xF0000000FFFF4000,
+            },
+    };
+  } else {
+    initProcess->authInfo = {
+        .unk0 = 0x3100000000000001,
+        .caps =
+            {
+                0x2000038000000000,
+                0x000000000000FF00,
+                0x0000000000000000,
+                0x0000000000000000,
+            },
+        .attrs =
+            {
+                0x4000400040000000,
+                0x4000000000000000,
+                0x0080000000000002,
+                0xF0000000FFFF4000,
+            },
+    };
+  }
+
   auto [baseId, mainThread] = initProcess->threadsMap.emplace();
   mainThread->tproc = initProcess;
   mainThread->tid = initProcess->pid + baseId;

rpcsx-os/ops.cpp

@@ -649,6 +649,7 @@ SysResult fork(Thread *thread, slong flags) {
   process->onSysExit = thread->tproc->onSysExit;
   process->ops = thread->tproc->ops;
   process->parentProcess = thread->tproc;
+  process->authInfo = thread->tproc->authInfo;
   for (auto [id, mod] : thread->tproc->modulesMap) {
     if (!process->modulesMap.insert(id, mod)) {
       std::abort();