Rework the nvdrv core for accuracy and support new deserialisation

Devices will need to be moved over in order to support this new
interface, IOCTL2/3 support will be added in a later commit.
This commit is contained in:
Billy Laws 2021-07-17 17:13:15 +01:00 committed by ◱ Mark
parent db2abe2290
commit a19bf973b1
9 changed files with 300 additions and 300 deletions

View File

@ -1,4 +1,4 @@
// SPDX-License-Identifier: MPL-2.0
// SPDX-License-Identifier: MIT OR MPL-2.0
// Copyright © 2020 Skyline Team and Contributors (https://github.com/skyline-emu/)
#include <kernel/types/KProcess.h>
@ -6,72 +6,72 @@
#include "driver.h"
#include "devices/nvdevice.h"
#define NVRESULT(x) [&response](NvResult err) { response.Push<NvResult>(err); return Result{}; }(x)
namespace skyline::service::nvdrv {
INvDrvServices::INvDrvServices(const DeviceState &state, ServiceManager &manager) : driver(nvdrv::driver.expired() ? std::make_shared<Driver>(state) : nvdrv::driver.lock()), BaseService(state, manager) {
if (nvdrv::driver.expired())
nvdrv::driver = driver;
}
INvDrvServices::INvDrvServices(const DeviceState &state, ServiceManager &manager, Driver &driver, const SessionPermissions &perms) : BaseService(state, manager), driver(driver), ctx(SessionContext{.perms = perms}) {}
Result INvDrvServices::Open(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
auto path{request.inputBuf.at(0).as_string()};
constexpr FileDescriptor SessionFdLimit{sizeof(u64) * 2 * 8}; //!< Nvdrv uses two 64 bit variables to store a bitset
response.Push<u32>(driver->OpenDevice(path));
response.Push(device::NvStatus::Success);
auto path{request.inputBuf.at(0).as_string(true)};
if (path.empty() || nextFdIndex == SessionFdLimit) {
response.Push<FileDescriptor>(InvalidFileDescriptor);
return NVRESULT(NvResult::FileOperationFailed);
}
return {};
if (auto err{driver.OpenDevice(path, nextFdIndex, ctx)}; err != NvResult::Success) {
response.Push<FileDescriptor>(InvalidFileDescriptor);
return NVRESULT(err);
}
response.Push(nextFdIndex++);
return NVRESULT(NvResult::Success);
}
Result INvDrvServices::Ioctl(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
auto fd{request.Pop<u32>()};
auto cmd{request.Pop<u32>()};
auto fd{request.Pop<FileDescriptor>()};
auto ioctl{request.Pop<IoctlDescriptor>()};
auto device{driver->GetDevice(fd)};
auto inBuf{request.inputBuf.at(0)};
auto outBuf{request.outputBuf.at(0)};
// Strip the permissions from the command leaving only the ID
cmd &= 0xFFFF;
if (ioctl.in && inBuf.size() < ioctl.size)
return NVRESULT(NvResult::InvalidSize);
span<u8> buffer{};
if (request.inputBuf.empty() || request.outputBuf.empty()) {
if (!request.inputBuf.empty())
buffer = request.inputBuf.at(0);
else if (!request.outputBuf.empty())
buffer = request.outputBuf.at(0);
else
throw exception("No IOCTL Buffers");
} else if (request.inputBuf[0].data() == request.outputBuf[0].data()) {
if (request.inputBuf[0].size() >= request.outputBuf[0].size())
buffer = request.inputBuf[0];
else
buffer = request.outputBuf[0];
} else {
throw exception("IOCTL Input Buffer (0x{:X}) != Output Buffer (0x{:X})", request.inputBuf[0].data(), request.outputBuf[0].data());
if (ioctl.out && outBuf.size() < ioctl.size)
return NVRESULT(NvResult::InvalidSize);
if (ioctl.in && ioctl.out) {
if (outBuf.size() < inBuf.size())
return NVRESULT(NvResult::InvalidSize);
// Copy in buf to out buf for inout ioctls to avoid needing to pass around two buffers everywhere
if (outBuf.data() != inBuf.data())
outBuf.copy_from(inBuf, ioctl.size);
}
response.Push(device->HandleIoctl(cmd, device::IoctlType::Ioctl, buffer, {}));
return {};
return NVRESULT(driver.Ioctl(fd, ioctl, ioctl.out ? outBuf : inBuf));
}
Result INvDrvServices::Close(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
auto fd{request.Pop<u32>()};
state.logger->Debug("Closing NVDRV device ({})", fd);
driver->CloseDevice(fd);
driver.CloseDevice(fd);
response.Push(device::NvStatus::Success);
return {};
return NVRESULT(NvResult::Success);
}
Result INvDrvServices::Initialize(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
response.Push(device::NvStatus::Success);
return {};
return NVRESULT(NvResult::Success);
}
Result INvDrvServices::QueryEvent(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
auto fd{request.Pop<u32>()};
auto eventId{request.Pop<u32>()};
auto device{driver->GetDevice(fd)};
auto event{device->QueryEvent(eventId)};
auto event{driver.QueryEvent(fd, eventId)};
if (event != nullptr) {
auto handle{state.process->InsertItem<type::KEvent>(event)};
@ -79,70 +79,16 @@ namespace skyline::service::nvdrv {
state.logger->Debug("FD: {}, Event ID: {}, Handle: 0x{:X}", fd, eventId, handle);
response.copyHandles.push_back(handle);
response.Push(device::NvStatus::Success);
return NVRESULT(NvResult::Success);
} else {
response.Push(device::NvStatus::BadValue);
return NVRESULT(NvResult::BadValue);
}
return {};
}
Result INvDrvServices::SetAruid(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
response.Push(device::NvStatus::Success);
return {};
return NVRESULT(NvResult::Success);
}
Result INvDrvServices::Ioctl2(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
auto fd{request.Pop<u32>()};
auto cmd{request.Pop<u32>()};
auto device{driver->GetDevice(fd)};
// Strip the permissions from the command leaving only the ID
cmd &= 0xFFFF;
if (request.inputBuf.size() < 2 || request.outputBuf.empty())
throw exception("Inadequate amount of buffers for IOCTL2: I - {}, O - {}", request.inputBuf.size(), request.outputBuf.size());
else if (request.inputBuf[0].data() != request.outputBuf[0].data())
throw exception("IOCTL2 Input Buffer (0x{:X}) != Output Buffer (0x{:X}) [Input Buffer #2: 0x{:X}]", request.inputBuf[0].data(), request.outputBuf[0].data(), request.inputBuf[1].data());
span<u8> buffer{};
if (request.inputBuf[0].size() >= request.outputBuf[0].size())
buffer = request.inputBuf[0];
else
buffer = request.outputBuf[0];
response.Push(device->HandleIoctl(cmd, device::IoctlType::Ioctl2, buffer, request.inputBuf[1]));
return {};
}
Result INvDrvServices::Ioctl3(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
auto fd{request.Pop<u32>()};
auto cmd{request.Pop<u32>()};
auto device{driver->GetDevice(fd)};
// Strip the permissions from the command leaving only the ID
cmd &= 0xFFFF;
if (request.inputBuf.empty() || request.outputBuf.empty()) {
throw exception("Inadequate amount of buffers for IOCTL3: I - {}, O - {}", request.inputBuf.size(), request.outputBuf.size());
} else if (request.inputBuf[0].data() != request.outputBuf[0].data()) {
if (request.outputBuf.size() >= 2)
throw exception("IOCTL3 Input Buffer (0x{:X}) != Output Buffer (0x{:X}) [Output Buffer #2: 0x{:X}]", request.inputBuf[0].data(), request.outputBuf[0].data(), request.outputBuf[1].data());
else
throw exception("IOCTL3 Input Buffer (0x{:X}) != Output Buffer (0x{:X})", request.inputBuf[0].data(), request.outputBuf[0].data());
}
span<u8> buffer{};
if (request.inputBuf[0].size() >= request.outputBuf[0].size())
buffer = request.inputBuf[0];
else
buffer = request.outputBuf[0];
response.Push(device->HandleIoctl(cmd, device::IoctlType::Ioctl3, buffer, request.outputBuf.size() >= 2 ? request.outputBuf[1] : span<u8>()));
return {};
}
Result INvDrvServices::SetGraphicsFirmwareMemoryMarginEnabled(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
return {};

View File

@ -1,9 +1,10 @@
// SPDX-License-Identifier: MPL-2.0
// SPDX-License-Identifier: MIT OR MPL-2.0
// Copyright © 2020 Skyline Team and Contributors (https://github.com/skyline-emu/)
#pragma once
#include <services/serviceman.h>
#include "types.h"
namespace skyline::service::nvdrv {
class Driver;
@ -14,10 +15,13 @@ namespace skyline::service::nvdrv {
*/
class INvDrvServices : public BaseService {
private:
std::shared_ptr<Driver> driver;
Driver &driver; //!< The global nvdrv driver this session accesses
SessionContext ctx; //!< Session specific context
FileDescriptor nextFdIndex{1}; //!< The index for the next allocated file descriptor
public:
INvDrvServices(const DeviceState &state, ServiceManager &manager);
INvDrvServices(const DeviceState &state, ServiceManager &manager, Driver &driver, const SessionPermissions &perms);
/**
* @brief Open a specific device and return a FD
@ -59,13 +63,13 @@ namespace skyline::service::nvdrv {
* @brief Perform an IOCTL on the specified FD with an extra input buffer
* @url https://switchbrew.org/wiki/NV_services#Ioctl2
*/
Result Ioctl2(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response);
// Result Ioctl2(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response);
/**
* @brief Perform an IOCTL on the specified FD with an extra output buffer
* @url https://switchbrew.org/wiki/NV_services#Ioctl3
*/
Result Ioctl3(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response);
// Result Ioctl3(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response);
/**
* @brief Enables the graphics firmware memory margin
@ -80,8 +84,7 @@ namespace skyline::service::nvdrv {
SFUNC(0x3, INvDrvServices, Initialize),
SFUNC(0x4, INvDrvServices, QueryEvent),
SFUNC(0x8, INvDrvServices, SetAruid),
SFUNC(0xB, INvDrvServices, Ioctl2),
SFUNC(0xC, INvDrvServices, Ioctl3),
SFUNC(0xD, INvDrvServices, SetGraphicsFirmwareMemoryMarginEnabled)
)
};

View File

@ -0,0 +1,19 @@
// SPDX-License-Identifier: MIT OR MPL-2.0
// Copyright © 2021 Skyline Team and Contributors (https://github.com/skyline-emu/)
#pragma once
#include "nvmap.h"
#include "syncpoint_manager.h"
namespace skyline::service::nvdrv {
/**
* @brief Holds the global state of nvdrv
*/
struct Core {
core::NvMap nvMap;
core::SyncpointManager syncpointManager;
Core(const DeviceState &state) : nvMap(state), syncpointManager(state) {}
};
}

View File

@ -1,11 +1,12 @@
// SPDX-License-Identifier: MPL-2.0
// Copyright © 2020 Skyline Team and Contributors (https://github.com/skyline-emu/)
// SPDX-License-Identifier: MIT OR MPL-2.0
// Copyright © 2021 Skyline Team and Contributors (https://github.com/skyline-emu/)
#include <cxxabi.h>
#include <common/trace.h>
#include "nvdevice.h"
namespace skyline::service::nvdrv::device {
NvDevice::NvDevice(const DeviceState &state, Core &core, const SessionContext &ctx) : state(state), core(core), ctx(ctx) {}
const std::string &NvDevice::GetName() {
if (name.empty()) {
auto mangledName{typeid(*this).name()};
@ -18,32 +19,4 @@ namespace skyline::service::nvdrv::device {
}
return name;
}
NvStatus NvDevice::HandleIoctl(u32 cmd, IoctlType type, span<u8> buffer, span<u8> inlineBuffer) {
std::string_view typeString{[type] {
switch (type) {
case IoctlType::Ioctl:
return "IOCTL";
case IoctlType::Ioctl2:
return "IOCTL2";
case IoctlType::Ioctl3:
return "IOCTL3";
}
}()};
NvDeviceFunctionDescriptor function;
try {
function = GetIoctlFunction(cmd);
state.logger->DebugNoPrefix("{}: {}", typeString, function.name);
} catch (std::out_of_range &) {
state.logger->Warn("Cannot find IOCTL for device '{}': 0x{:X}", GetName(), cmd);
return NvStatus::NotImplemented;
}
TRACE_EVENT("service", perfetto::StaticString{function.name});
try {
return function(type, buffer, inlineBuffer);
} catch (const std::exception &e) {
throw exception("{} ({}: {})", e.what(), typeString, function.name);
}
}
}

View File

@ -1,66 +1,19 @@
// SPDX-License-Identifier: MPL-2.0
// Copyright © 2020 Skyline Team and Contributors (https://github.com/skyline-emu/)
// SPDX-License-Identifier: MIT OR MPL-2.0
// Copyright © 2021 Skyline Team and Contributors (https://github.com/skyline-emu/)
#pragma once
#include <kernel/ipc.h>
#include <kernel/types/KEvent.h>
#include <services/common/result.h>
#include <services/nvdrv/types.h>
#include <services/nvdrv/core/core.h>
#define NV_STRINGIFY(string) #string
#define NVFUNC(id, Class, Function) std::pair<u32, std::pair<NvStatus(Class::*)(IoctlType, span<u8>, span<u8>), const char*>>{id, {&Class::Function, NV_STRINGIFY(Class::Function)}}
#define NVDEVICE_DECL_AUTO(name, value) decltype(value) name = value
#define NVDEVICE_DECL(...) \
NVDEVICE_DECL_AUTO(functions, frz::make_unordered_map({__VA_ARGS__})); \
NvDeviceFunctionDescriptor GetIoctlFunction(u32 id) override { \
auto& function{functions.at(id)}; \
return NvDeviceFunctionDescriptor{ \
reinterpret_cast<DerivedDevice*>(this), \
reinterpret_cast<decltype(NvDeviceFunctionDescriptor::function)>(function.first), \
function.second \
}; \
}
#include "deserialisation/types.h"
namespace skyline::service::nvdrv::device {
using namespace kernel;
/**
* @brief All the possible error codes returned by the Nvidia driver
* @url https://switchbrew.org/wiki/NV_services#Errors
*/
enum class NvStatus : u32 {
Success = 0x0, //!< The operation has succeeded
NotImplemented = 0x1, //!< The operation is not implemented
NotSupported = 0x2, //!< The operation is not supported
NotInitialized = 0x3, //!< The operation uses an uninitialized object
BadParameter = 0x4, //!< The operation was provided a bad parameter
Timeout = 0x5, //!< The operation has timed out
InsufficientMemory = 0x6, //!< The device ran out of memory during the operation
ReadOnlyAttribute = 0x7, //!< The mutating operation was performed on a read only section
InvalidState = 0x8, //!< The state of the device was invalid
InvalidAddress = 0x9, //!< The provided address is invalid
InvalidSize = 0xA, //!< The provided size is invalid
BadValue = 0xB, //!< The operation was provided a bad value
AlreadyAllocated = 0xD, //!< An object was tried to be reallocated
Busy = 0xE, //!< The device is busy
ResourceError = 0xF, //!< There was an error accessing the resource
CountMismatch = 0x10, //!< ?
SharedMemoryTooSmall = 0x1000, //!< The shared memory segment is too small
FileOperationFailed = 0x30003, //!< The file operation has failed
DirOperationFailed = 0x30004, //!< The directory operation has failed
IoctlFailed = 0x3000F, //!< The IOCTL operation has failed
AccessDenied = 0x30010, //!< The access to a resource was denied
FileNotFound = 0x30013, //!< A file was not found
ModuleNotPresent = 0xA000E, //!< A module was not present
};
/**
* @brief The IOCTL call variants, they have different buffer configurations
*/
enum class IoctlType : u8 {
Ioctl, //!< 1 input/output buffer
Ioctl2, //!< 1 input/output buffer + 1 input buffer
Ioctl3, //!< 1 input/output buffer + 1 output buffer
};
using namespace deserialisation;
/**
* @brief NvDevice is the base class that all /dev/nv* devices inherit from
@ -71,40 +24,25 @@ namespace skyline::service::nvdrv::device {
protected:
const DeviceState &state;
class DerivedDevice; //!< A placeholder derived class which is used for class function semantics
/**
* @brief A per-function descriptor for NvDevice functions
*/
struct NvDeviceFunctionDescriptor {
DerivedDevice *clazz; //!< A pointer to the class that this was derived from, it's used as the 'this' pointer for the function
NvStatus (DerivedDevice::*function)(IoctlType, span<u8>, span<u8>); //!< A function pointer to the implementation of the function
const char *name; //!< A pointer to a static string in the format "Class::Function" for the specific device class/function
constexpr NvStatus operator()(IoctlType type, span<u8> buffer, span<u8> inlineBuffer) {
return (clazz->*function)(type, buffer, inlineBuffer);
}
};
Core &core;
SessionContext ctx;
public:
NvDevice(const DeviceState &state) : state(state) {}
NvDevice(const DeviceState &state, Core &core, const SessionContext &ctx);
virtual ~NvDevice() = default;
virtual NvDeviceFunctionDescriptor GetIoctlFunction(u32 id) = 0;
/**
* @return The name of the class
* @note The lifetime of the returned string is tied to that of the class
*/
const std::string &GetName();
/**
* @brief Handles IOCTL calls for devices
* @param cmd The IOCTL command that was called
*/
NvStatus HandleIoctl(u32 cmd, IoctlType type, span<u8> buffer, span<u8> inlineBuffer);
virtual PosixResult Ioctl(IoctlDescriptor cmd, span<u8> buffer) = 0;
virtual PosixResult Ioctl2(IoctlDescriptor cmd, span<u8> buffer, span<u8> inlineOutput) { return PosixResult::NotSupported; }
virtual PosixResult Ioctl3(IoctlDescriptor cmd, span<u8> buffer, span<u8> inlineInput) { return PosixResult::NotSupported; }
virtual std::shared_ptr<kernel::type::KEvent> QueryEvent(u32 eventId) {
return nullptr;

View File

@ -1,61 +1,121 @@
// SPDX-License-Identifier: MPL-2.0
// SPDX-License-Identifier: MIT OR MPL-2.0
// Copyright © 2020 Skyline Team and Contributors (https://github.com/skyline-emu/)
#include "driver.h"
#include "devices/nvhost_ctrl.h"
#include "devices/nvhost_ctrl_gpu.h"
#include "devices/nvmap.h"
#include "devices/nvhost_channel.h"
#include "devices/nvhost_as_gpu.h"
#include "devices/nvhost/ctrl.h"
#include "devices/nvhost/ctrl_gpu.h"
#include "devices/nvhost/gpu_channel.h"
#include "devices/nvhost/as_gpu.h"
namespace skyline::service::nvdrv {
Driver::Driver(const DeviceState &state) : state(state), hostSyncpoint(state) {}
Driver::Driver(const DeviceState &state) : state(state), core(state) {}
u32 Driver::OpenDevice(std::string_view path) {
state.logger->Debug("Opening NVDRV device ({}): {}", fdIndex, path);
NvResult Driver::OpenDevice(std::string_view path, FileDescriptor fd, const SessionContext &ctx) {
state.logger->Debug("Opening NvDrv device ({}): {}", fd, path);
auto pathHash{util::Hash(path)};
switch (util::Hash(path)) {
#define NVDEVICE(type, name, devicePath) \
case util::Hash(devicePath): { \
std::shared_ptr<device::type> device{}; \
if (name.expired()) { \
device = std::make_shared<device::type>(state); \
name = device; \
} else { \
device = name.lock(); \
} \
devices.push_back(device); \
break; \
}
NVDEVICE_LIST
#undef NVDEVICE
#define DEVICE_SWITCH(cases) \
switch (pathHash) { \
cases; \
default: \
break; \
}
default:
throw exception("Cannot find NVDRV device");
#define DEVICE_CASE(path, object) \
case util::Hash(path): \
devices.emplace(fd, std::make_unique<device::object>(state, core, ctx)); \
return NvResult::Success;
DEVICE_SWITCH(
DEVICE_CASE("/dev/nvmap", NvMap)
DEVICE_CASE("/dev/nvhost-ctrl", nvhost::Ctrl)
);
if (ctx.perms.AccessGpu) {
DEVICE_SWITCH(
DEVICE_CASE("/dev/nvhost-as-gpu", nvhost::AsGpu)
DEVICE_CASE("/dev/nvhost-ctrl-gpu", nvhost::CtrlGpu)
DEVICE_CASE("/dev/nvhost-gpu", nvhost::GpuChannel)
);
}/*
if (ctx.perms.AccessVic) {
switch (pathHash) {
ENTRY("/dev/nvhost-vic", nvhost::Vic)
default:
break;
}
}
return fdIndex++;
if (ctx.perms.AccessVideoDecoder) {
switch (pathHash) {
ENTRY("/dev/nvhost-nvdec", nvhost::NvDec)
default:
break;
}
}
if (ctx.perms.AccessJpeg) {
switch (pathHash) {
ENTRY("/dev/nvhost-nvjpg", nvhost::NvJpg)
default:
break;
}
}*/
#undef DEVICE_CASE
#undef DEVICE_SWITCH
// Device doesn't exist/no permissions
return NvResult::FileOperationFailed;
}
std::shared_ptr<device::NvDevice> Driver::GetDevice(u32 fd) {
static NvResult ConvertResult(PosixResult result) {
switch (result) {
case PosixResult::Success:
return NvResult::Success;
case PosixResult::NotPermitted:
return NvResult::AccessDenied;
case PosixResult::TryAgain:
return NvResult::Timeout;
case PosixResult::Busy:
return NvResult::Busy;
case PosixResult::InvalidArgument:
return NvResult::BadValue;
case PosixResult::InappropriateIoctlForDevice:
return NvResult::IoctlFailed;
case PosixResult::NotSupported:
return NvResult::NotSupported;
case PosixResult::TimedOut:
return NvResult::Timeout;
default:
throw exception("Unhandled POSIX result: {}!", static_cast<i32>(result));
}
}
NvResult Driver::Ioctl(u32 fd, IoctlDescriptor cmd, span<u8> buffer) {
try {
auto item{devices.at(fd)};
if (!item)
throw exception("GetDevice was called with a closed file descriptor: 0x{:X}", fd);
return item;
} catch (std::out_of_range) {
return ConvertResult(devices.at(fd)->Ioctl(cmd, buffer));
} catch (const std::out_of_range &) {
throw exception("GetDevice was called with invalid file descriptor: 0x{:X}", fd);
}
}
void Driver::CloseDevice(u32 fd) {
try {
auto &device{devices.at(fd)};
device.reset();
devices.at(fd).reset();
} catch (const std::out_of_range &) {
state.logger->Warn("Trying to close non-existent FD");
}
}
std::weak_ptr<Driver> driver{};
std::shared_ptr<kernel::type::KEvent> Driver::QueryEvent(u32 fd, u32 eventId) {
try {
return devices.at(fd)->QueryEvent(eventId);
} catch (const std::exception &) {
throw exception("QueryEvent was called with invalid file descriptor: 0x{:X}", fd);
}
}
}

View File

@ -1,76 +1,45 @@
// SPDX-License-Identifier: MPL-2.0
// SPDX-License-Identifier: MIT OR MPL-2.0
// Copyright © 2020 Skyline Team and Contributors (https://github.com/skyline-emu/)
#pragma once
#include "devices/nvhost_syncpoint.h"
#define NVDEVICE_LIST \
NVDEVICE(NvHostCtrl, nvHostCtrl, "/dev/nvhost-ctrl") \
NVDEVICE(NvHostChannel, nvHostGpu, "/dev/nvhost-gpu") \
NVDEVICE(NvHostChannel, nvHostNvdec, "/dev/nvhost-nvdec") \
NVDEVICE(NvHostChannel, nvHostVic, "/dev/nvhost-vic") \
NVDEVICE(NvMap, nvMap, "/dev/nvmap") \
NVDEVICE(NvHostAsGpu, nvHostAsGpu, "/dev/nvhost-as-gpu") \
NVDEVICE(NvHostCtrlGpu, nvHostCtrlGpu, "/dev/nvhost-ctrl-gpu")
#include <common.h>
#include "types.h"
#include "devices/nvdevice.h"
#include "core/core.h"
namespace skyline::service::nvdrv {
namespace device {
class NvDevice;
#define NVDEVICE(type, name, path) class type;
NVDEVICE_LIST
#undef NVDEVICE
}
/**
* @brief nvnflinger:dispdrv or nns::hosbinder::IHOSBinderDriver is responsible for writing buffers to the display
*/
class Driver {
private:
const DeviceState &state;
std::vector<std::shared_ptr<device::NvDevice>> devices; //!< A vector of shared pointers to NvDevice object that correspond to FDs
u32 fdIndex{}; //!< The next file descriptor to assign
std::unordered_map<FileDescriptor, std::unique_ptr<device::NvDevice>> devices;
public:
NvHostSyncpoint hostSyncpoint;
#define NVDEVICE(type, name, path) std::weak_ptr<device::type> name;
NVDEVICE_LIST
#undef NVDEVICE
Core core; //!< The core global state object of nvdrv that is accessed by devices
Driver(const DeviceState &state);
/**
* @brief Open a specific device and return a FD
* @param path The path of the device to open an FD to
* @return The file descriptor to the device
* @brief Creates a new device as specified by path
* @param path The /dev path that corresponds to the device
* @param fd The fd that will be used to refer to the device
* @param ctx The context to be attached to the device
*/
u32 OpenDevice(std::string_view path);
NvResult OpenDevice(std::string_view path, FileDescriptor fd, const SessionContext &ctx);
/**
* @brief Returns a particular device with a specific FD
* @param fd The file descriptor to retrieve
* @return A shared pointer to the device
* @brief Calls an IOCTL on the device specified by `fd`
*/
std::shared_ptr<device::NvDevice> GetDevice(u32 fd);
NvResult Ioctl(u32 fd, IoctlDescriptor cmd, span<u8> buffer);
/**
* @brief Returns a particular device with a specific FD
* @tparam objectClass The class of the device to return
* @param fd The file descriptor to retrieve
* @return A shared pointer to the device
* @brief Queries a KEvent for the given `eventId` for the device specified by `fd`
*/
template<typename objectClass>
std::shared_ptr<objectClass> GetDevice(u32 fd) {
return std::static_pointer_cast<objectClass>(GetDevice(fd));
}
std::shared_ptr<kernel::type::KEvent> QueryEvent(u32 fd, u32 eventId);
/**
* @brief Closes the specified device with its file descriptor
* @brief Closes the device specified by `fd`
*/
void CloseDevice(u32 fd);
};
extern std::weak_ptr<Driver> driver; //!< A globally shared instance of the Driver
}

View File

@ -0,0 +1,93 @@
// SPDX-License-Identifier: MIT OR MPL-2.0
// Copyright © 2021 Skyline Team and Contributors (https://github.com/skyline-emu/)
#pragma once
#include <common.h>
namespace skyline::service::nvdrv {
using FileDescriptor = i32;
constexpr FileDescriptor InvalidFileDescriptor{-1};
/**
* @brief Holds the permissions for an nvdrv instance
*/
struct SessionPermissions {
bool AccessGpu;
bool AccessGpuDebug;
bool AccessGpuSchedule;
bool AccessVic;
bool AccessVideoEncoder;
bool AccessVideoDecoder;
bool AccessTsec;
bool AccessJpeg;
bool AccessDisplay;
bool AccessImportMemory;
bool NoCheckedAruid;
bool ModifyGraphicsMargin;
bool DuplicateNvMapHandles;
bool ExportNvMapHandles;
};
/**
* @brief Holds the per-session context for nvdrv
*/
struct SessionContext {
SessionPermissions perms;
bool internalSession;
};
/**
* @brief Permissions that applications have when using the 'nvdrv' service
*/
static constexpr SessionPermissions ApplicationSessionPermissions {
.AccessGpu = true,
.AccessGpuDebug = true,
.AccessVic = true,
.AccessVideoDecoder = true,
.ModifyGraphicsMargin = true
};
/**
* @brief An bitfield struct that unpacks an ioctl number, used as an alternative to Linux's macros
*/
union IoctlDescriptor {
struct {
u8 function; //!< The function number corresponding to a specific call in the driver
i8 magic; //!< Unique to each driver
u16 size : 14; //!< Size of the argument buffer
bool in : 1; //!< Guest is writing, we are reading
bool out : 1; //!< Guest is reading, we are writing
};
u32 raw;
};
static_assert(sizeof(IoctlDescriptor) == sizeof(u32));
/**
* @brief NvRm result codes that are translated from the POSIX error codes used internally
* @url https://switchbrew.org/wiki/NV_services#NvError
*/
enum class NvResult : i32 {
Success = 0x0,
NotImplemented = 0x1,
NotSupported = 0x2,
NotInitialized = 0x3,
BadParameter = 0x4,
Timeout = 0x5,
InsufficientMemory = 0x6,
ReadOnlyAttribute = 0x7,
InvalidState = 0x8,
InvalidAddress = 0x9,
InvalidSize = 0xA,
BadValue = 0xB,
AlreadyAllocated = 0xD,
Busy = 0xE,
ResourceError = 0xF,
CountMismatch = 0x10,
Overflow = 0x11,
FileOperationFailed = 0x30003,
AccessDenied = 0x30010,
IoctlFailed = 0x3000F
};
}

View File

@ -18,7 +18,8 @@
#include "glue/IStaticService.h"
#include "services/timesrv/core.h"
#include "fssrv/IFileSystemProxy.h"
#include "services/nvdrv/INvDrvServices.h"
#include "nvdrv/INvDrvServices.h"
#include "nvdrv/driver.h"
#include "hosbinder/IHOSBinderDriver.h"
#include "visrv/IApplicationRootService.h"
#include "visrv/ISystemRootService.h"
@ -48,8 +49,9 @@
namespace skyline::service {
struct GlobalServiceState {
timesrv::core::TimeServiceObject timesrv;
nvdrv::Driver nvdrv;
explicit GlobalServiceState(const DeviceState &state) : timesrv(state) {}
explicit GlobalServiceState(const DeviceState &state) : timesrv(state), nvdrv(state) {}
};
ServiceManager::ServiceManager(const DeviceState &state) : state(state), smUserInterface(std::make_shared<sm::IUserInterface>(state, *this)), globalServiceState(std::make_shared<GlobalServiceState>(state)) {}
@ -76,11 +78,8 @@ namespace skyline::service {
SERVICE_CASE(glue::IStaticService, "time:r", globalServiceState->timesrv.managerServer.GetStaticServiceAsRepair(state, *this), globalServiceState->timesrv, timesrv::constant::StaticServiceRepairPermissions)
SERVICE_CASE(glue::IStaticService, "time:u", globalServiceState->timesrv.managerServer.GetStaticServiceAsUser(state, *this), globalServiceState->timesrv, timesrv::constant::StaticServiceUserPermissions)
SERVICE_CASE(fssrv::IFileSystemProxy, "fsp-srv")
SERVICE_CASE(nvdrv::INvDrvServices, "nvdrv")
SERVICE_CASE(nvdrv::INvDrvServices, "nvdrv:a")
SERVICE_CASE(nvdrv::INvDrvServices, "nvdrv:s")
SERVICE_CASE(nvdrv::INvDrvServices, "nvdrv:t")
SERVICE_CASE(hosbinder::IHOSBinderDriver, "dispdrv")
SERVICE_CASE(nvdrv::INvDrvServices, "nvdrv", globalServiceState->nvdrv, nvdrv::ApplicationSessionPermissions)
SERVICE_CASE(hosbinder::IHOSBinderDriver, "dispdrv", globalServiceState->nvdrv.core.nvMap)
SERVICE_CASE(visrv::IApplicationRootService, "vi:u")
SERVICE_CASE(visrv::ISystemRootService, "vi:s")
SERVICE_CASE(visrv::IManagerRootService, "vi:m")