[rpcsx-os] implement sys_dmem_mmap

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

@@ -728,7 +728,9 @@ SysResult sys_get_vm_map_timestamp(Thread *thread /* TODO */);
 SysResult sys_opmc_set_hw(Thread *thread /* TODO */);
 SysResult sys_opmc_get_hw(Thread *thread /* TODO */);
 SysResult sys_get_cpu_usage_all(Thread *thread /* TODO */);
-SysResult sys_mmap_dmem(Thread *thread /* TODO */);
+SysResult sys_mmap_dmem(Thread *thread, caddr_t addr, size_t len,
+                        sint memoryType, sint prot, sint flags,
+                        off_t directMemoryStart);
 SysResult sys_physhm_open(Thread *thread /* TODO */);
 SysResult sys_physhm_unlink(Thread *thread /* TODO */);
 SysResult sys_resume_internal_hdd(Thread *thread /* TODO */);

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

@@ -14,6 +14,9 @@ struct File;
 struct ProcessOps {
   SysResult (*mmap)(Thread *thread, caddr_t addr, size_t len, sint prot,
                     sint flags, sint fd, off_t pos);
+  SysResult (*dmem_mmap)(Thread *thread, caddr_t addr, size_t len,
+                         sint memoryType, sint prot, sint flags,
+                         off_t directMemoryStart);
   SysResult (*munmap)(Thread *thread, ptr<void> addr, size_t len);
   SysResult (*msync)(Thread *thread, ptr<void> addr, size_t len, sint flags);
   SysResult (*mprotect)(Thread *thread, ptr<const void> addr, size_t len,

orbis-kernel/src/sys/sys_sce.cpp

@@ -1093,7 +1093,13 @@ orbis::SysResult orbis::sys_opmc_get_hw(Thread *thread /* TODO */) {
 orbis::SysResult orbis::sys_get_cpu_usage_all(Thread *thread /* TODO */) {
   return ErrorCode::NOSYS;
 }
-orbis::SysResult orbis::sys_mmap_dmem(Thread *thread /* TODO */) {
+orbis::SysResult orbis::sys_mmap_dmem(Thread *thread, caddr_t addr, size_t len,
+                                      sint memoryType, sint prot, sint flags,
+                                      off_t directMemoryStart) {
+  if (auto dmem_mmap = thread->tproc->ops->dmem_mmap) {
+    return dmem_mmap(thread, addr, len, memoryType, prot, flags,
+                     directMemoryStart);
+  }
   return ErrorCode::NOSYS;
 }
 orbis::SysResult orbis::sys_physhm_open(Thread *thread /* TODO */) {

rpcsx-os/iodev/dmem.cpp

@@ -1,23 +1,12 @@
+#include "dmem.hpp"
 #include "io-device.hpp"
 #include "orbis/KernelAllocator.hpp"
 #include "orbis/file.hpp"
 #include "orbis/thread/Thread.hpp"
 #include "orbis/utils/Logs.hpp"
-#include "orbis/utils/SharedMutex.hpp"
 #include "vm.hpp"
 #include <mutex>
 
-struct DmemDevice : public IoDevice {
-  orbis::shared_mutex mtx;
-  int index;
-  std::uint64_t nextOffset;
-  std::uint64_t memBeginAddress;
-
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
-                        std::uint32_t flags, std::uint32_t mode,
-                        orbis::Thread *thread) override;
-};
-
 struct DmemFile : public orbis::File {};
 
 struct AllocateDirectMemoryArgs {
@@ -32,6 +21,22 @@ static constexpr auto dmemSize = 4ul * 1024 * 1024 * 1024;
 // static const std::uint64_t nextOffset = 0;
 //  static const std::uint64_t memBeginAddress = 0xfe0000000;
 
+orbis::ErrorCode DmemDevice::mmap(void **address, std::uint64_t len,
+                                  std::int32_t memoryType, std::int32_t prot,
+                                  std::int32_t flags,
+                                  std::int64_t directMemoryStart) {
+  ORBIS_LOG_WARNING("dmem mmap", index, directMemoryStart, memoryType);
+
+  auto result = rx::vm::map(*address, len, prot, flags);
+
+  if (result == (void *)-1) {
+    return orbis::ErrorCode::NOMEM; // TODO
+  }
+
+  *address = result;
+  return {};
+}
+
 static orbis::ErrorCode dmem_ioctl(orbis::File *file, std::uint64_t request,
                                    void *argp, orbis::Thread *thread) {
   auto device = static_cast<DmemDevice *>(file->device.get());

rpcsx-os/iodev/dmem.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "io-device.hpp"
+#include "orbis/error/ErrorCode.hpp"
+#include "orbis/file.hpp"
+#include "orbis/utils/Rc.hpp"
+#include "orbis/utils/SharedMutex.hpp"
+#include <cstdint>
+#include <unistd.h>
+
+struct DmemDevice : public IoDevice {
+  orbis::shared_mutex mtx;
+  int index;
+  std::uint64_t nextOffset;
+  std::uint64_t memBeginAddress;
+
+  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+                        std::uint32_t flags, std::uint32_t mode,
+                        orbis::Thread *thread) override;
+
+  orbis::ErrorCode mmap(void **address, std::uint64_t len,
+                        std::int32_t memoryType, std::int32_t prot,
+                        std::int32_t flags, std::int64_t directMemoryStart);
+};

rpcsx-os/main.cpp

@@ -307,8 +307,11 @@ static int ps4Exec(orbis::Thread *mainThread,
   mainThread->stackEnd =
       reinterpret_cast<std::byte *>(mainThread->stackStart) + stackSize;
 
+  auto dmem1 = createDmemCharacterDevice(1);
+  orbis::g_context.dmemDevice = dmem1;
+
   rx::vfs::mount("/dev/dmem0", createDmemCharacterDevice(0));
-  rx::vfs::mount("/dev/dmem1", createDmemCharacterDevice(1));
+  rx::vfs::mount("/dev/dmem1", dmem1);
   rx::vfs::mount("/dev/dmem2", createDmemCharacterDevice(2));
   rx::vfs::mount("/dev/stdout", createFdWrapDevice(STDOUT_FILENO));
   rx::vfs::mount("/dev/stderr", createFdWrapDevice(STDERR_FILENO));

rpcsx-os/ops.cpp

@@ -2,6 +2,7 @@
 #include "align.hpp"
 #include "backtrace.hpp"
 #include "io-device.hpp"
+#include "iodev/dmem.hpp"
 #include "linker.hpp"
 #include "orbis/KernelContext.hpp"
 #include "orbis/module/ModuleHandle.hpp"
@@ -170,6 +171,22 @@ orbis::SysResult mmap(orbis::Thread *thread, orbis::caddr_t addr,
   return {};
 }
 
+orbis::SysResult dmem_mmap(orbis::Thread *thread, orbis::caddr_t addr,
+                           orbis::size_t len, orbis::sint memoryType,
+                           orbis::sint prot, sint flags,
+                           orbis::off_t directMemoryStart) {
+  auto dmem = static_cast<DmemDevice *>(orbis::g_context.dmemDevice.get());
+  void *address = addr;
+  auto result =
+      dmem->mmap(&address, len, memoryType, prot, flags, directMemoryStart);
+  if (result != ErrorCode{}) {
+    return result;
+  }
+
+  thread->retval[0] = reinterpret_cast<std::uint64_t>(address);
+  return {};
+}
+
 orbis::SysResult munmap(orbis::Thread *, orbis::ptr<void> addr,
                         orbis::size_t len) {
   if (rx::vm::unmap(addr, len)) {
@@ -531,6 +548,7 @@ void where(Thread *thread) {
 
 ProcessOps rx::procOpsTable = {
     .mmap = mmap,
+    .dmem_mmap = dmem_mmap,
     .munmap = munmap,
     .msync = msync,
     .mprotect = mprotect,