Filesystem devices (#2184)

* added dummy devices

* More WIP

* added urandom,srandom,random,console,deci_tty6 devices

* small fix

* macOS fix

src/core/devices/deci_tty6.cpp

@@ -0,0 +1,66 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging/log.h"
+#include "deci_tty6.h"
+
+namespace Core::Devices {
+std::shared_ptr<BaseDevice> DeciTty6Device::Create(u32 handle, const char*, int, u16) {
+    return std::shared_ptr<BaseDevice>(
+        reinterpret_cast<Devices::BaseDevice*>(new DeciTty6Device(handle)));
+}
+int DeciTty6Device::ioctl(u64 cmd, Common::VaCtx* args) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 DeciTty6Device::write(const void* buf, size_t nbytes) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t DeciTty6Device::writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t DeciTty6Device::readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 DeciTty6Device::preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 DeciTty6Device::lseek(s64 offset, int whence) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 DeciTty6Device::read(void* buf, size_t nbytes) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int DeciTty6Device::fstat(Libraries::Kernel::OrbisKernelStat* sb) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s32 DeciTty6Device::fsync() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int DeciTty6Device::ftruncate(s64 length) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int DeciTty6Device::getdents(void* buf, u32 nbytes, s64* basep) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 DeciTty6Device::pwrite(const void* buf, size_t nbytes, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+} // namespace Core::Devices

src/core/devices/deci_tty6.h

@@ -0,0 +1,33 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+#include <memory>
+#include "base_device.h"
+
+namespace Core::Devices {
+
+class DeciTty6Device final : BaseDevice {
+    u32 handle;
+
+public:
+    static std::shared_ptr<BaseDevice> Create(u32 handle, const char*, int, u16);
+    explicit DeciTty6Device(u32 handle) : handle(handle) {}
+
+    ~DeciTty6Device() override = default;
+
+    int ioctl(u64 cmd, Common::VaCtx* args) override;
+    s64 write(const void* buf, size_t nbytes) override;
+    size_t readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    size_t writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    s64 preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) override;
+    s64 lseek(s64 offset, int whence) override;
+    s64 read(void* buf, size_t nbytes) override;
+    int fstat(Libraries::Kernel::OrbisKernelStat* sb) override;
+    s32 fsync() override;
+    int ftruncate(s64 length) override;
+    int getdents(void* buf, u32 nbytes, s64* basep) override;
+    s64 pwrite(const void* buf, size_t nbytes, u64 offset) override;
+};
+
+} // namespace Core::Devices

src/core/devices/dev_console.cpp

@@ -0,0 +1,67 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging/log.h"
+#include "dev_console.h"
+
+namespace Core::Devices {
+std::shared_ptr<BaseDevice> ConsoleDevice::Create(u32 handle, const char*, int, u16) {
+    return std::shared_ptr<BaseDevice>(
+        reinterpret_cast<Devices::BaseDevice*>(new ConsoleDevice(handle)));
+}
+int ConsoleDevice::ioctl(u64 cmd, Common::VaCtx* args) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 ConsoleDevice::write(const void* buf, size_t nbytes) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t ConsoleDevice::writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t ConsoleDevice::readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 ConsoleDevice::preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 ConsoleDevice::lseek(s64 offset, int whence) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 ConsoleDevice::read(void* buf, size_t nbytes) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int ConsoleDevice::fstat(Libraries::Kernel::OrbisKernelStat* sb) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s32 ConsoleDevice::fsync() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int ConsoleDevice::ftruncate(s64 length) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int ConsoleDevice::getdents(void* buf, u32 nbytes, s64* basep) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 ConsoleDevice::pwrite(const void* buf, size_t nbytes, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+} // namespace Core::Devices

src/core/devices/dev_console.h

@@ -0,0 +1,33 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+#include <memory>
+#include "base_device.h"
+
+namespace Core::Devices {
+
+class ConsoleDevice final : BaseDevice {
+    u32 handle;
+
+public:
+    static std::shared_ptr<BaseDevice> Create(u32 handle, const char*, int, u16);
+    explicit ConsoleDevice(u32 handle) : handle(handle) {}
+
+    ~ConsoleDevice() override = default;
+
+    int ioctl(u64 cmd, Common::VaCtx* args) override;
+    s64 write(const void* buf, size_t nbytes) override;
+    size_t readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    size_t writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    s64 preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) override;
+    s64 lseek(s64 offset, int whence) override;
+    s64 read(void* buf, size_t nbytes) override;
+    int fstat(Libraries::Kernel::OrbisKernelStat* sb) override;
+    s32 fsync() override;
+    int ftruncate(s64 length) override;
+    int getdents(void* buf, u32 nbytes, s64* basep) override;
+    s64 pwrite(const void* buf, size_t nbytes, u64 offset) override;
+};
+
+} // namespace Core::Devices

src/core/devices/random.cpp

@@ -0,0 +1,68 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+#include <cstdlib>
+#include "common/logging/log.h"
+#include "random.h"
+
+namespace Core::Devices {
+std::shared_ptr<BaseDevice> RandomDevice::Create(u32 handle, const char*, int, u16) {
+    std::srand(std::time(nullptr));
+    return std::shared_ptr<BaseDevice>(
+        reinterpret_cast<Devices::BaseDevice*>(new RandomDevice(handle)));
+}
+int RandomDevice::ioctl(u64 cmd, Common::VaCtx* args) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 RandomDevice::write(const void* buf, size_t nbytes) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t RandomDevice::writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t RandomDevice::readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 RandomDevice::preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 RandomDevice::lseek(s64 offset, int whence) {
+    return 0;
+}
+
+s64 RandomDevice::read(void* buf, size_t nbytes) {
+    auto rbuf = static_cast<char*>(buf);
+    for (size_t i = 0; i < nbytes; i++)
+        rbuf[i] = std::rand() & 0xFF;
+    return nbytes;
+}
+
+int RandomDevice::fstat(Libraries::Kernel::OrbisKernelStat* sb) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s32 RandomDevice::fsync() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int RandomDevice::ftruncate(s64 length) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int RandomDevice::getdents(void* buf, u32 nbytes, s64* basep) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 RandomDevice::pwrite(const void* buf, size_t nbytes, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+} // namespace Core::Devices

src/core/devices/random.h

@@ -0,0 +1,33 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+#include <memory>
+#include "base_device.h"
+
+namespace Core::Devices {
+
+class RandomDevice final : BaseDevice {
+    u32 handle;
+
+public:
+    static std::shared_ptr<BaseDevice> Create(u32 handle, const char*, int, u16);
+    explicit RandomDevice(u32 handle) : handle(handle) {}
+
+    ~RandomDevice() override = default;
+
+    int ioctl(u64 cmd, Common::VaCtx* args) override;
+    s64 write(const void* buf, size_t nbytes) override;
+    size_t readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    size_t writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    s64 preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) override;
+    s64 lseek(s64 offset, int whence) override;
+    s64 read(void* buf, size_t nbytes) override;
+    int fstat(Libraries::Kernel::OrbisKernelStat* sb) override;
+    s32 fsync() override;
+    int ftruncate(s64 length) override;
+    int getdents(void* buf, u32 nbytes, s64* basep) override;
+    s64 pwrite(const void* buf, size_t nbytes, u64 offset) override;
+};
+
+} // namespace Core::Devices

src/core/devices/srandom.cpp

@@ -0,0 +1,69 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+#include <cstdlib>
+#include "common/logging/log.h"
+#include "srandom.h"
+
+namespace Core::Devices {
+std::shared_ptr<BaseDevice> SRandomDevice::Create(u32 handle, const char*, int, u16) {
+    std::srand(std::time(nullptr));
+    return std::shared_ptr<BaseDevice>(
+        reinterpret_cast<Devices::BaseDevice*>(new SRandomDevice(handle)));
+}
+int SRandomDevice::ioctl(u64 cmd, Common::VaCtx* args) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 SRandomDevice::write(const void* buf, size_t nbytes) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t SRandomDevice::writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t SRandomDevice::readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 SRandomDevice::preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 SRandomDevice::lseek(s64 offset, int whence) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 SRandomDevice::read(void* buf, size_t nbytes) {
+    auto rbuf = static_cast<char*>(buf);
+    for (size_t i = 0; i < nbytes; i++)
+        rbuf[i] = std::rand();
+    return nbytes;
+}
+
+int SRandomDevice::fstat(Libraries::Kernel::OrbisKernelStat* sb) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s32 SRandomDevice::fsync() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return s32();
+}
+
+int SRandomDevice::ftruncate(s64 length) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int SRandomDevice::getdents(void* buf, u32 nbytes, s64* basep) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 SRandomDevice::pwrite(const void* buf, size_t nbytes, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+} // namespace Core::Devices

src/core/devices/srandom.h

@@ -0,0 +1,33 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+#include <memory>
+#include "base_device.h"
+
+namespace Core::Devices {
+
+class SRandomDevice final : BaseDevice {
+    u32 handle;
+
+public:
+    static std::shared_ptr<BaseDevice> Create(u32 handle, const char*, int, u16);
+    explicit SRandomDevice(u32 handle) : handle(handle) {}
+
+    ~SRandomDevice() override = default;
+
+    int ioctl(u64 cmd, Common::VaCtx* args) override;
+    s64 write(const void* buf, size_t nbytes) override;
+    size_t readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    size_t writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    s64 preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) override;
+    s64 lseek(s64 offset, int whence) override;
+    s64 read(void* buf, size_t nbytes) override;
+    int fstat(Libraries::Kernel::OrbisKernelStat* sb) override;
+    s32 fsync() override;
+    int ftruncate(s64 length) override;
+    int getdents(void* buf, u32 nbytes, s64* basep) override;
+    s64 pwrite(const void* buf, size_t nbytes, u64 offset) override;
+};
+
+} // namespace Core::Devices

src/core/devices/urandom.cpp

@@ -0,0 +1,71 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+#include <cstdlib>
+#include "common/logging/log.h"
+#include "urandom.h"
+
+namespace Core::Devices {
+
+std::shared_ptr<BaseDevice> URandomDevice::Create(u32 handle, const char*, int, u16) {
+    std::srand(std::time(nullptr));
+    return std::shared_ptr<BaseDevice>(
+        reinterpret_cast<Devices::BaseDevice*>(new URandomDevice(handle)));
+}
+
+int URandomDevice::ioctl(u64 cmd, Common::VaCtx* args) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 URandomDevice::write(const void* buf, size_t nbytes) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t URandomDevice::writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t URandomDevice::readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 URandomDevice::preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 URandomDevice::lseek(s64 offset, int whence) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 URandomDevice::read(void* buf, size_t nbytes) {
+    auto rbuf = static_cast<char*>(buf);
+    for (size_t i = 0; i < nbytes; i++)
+        rbuf[i] = std::rand() & 0xFF;
+    return nbytes;
+}
+
+int URandomDevice::fstat(Libraries::Kernel::OrbisKernelStat* sb) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s32 URandomDevice::fsync() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int URandomDevice::ftruncate(s64 length) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int URandomDevice::getdents(void* buf, u32 nbytes, s64* basep) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 URandomDevice::pwrite(const void* buf, size_t nbytes, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+} // namespace Core::Devices

src/core/devices/urandom.h

@@ -0,0 +1,33 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+#include <memory>
+#include "base_device.h"
+
+namespace Core::Devices {
+
+class URandomDevice final : BaseDevice {
+    u32 handle;
+
+public:
+    static std::shared_ptr<BaseDevice> Create(u32 handle, const char*, int, u16);
+    explicit URandomDevice(u32 handle) : handle(handle) {}
+
+    ~URandomDevice() override = default;
+
+    int ioctl(u64 cmd, Common::VaCtx* args) override;
+    s64 write(const void* buf, size_t nbytes) override;
+    size_t readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    size_t writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    s64 preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) override;
+    s64 lseek(s64 offset, int whence) override;
+    s64 read(void* buf, size_t nbytes) override;
+    int fstat(Libraries::Kernel::OrbisKernelStat* sb) override;
+    s32 fsync() override;
+    int ftruncate(s64 length) override;
+    int getdents(void* buf, u32 nbytes, s64* basep) override;
+    s64 pwrite(const void* buf, size_t nbytes, u64 offset) override;
+};
+
+} // namespace Core::Devices