The-Homebrew-Cloud/skyline
2
0
Fork 0
mirror of https://github.com/skyline-emu/skyline.git synced 2024-06-01 12:28:48 +02:00
Code Issues Packages Projects Releases Wiki Activity

Fix CircularQueue + NPDM ACI0 & Kernel Capability Parsing

Browse Source
This commit is contained in:
◱ PixelyIon 2020-11-20 23:57:53 +05:30 committed by ◱ PixelyIon
parent a5927c5c7b
commit bc5c094860
19 changed files with 277 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
app/src/main/cpp/skyline/common.h
View File

@ -26,6 +26,19 @@
#define FORCE_INLINE __attribute__((always_inline)) inline // NOLINT(cppcoreguidelines-macro-usage)
namespace fmt {
/**
* @brief A std::bitset formatter for {fmt}
*/
template <size_t N>
struct formatter<std::bitset<N>>: formatter<std::string> {
template <typename FormatContext>
constexpr auto format(const std::bitset<N> &s, FormatContext &ctx) {
return formatter<std::string>::format(s.to_string(), ctx);
}
};
}
namespace skyline {
using u128 = __uint128_t; //!< Unsigned 128-bit integer
using u64 = __uint64_t; //!< Unsigned 64-bit integer
@ -79,7 +92,7 @@ namespace skyline {
namespace util {
/**
* @brief A way to implicitly cast all pointers to u64s, this is used for libfmt as we use 0x{:X} to print pointers
* @brief A way to implicitly cast all pointers to u64s, this is used for {fmt} as we use 0x{:X} to print pointers
* @note There's the exception of signed char pointers as they represent C Strings
* @note This does not cover std::shared_ptr or std::unique_ptr and those will have to be explicitly casted to u64 or passed through fmt::ptr
*/
@ -96,12 +109,12 @@ namespace skyline {
}
/**
* @brief A wrapper over std::runtime_error with libfmt formatting
* @brief A wrapper over std::runtime_error with {fmt} formatting
*/
class exception : public std::runtime_error {
public:
/**
* @param formatStr The exception string to be written, with libfmt formatting
* @param formatStr The exception string to be written, with {fmt} formatting
* @param args The arguments based on format_str
*/
template<typename S, typename... Args>

37
app/src/main/cpp/skyline/common/circular_queue.h
View File

@ -49,18 +49,11 @@ namespace skyline {
produceCondition.wait(lock, [this]() { return start != end; });
}
ssize_t size{};
if (start < end)
size = end - start;
else
size = (reinterpret_cast<Type *>(vector.end().base()) - start) + (end - reinterpret_cast<Type *>(vector.begin().base()));
while (size--) {
function(*start);
if (start + 1 != reinterpret_cast<Type *>(vector.end().base()))
start++;
else
start = reinterpret_cast<Type *>(vector.begin().base());
while (start != end) {
auto next{start + 1};
next = (next == reinterpret_cast<Type *>(vector.end().base())) ? reinterpret_cast<Type *>(vector.begin().base()) : next;
function(*next);
start = next;
}
consumeCondition.notify_one();
@ -81,12 +74,14 @@ namespace skyline {
inline void Append(span<Type> buffer) {
std::unique_lock lock(productionMutex);
for (auto &item : buffer) {
end = (end == reinterpret_cast<Type *>(vector.end().base()) - 1) ? reinterpret_cast<Type *>(vector.begin().base()) : end;
if (start == end + 1) {
auto next{end + 1};
next = (next == reinterpret_cast<Type *>(vector.end().base())) ? reinterpret_cast<Type *>(vector.begin().base()) : next;
if (next == start) {
std::unique_lock consumeLock(consumptionMutex);
consumeCondition.wait(consumeLock, [=]() { return start != end + 1; });
consumeCondition.wait(consumeLock, [=]() { return next != start; });
}
*(end++) = item;
*next = item;
end = next++;
}
produceCondition.notify_one();
}
@ -99,12 +94,14 @@ namespace skyline {
inline void AppendTranform(span<TransformedType> buffer, Transformation transformation) {
std::unique_lock lock(productionMutex);
for (auto &item : buffer) {
end = (end == reinterpret_cast<Type *>(vector.end().base()) - 1) ? reinterpret_cast<Type *>(vector.begin().base()) : end;
if (start == end + 1) {
auto next{end + 1};
next = (next == reinterpret_cast<Type *>(vector.end().base())) ? reinterpret_cast<Type *>(vector.begin().base()) : next;
if (next == start) {
std::unique_lock consumeLock(consumptionMutex);
consumeCondition.wait(consumeLock, [=]() { return start != end + 1; });
consumeCondition.wait(consumeLock, [=]() { return next != start; });
}
*(end++) = transformation(item);
*next = transformation(item);
end = next;
}
produceCondition.notify_one();
}

2
app/src/main/cpp/skyline/crypto/key_store.cpp
View File

@ -15,7 +15,7 @@ namespace skyline::crypto {
void KeyStore::ReadPairs(const std::shared_ptr<vfs::Backing> &backing, ReadPairsCallback callback) {
std::vector<char> fileContent(backing->size);
backing->Read(span(fileContent).cast<u8>());
backing->Read(span(fileContent));
auto lineStart{fileContent.begin()};
std::vector<char>::iterator lineEnd;

2
app/src/main/cpp/skyline/gpu/gpfifo.h
View File

@ -68,7 +68,7 @@ namespace skyline::gpu {
};
};
constexpr u64 Address() {
constexpr u64 Address() const {
return (static_cast<u64>(getHi) << 32) | (static_cast<u64>(get) << 2);
}
};

2
app/src/main/cpp/skyline/kernel/memory.h
View File

@ -182,7 +182,7 @@ namespace skyline {
AddressSpace32Bit = 0, //!< 32-bit address space used by 32-bit applications
AddressSpace36Bit = 1, //!< 36-bit address space used by 64-bit applications before 2.0.0
AddressSpace32BitNoReserved = 2, //!< 32-bit address space without the map region
AddressSpace39Bit, //!< 39-bit address space used by 64-bit applications after 2.0.0
AddressSpace39Bit = 3, //!< 39-bit address space used by 64-bit applications after 2.0.0
};
}

32
app/src/main/cpp/skyline/kernel/scheduler.h Normal file
View File

@ -0,0 +1,32 @@
// SPDX-License-Identifier: MPL-2.0
// Copyright © 2020 Skyline Team and Contributors (https://github.com/skyline-emu/)
#pragma once
#include <common.h>
namespace skyline {
namespace constant {
constexpr u8 CoreCount{4}; // The amount of cores an HOS process can be scheduled onto (User applications can only be on the first 3 cores, the last one is reserved for the system)
}
namespace kernel {
using CoreMask = std::bitset<constant::CoreCount>;
struct Priority {
u8 min;
u8 max;
constexpr u64 Mask() const {
u64 mask{};
for (u8 i{min}; i <= max; i++)
mask |= 1 << i;
return mask;
}
constexpr bool Valid(i8 value) const {
return (value >= min) && (value <= max);
}
};
}
}

59
app/src/main/cpp/skyline/kernel/svc.cpp
View File

@ -3,6 +3,7 @@
#include <os.h>
#include <kernel/types/KProcess.h>
#include <vfs/npdm.h>
#include "results.h"
#include "svc.h"
@ -239,7 +240,7 @@ namespace skyline::kernel::svc {
return;
}
if (!constant::HosPriority.Valid(priority)) {
if (!state.process->npdm.threadInfo.priority.Valid(priority)) {
state.ctx->gpr.w0 = result::InvalidPriority;
state.logger->Warn("svcCreateThread: 'priority' invalid: {}", priority);
return;
@ -251,7 +252,7 @@ namespace skyline::kernel::svc {
auto thread{state.process->CreateThread(entry, entryArgument, stackTop, priority, idealCore)};
if (thread) {
state.logger->Debug("svcCreateThread: Created thread with handle 0x{:X} (Entry Point: 0x{:X}, Argument: 0x{:X}, Stack Pointer: 0x{:X}, Priority: {}, ID: {})", thread->handle, entry, entryArgument, stackTop, priority, thread->id);
state.logger->Debug("svcCreateThread: Created thread #{} with handle 0x{:X} (Entry Point: 0x{:X}, Argument: 0x{:X}, Stack Pointer: 0x{:X}, Priority: {}, Ideal Core: {})", thread->id, thread->handle, entry, entryArgument, stackTop, priority, idealCore);
state.ctx->gpr.w1 = thread->handle;
state.ctx->gpr.w0 = Result{};
@ -316,7 +317,7 @@ namespace skyline::kernel::svc {
void SetThreadPriority(const DeviceState &state) {
KHandle handle{state.ctx->gpr.w0};
u32 priority{state.ctx->gpr.w1};
if (!constant::HosPriority.Valid(priority)) {
if (!state.process->npdm.threadInfo.priority.Valid(priority)) {
state.logger->Warn("svcSetThreadPriority: 'priority' invalid: 0x{:X}", priority);
state.ctx->gpr.w0 = result::InvalidPriority;
return;
@ -338,7 +339,7 @@ namespace skyline::kernel::svc {
auto thread{state.process->GetHandle<type::KThread>(handle)};
auto idealCore{thread->idealCore};
auto affinityMask{thread->affinityMask};
state.logger->Debug("svcGetThreadCoreMask: Writing thread #{}'s Ideal Core ({}) + Affinity Mask ({})", thread->id, idealCore, affinityMask.to_string());
state.logger->Debug("svcGetThreadCoreMask: Writing thread #{}'s Ideal Core ({}) + Affinity Mask ({})", thread->id, idealCore, affinityMask);
state.ctx->gpr.x2 = affinityMask.to_ullong();
state.ctx->gpr.w1 = idealCore;
@ -351,29 +352,36 @@ namespace skyline::kernel::svc {
void SetThreadCoreMask(const DeviceState &state) {
KHandle handle{state.ctx->gpr.w0};
i32 idealCore{static_cast<i32>(state.ctx->gpr.w1)};
std::bitset<constant::CoreCount> affinityMask{state.ctx->gpr.x2};
i32 coreId{static_cast<i32>(state.ctx->gpr.w1)};
CoreMask affinityMask{state.ctx->gpr.x2};
try {
auto thread{state.process->GetHandle<type::KThread>(handle)};
if (idealCore == IdealCoreUseProcessValue) {
idealCore = state.process->npdm.meta.idealCore;
affinityMask.reset().set(idealCore);
} else if (idealCore == IdealCoreNoUpdate) {
idealCore = thread->idealCore;
} else if (idealCore == IdealCoreDontCare) {
idealCore = __builtin_ctzll(affinityMask.to_ullong()); // The first enabled core in the affinity mask
if (coreId == IdealCoreUseProcessValue) {
coreId = state.process->npdm.meta.idealCore;
affinityMask.reset().set(coreId);
} else if (coreId == IdealCoreNoUpdate) {
coreId = thread->idealCore;
} else if (coreId == IdealCoreDontCare) {
coreId = __builtin_ctzll(affinityMask.to_ullong()); // The first enabled core in the affinity mask
}
if (affinityMask.none() || !affinityMask.test(idealCore)) {
state.logger->Warn("svcSetThreadCoreMask: 'affinityMask' invalid: {} (Ideal Core: {})", affinityMask.to_string(), idealCore);
auto processMask{state.process->npdm.threadInfo.coreMask};
if ((processMask | affinityMask) == processMask) {
state.logger->Warn("svcSetThreadCoreMask: 'affinityMask' invalid: {} (Process Mask: {})", affinityMask, processMask);
state.ctx->gpr.w0 = result::InvalidCoreId;
return;
}
if (affinityMask.none() || !affinityMask.test(coreId)) {
state.logger->Warn("svcSetThreadCoreMask: 'affinityMask' invalid: {} (Ideal Core: {})", affinityMask, coreId);
state.ctx->gpr.w0 = result::InvalidCombination;
return;
}
state.logger->Debug("svcSetThreadCoreMask: Setting thread #{}'s Ideal Core ({}) + Affinity Mask ({})", thread->id, idealCore, affinityMask.to_string());
state.logger->Debug("svcSetThreadCoreMask: Setting thread #{}'s Ideal Core ({}) + Affinity Mask ({})", thread->id, coreId, affinityMask);
thread->idealCore = idealCore;
thread->idealCore = coreId;
thread->affinityMask = affinityMask;
state.ctx->gpr.w0 = Result{};
@ -735,7 +743,7 @@ namespace skyline::kernel::svc {
// 3.0.0+
TotalSystemResourceAvailable = 16,
TotalSystemResourceUsage = 17,
TitleId = 18,
ProgramId = 18,
// 4.0.0+
PrivilegedProcessId = 19,
// 5.0.0+
@ -753,13 +761,18 @@ namespace skyline::kernel::svc {
u64 out{};
switch (info) {
case InfoState::AllowedCpuIdBitmask:
case InfoState::AllowedThreadPriorityMask:
case InfoState::IsCurrentProcessBeingDebugged:
case InfoState::TitleId:
case InfoState::PrivilegedProcessId:
break;
case InfoState::AllowedCpuIdBitmask:
out = state.process->npdm.threadInfo.coreMask.to_ullong();
break;
case InfoState::AllowedThreadPriorityMask:
out = state.process->npdm.threadInfo.priority.Mask();
break;
case InfoState::AliasRegionBaseAddr:
out = state.process->memory.alias.address;
break;
@ -813,6 +826,10 @@ namespace skyline::kernel::svc {
out = std::min(static_cast<size_t>(state.process->npdm.meta.systemResourceSize), state.process->memory.GetKMemoryBlockSize());
break;
case InfoState::ProgramId:
out = state.process->npdm.aci0.programId;
break;
case InfoState::TotalMemoryAvailableWithoutSystemResource:
out = totalPhysicalMemory - state.process->npdm.meta.systemResourceSize;
break;

1
app/src/main/cpp/skyline/kernel/types/KProcess.h
View File

@ -4,7 +4,6 @@
#pragma once
#include <list>
#include <kernel/memory.h>
#include <vfs/npdm.h>
#include "KThread.h"
#include "KTransferMemory.h"

34
app/src/main/cpp/skyline/kernel/types/KThread.h
View File

@ -5,40 +5,12 @@
#include <csetjmp>
#include <nce/guest.h>
#include <kernel/scheduler.h>
#include "KSyncObject.h"
#include "KPrivateMemory.h"
#include "KSharedMemory.h"
namespace skyline {
namespace kernel::type {
struct Priority {
i8 low; //!< The low range of priority
i8 high; //!< The high range of priority
/**
* @param priority The priority range of the value
* @param value The priority value to rescale
* @return The rescaled priority value according to this range
*/
constexpr i8 Rescale(const Priority &priority, i8 value) const {
return static_cast<i8>(priority.low + ((static_cast<float>(priority.high - priority.low) / static_cast<float>(priority.low - priority.high)) * (static_cast<float>(value) - priority.low)));
}
/**
* @param value The priority value to check for validity
* @return If the supplied priority value is valid
*/
constexpr bool Valid(i8 value) const {
return (value >= low) && (value <= high);
}
};
}
namespace constant {
constexpr u8 CoreCount{4}; // The amount of cores an HOS process can be scheduled onto (User applications can only be on the first 3 cores, the last one is reserved for the system)
constexpr kernel::type::Priority HosPriority{0, 63}; //!< The range of priorities for Horizon OS
}
namespace kernel::type {
/**
* @brief KThread manages a single thread of execution which is responsible for running guest code and kernel code which is invoked by the guest
@ -67,9 +39,9 @@ namespace skyline {
void *stackTop;
i8 priority;
i8 idealCore;
i8 idealCore; //!< The ideal CPU core for this thread to run on
i8 coreId; //!< The CPU core on which this thread is running
std::bitset<constant::CoreCount> affinityMask{}; //!< The CPU core on which this thread is running
CoreMask affinityMask{}; //!< A mask of CPU cores this thread is allowed to run on
KThread(const DeviceState &state, KHandle handle, KProcess *parent, size_t id, void *entry, u64 argument, void *stackTop, i8 priority, i8 idealCore);

2
app/src/main/cpp/skyline/loader/nca.cpp
View File

@ -45,7 +45,7 @@ namespace skyline::loader {
}
void *NcaLoader::LoadProcessData(const std::shared_ptr<kernel::type::KProcess> process, const DeviceState &state) {
process->npdm = vfs::NPDM(nca.exeFs->OpenFile("main.npdm"));
process->npdm = vfs::NPDM(nca.exeFs->OpenFile("main.npdm"), state);
return LoadExeFs(nca.exeFs, process, state);
}
}

2
app/src/main/cpp/skyline/loader/nsp.cpp
View File

@ -36,7 +36,7 @@ namespace skyline::loader {
}
void *NspLoader::LoadProcessData(const std::shared_ptr<kernel::type::KProcess> process, const DeviceState &state) {
process->npdm = vfs::NPDM(programNca->exeFs->OpenFile("main.npdm"));
process->npdm = vfs::NPDM(programNca->exeFs->OpenFile("main.npdm"), state);
return NcaLoader::LoadExeFs(programNca->exeFs, process, state);
}

2
app/src/main/cpp/skyline/services/nvdrv/devices/nvhost_channel.cpp
View File

@ -107,7 +107,7 @@ namespace skyline::service::nvdrv::device {
u32 numJobs; // In
u32 flags; // In
Fence fence; // Out
u32 reserved[3]; // In
u32 _res_[3]; // In
} &data = buffer.as<Data>();
state.gpu->gpfifo.Initialize(data.numEntries);

4
app/src/main/cpp/skyline/services/nvdrv/devices/nvhost_ctrl_gpu.cpp
View File

@ -48,7 +48,7 @@ namespace skyline::service::nvdrv::device {
u32 smArchSpaVersion{0x503}; // Maxwell Generation 5.0.3
u32 smArchWarpCount{0x80};
u32 gpuVaBitCount{0x28};
u32 reserved{};
u32 _res_{};
u64 flags{0x55}; // HAS_SYNCPOINTS | SUPPORT_SPARSE_ALLOCS | SUPPORT_CYCLE_STATS | SUPPORT_CYCLE_STATS_SNAPSHOT
u32 twodClass{0x902D}; // FERMI_TWOD_A
u32 threedClass{0xB197}; // MAXWELL_B
@ -92,7 +92,7 @@ namespace skyline::service::nvdrv::device {
NvStatus NvHostCtrlGpu::GetTpcMasks(IoctlType type, span<u8> buffer, span<u8> inlineBuffer) {
struct Data {
u32 maskBufSize; // In
u32 reserved[3]; // In
u32 _res_[3]; // In
u64 maskBuf; // Out
} &data = buffer.as<Data>();

2
app/src/main/cpp/skyline/services/nvdrv/devices/nvhost_syncpoint.h
View File

@ -18,7 +18,7 @@ namespace skyline::service::nvdrv {
std::atomic<u32> counterMin; //!< The least value the syncpoint can be (The value it was when it was last synchronized with host1x)
std::atomic<u32> counterMax; //!< The maximum value the syncpoint can reach according to the current usage
bool interfaceManaged; //!< If the syncpoint is managed by a host1x client interface, a client interface is a HW block that can handle host1x transactions on behalf of a host1x client (Which would otherwise need to be manually synced using PIO which is synchronous and requires direct cooperation of the CPU)
bool reserved;
bool reserved; //!< If the syncpoint is reserved or not, not to be confused with a reserved value
};
const DeviceState &state;

8
app/src/main/cpp/skyline/vfs/backing.h
View File

@ -44,6 +44,14 @@ namespace skyline::vfs {
*/
virtual size_t Read(span<u8> output, size_t offset = 0) = 0;
/**
* @brief Implicit casting for reading into spans of different types
*/
template<class T, typename std::enable_if<!std::is_same_v<T, u8>, bool>::type = true>
inline size_t Read(span<T> output, size_t offset = 0) {
return Read(output.template cast<u8>(), offset);
}
/**
* @brief Read bytes from the backing at a particular offset into an object
* @param offset The offset to start reading from

47
app/src/main/cpp/skyline/vfs/npdm.cpp
View File

@ -5,7 +5,7 @@
#include "npdm.h"
namespace skyline::vfs {
constexpr u32 MetaMagic = util::MakeMagic<u32>("META");
constexpr u32 MetaMagic{util::MakeMagic<u32>("META")};
NPDM::NPDM() {
constexpr i8 DefaultPriority{44}; // The default priority of an HOS process
@ -27,17 +27,52 @@ namespace skyline::vfs {
.systemResourceSize = DefaultSystemResourceSize,
.name = "Application",
};
aci0 = {
.magic = MetaMagic,
};
threadInfo = {
.coreMask = 0b1110,
.priority = {0, 63},
};
}
NPDM::NPDM(const std::shared_ptr<vfs::Backing> &backing) {
NPDM::NPDM(const std::shared_ptr<vfs::Backing> &backing, const DeviceState &state) {
meta = backing->Read<NpdmMeta>();
if (meta.magic != MetaMagic)
throw exception("NPDM Meta Magic isn't correct: 0x{:X} (\"META\" = 0x{:X})", meta.magic, MetaMagic);
if (!constant::HosPriority.Valid(meta.mainThreadPriority))
throw exception("NPDM Main Thread Priority isn't valid: {}", meta.mainThreadStackSize);
if (meta.idealCore >= constant::CoreCount)
throw exception("NPDM Ideal Core isn't valid: {}", meta.idealCore);
if (!util::PageAligned(meta.mainThreadStackSize))
throw exception("NPDM Main Thread Stack isn't page aligned: 0x{:X}", meta.mainThreadStackSize);
aci0 = meta.aci0.Read<NpdmAci0>(backing);
constexpr u32 Aci0Magic{util::MakeMagic<u32>("ACI0")};
if (aci0.magic != Aci0Magic)
throw exception("NPDM ACI0 Magic isn't correct: 0x{:X} (\"ACI0\" = 0x{:X})", aci0.magic, Aci0Magic);
std::vector<NpdmKernelCapability> capabilities(aci0.kernelCapability.size / sizeof(NpdmKernelCapability));
backing->Read(span(capabilities), meta.aci0.offset + aci0.kernelCapability.offset);
for (auto capability : capabilities) {
auto trailingOnes{__builtin_ctz(~capability.raw)};
switch (trailingOnes) {
case 3:
threadInfo.priority = kernel::Priority{capability.threadInfo.lowestPriority, capability.threadInfo.highestPriority};
threadInfo.coreMask = {};
for (u8 core{capability.threadInfo.minCoreId}; core <= capability.threadInfo.maxCoreId; core++)
threadInfo.coreMask.set(core);
break;
case 14:
kernelVersion.minorVersion = capability.kernelVersion.minorVersion;
kernelVersion.majorVersion = capability.kernelVersion.majorVersion;
break;
}
}
if (!threadInfo.priority.Valid(meta.mainThreadPriority))
throw exception("NPDM Main Thread Priority isn't valid: {} ({} - {})", meta.mainThreadPriority, threadInfo.priority.min, threadInfo.priority.max);
if (!threadInfo.coreMask.test(meta.idealCore))
throw exception("NPDM Ideal Core isn't valid: {} ({})", meta.idealCore, threadInfo.coreMask);
state.logger->Debug("NPDM Metadata:\nTitle: ID: {:X}, Version: {}\nMain Thread: Priority: {}, Stack Size: 0x{:X}\nScheduler: Ideal Core: {}, Core Mask: {}, Priority: {} - {}\nKernel Version: v{}.{}", aci0.programId, meta.version, meta.mainThreadPriority, meta.mainThreadStackSize, meta.idealCore, threadInfo.coreMask, threadInfo.priority.min, threadInfo.priority.max, kernelVersion.majorVersion, kernelVersion.minorVersion);
}
}

148
app/src/main/cpp/skyline/vfs/npdm.h
View File

@ -4,51 +4,119 @@
#pragma once
#include "backing.h"
#include <kernel/scheduler.h>
#include <kernel/memory.h>
namespace skyline::vfs {
/**
* @url https://switchbrew.org/wiki/NPDM
*/
class NPDM {
public:
namespace skyline {
namespace vfs {
/**
* @url https://switchbrew.org/wiki/NPDM#META
* @url https://switchbrew.org/wiki/NPDM
*/
struct __attribute__((packed)) NpdmMeta {
u32 magic; //!< "META"
u32 acidSignatureKeyGeneration;
u32 _unk0_;
union {
struct {
bool is64Bit : 1;
memory::AddressSpaceType type : 2;
bool optimizeMemoryAllocation : 1;
};
u8 raw{};
} flags;
u8 _unk1_;
u8 mainThreadPriority;
u8 idealCore;
u32 _unk2_;
u32 systemResourceSize; //!< 3.0.0+
u32 version;
u32 mainThreadStackSize;
std::array<char, 0x10> name; //!< "Application"
std::array<u8, 0x10> productCode;
u8 _unk3_[0x30];
u32 aciOffset;
u32 aciSize;
u32 acidOffset;
u32 acidSize;
} meta;
class NPDM {
private:
struct Section {
u32 offset;
u32 size;
static_assert(sizeof(NpdmMeta::flags) == sizeof(u8));
static_assert(sizeof(NpdmMeta) == 0x80);
template<class T>
inline T Read(const std::shared_ptr<vfs::Backing> &backing, size_t baseOffset = 0) {
if (sizeof(T) > size)
throw exception("Section size ({}) smaller than Read type size ({})", size, sizeof(T));
return backing->Read<T>(baseOffset + offset);
}
};
static_assert(sizeof(Section) == sizeof(u64));
public:
NPDM();
public:
/**
* @url https://switchbrew.org/wiki/NPDM#META
*/
struct __attribute__((packed)) NpdmMeta {
u32 magic; //!< "META"
u32 acidSignatureKeyGeneration;
u32 _unk0_;
union {
struct {
bool is64Bit : 1;
memory::AddressSpaceType type : 2;
bool optimizeMemoryAllocation : 1;
};
u8 raw{};
} flags;
u8 _unk1_;
u8 mainThreadPriority;
u8 idealCore;
u32 _unk2_;
u32 systemResourceSize; //!< 3.0.0+
u32 version;
u32 mainThreadStackSize;
std::array<char, 0x10> name; //!< "Application"
std::array<u8, 0x10> productCode;
u8 _unk3_[0x30];
Section aci0;
Section acid;
} meta;
static_assert(sizeof(NpdmMeta::flags) == sizeof(u8));
static_assert(sizeof(NpdmMeta) == 0x80);
NPDM(const std::shared_ptr<vfs::Backing> &backing);
};
/**
* @url https://switchbrew.org/wiki/NPDM#ACI0
* @note Offsets in this are all relative to ACI0, not the start of the file
*/
struct __attribute__((packed)) NpdmAci0 {
u32 magic; //!< "ACI0"
u32 _res0_[3];
u64 programId;
u64 _res1_;
Section fsAccessControl;
Section srvAccessControl;
Section kernelCapability;
u64 _res2_;
} aci0;
static_assert(sizeof(NpdmAci0) == 0x40);
/**
* @url https://switchbrew.org/wiki/NPDM#KernelCapability
*/
union __attribute__((packed)) NpdmKernelCapability {
/**
* @url https://switchbrew.org/wiki/NPDM#ThreadInfo
*/
struct __attribute__((packed)) {
u8 pattern : 4; //!< 0b0111
u8 highestPriority : 6;
u8 lowestPriority : 6;
u8 minCoreId : 8;
u8 maxCoreId : 8;
} threadInfo;
/**
* @url https://switchbrew.org/wiki/NPDM#KernelVersion
*/
struct __attribute__((packed)) {
u16 pattern : 15; //!< 0b011111111111111
u8 minorVersion : 4;
u16 majorVersion : 13;
} kernelVersion;
u32 raw;
};
static_assert(sizeof(NpdmKernelCapability) == sizeof(u32));
struct {
kernel::Priority priority;
kernel::CoreMask coreMask;
} threadInfo;
struct {
u8 minorVersion;
u16 majorVersion;
} kernelVersion{};
public:
NPDM();
NPDM(const std::shared_ptr<vfs::Backing> &backing, const DeviceState &state);
};
}
}

2
app/src/main/cpp/skyline/vfs/partition_filesystem.cpp
View File

@ -20,7 +20,7 @@ namespace skyline::vfs {
fileDataOffset = stringTableOffset + header.stringTableSize;
std::vector<char> stringTable(header.stringTableSize + 1);
backing->Read(span(stringTable).first(header.stringTableSize).cast<u8>(), stringTableOffset);
backing->Read(span(stringTable).first(header.stringTableSize), stringTableOffset);
stringTable[header.stringTableSize] = 0;
for (u32 entryOffset{sizeof(FsHeader)}; entryOffset < header.numFiles * entrySize; entryOffset += entrySize) {

8
app/src/main/cpp/skyline/vfs/rom_filesystem.cpp
View File

@ -17,7 +17,7 @@ namespace skyline::vfs {
if (entry.nameSize) {
std::vector<char> name(entry.nameSize);
backing->Read(span(name).cast<u8>(), header.fileMetaTableOffset + offset + sizeof(RomFsFileEntry));
backing->Read(span(name), header.fileMetaTableOffset + offset + sizeof(RomFsFileEntry));
std::string fullPath{path + (path.empty() ? "" : "/") + std::string(name.data(), entry.nameSize)};
fileMap.emplace(fullPath, entry);
@ -33,7 +33,7 @@ namespace skyline::vfs {
std::string childPath{path};
if (entry.nameSize) {
std::vector<char> name(entry.nameSize);
backing->Read(span(name).cast<u8>(), header.dirMetaTableOffset + offset + sizeof(RomFsDirectoryEntry));
backing->Read(span(name), header.dirMetaTableOffset + offset + sizeof(RomFsDirectoryEntry));
childPath = path + (path.empty() ? "" : "/") + std::string(name.data(), entry.nameSize);
}
@ -90,7 +90,7 @@ namespace skyline::vfs {
if (romFsFileEntry.nameSize) {
std::vector<char> name(romFsFileEntry.nameSize);
backing->Read(span(name).cast<u8>(), header.fileMetaTableOffset + offset + sizeof(RomFileSystem::RomFsFileEntry));
backing->Read(span(name), header.fileMetaTableOffset + offset + sizeof(RomFileSystem::RomFsFileEntry));
contents.emplace_back(Entry{std::string(name.data(), romFsFileEntry.nameSize), EntryType::File, romFsFileEntry.size});
}
@ -108,7 +108,7 @@ namespace skyline::vfs {
if (romFsDirectoryEntry.nameSize) {
std::vector<char> name(romFsDirectoryEntry.nameSize);
backing->Read(span(name).cast<u8>(), header.dirMetaTableOffset + offset + sizeof(RomFileSystem::RomFsDirectoryEntry));
backing->Read(span(name), header.dirMetaTableOffset + offset + sizeof(RomFileSystem::RomFsDirectoryEntry));
contents.emplace_back(Entry{std::string(name.data(), romFsDirectoryEntry.nameSize), EntryType::Directory});
}