271 lines
14 KiB
C++
271 lines
14 KiB
C++
#include "svc.h"
|
|
#include <os.h>
|
|
|
|
namespace skyline::kernel::svc {
|
|
void SetHeapSize(DeviceState &state) {
|
|
auto heap = state.thisProcess->MapPrivateRegion(0, state.nce->GetRegister(Wreg::W1), {true, true, false}, memory::Type::Heap, memory::Region::Heap);
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Success);
|
|
state.nce->SetRegister(Xreg::X1, heap.item->address);
|
|
state.logger->Write(Logger::Debug, "Heap size was set to 0x{:X}", state.nce->GetRegister(Wreg::W1));
|
|
}
|
|
|
|
void QueryMemory(DeviceState &state) {
|
|
memory::MemoryInfo memInf;
|
|
u64 addr = state.nce->GetRegister(Xreg::X2);
|
|
bool memFree = true;
|
|
for(const auto& [address, region] : state.thisProcess->memoryMap) {
|
|
if (addr >= address && addr < (address + region->size)) {
|
|
memInf = region->GetInfo();
|
|
memFree = false;
|
|
break;
|
|
}
|
|
}
|
|
if (memFree) {
|
|
memInf = {
|
|
.baseAddress = static_cast<u64>(static_cast<u64>(addr / PAGE_SIZE) * PAGE_SIZE),
|
|
.size = static_cast<u64>(-constant::BaseSize + 1),
|
|
.type = static_cast<u64>(memory::Type::Unmapped),
|
|
};
|
|
}
|
|
state.thisProcess->WriteMemory<memory::MemoryInfo>(memInf, state.nce->GetRegister(Xreg::X0));
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Success);
|
|
}
|
|
|
|
void CreateThread(DeviceState &state) {
|
|
// TODO: Support Core Mask potentially
|
|
auto thread = state.thisProcess->CreateThread(state.nce->GetRegister(Xreg::X1), state.nce->GetRegister(Xreg::X2), state.nce->GetRegister(Xreg::X3), static_cast<u8>(state.nce->GetRegister(Wreg::W4)));
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Success);
|
|
state.nce->SetRegister(Wreg::W1, thread->handle);
|
|
state.logger->Write(Logger::Info, "Creating a thread: {}", thread->handle);
|
|
}
|
|
|
|
void StartThread(DeviceState &state) {
|
|
auto &object = state.thisProcess->handleTable.at(static_cast<const unsigned int &>(state.nce->GetRegister(Wreg::W0)));
|
|
if (object->objectType == type::KType::KThread)
|
|
std::static_pointer_cast<type::KThread>(object)->Start();
|
|
else
|
|
throw exception("StartThread was called on a non-KThread object");
|
|
}
|
|
|
|
void ExitThread(DeviceState &state) {
|
|
state.os->KillThread(state.thisThread->pid);
|
|
}
|
|
|
|
void SleepThread(DeviceState &state) {
|
|
auto in = state.nce->GetRegister(Xreg::X0);
|
|
switch(in) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
state.thisThread->status = type::KThread::ThreadStatus::Runnable; // Will cause the application to awaken on the next iteration of the main loop
|
|
default:
|
|
state.thisThread->timeout = GetCurrTimeNs() + in;
|
|
state.thisThread->status = type::KThread::ThreadStatus::Sleeping;
|
|
}
|
|
}
|
|
|
|
void GetThreadPriority(DeviceState &state) {
|
|
state.nce->SetRegister(Wreg::W1, state.thisProcess->GetHandle<type::KThread>(static_cast<handle_t>(state.nce->GetRegister(Wreg::W0)))->priority);
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Success);
|
|
}
|
|
|
|
void SetThreadPriority(DeviceState &state) {
|
|
state.thisProcess->GetHandle<type::KThread>(static_cast<handle_t>(state.nce->GetRegister(Wreg::W0)))->Start();
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Success);
|
|
}
|
|
|
|
void MapSharedMemory(DeviceState &state) {
|
|
auto object = state.thisProcess->GetHandle<type::KSharedMemory>(static_cast<handle_t>(state.nce->GetRegister(Wreg::W0)));
|
|
object->Map(state.nce->GetRegister(Xreg::X1), state.nce->GetRegister(Xreg::X2), state.thisProcess->mainThread);
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Success);
|
|
}
|
|
|
|
void CloseHandle(DeviceState &state) {
|
|
auto handle = static_cast<handle_t>(state.nce->GetRegister(Wreg::W0));
|
|
state.logger->Write(Logger::Debug, "Closing handle: 0x{:X}", handle);
|
|
auto &object = state.thisProcess->handleTable.at(handle);
|
|
switch (object->objectType) {
|
|
case (type::KType::KThread):
|
|
state.os->KillThread(std::static_pointer_cast<type::KThread>(object)->pid);
|
|
break;
|
|
case (type::KType::KProcess):
|
|
state.os->KillThread(std::static_pointer_cast<type::KProcess>(object)->mainThread);
|
|
break;
|
|
default:
|
|
state.thisProcess->handleTable.erase(handle);
|
|
}
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Success);
|
|
}
|
|
|
|
void WaitSynchronization(DeviceState &state) {
|
|
auto numHandles = state.nce->GetRegister(Wreg::W2);
|
|
if (numHandles > constant::MaxSyncHandles) {
|
|
state.nce->SetRegister(Wreg::W0, constant::status::MaxHandles);
|
|
return;
|
|
}
|
|
std::vector<handle_t> waitHandles(numHandles);
|
|
state.thisProcess->ReadMemory(waitHandles.data(), state.nce->GetRegister(Xreg::X1), numHandles * sizeof(handle_t));
|
|
for (const auto& handle : waitHandles) {
|
|
auto object = state.thisProcess->handleTable.at(handle);
|
|
switch(object->objectType) {
|
|
case type::KType::KProcess:
|
|
case type::KType::KThread:
|
|
case type::KType::KEvent:
|
|
case type::KType::KSession:
|
|
break;
|
|
default:
|
|
state.nce->SetRegister(Wreg::W0, constant::status::InvHandle);
|
|
return;
|
|
}
|
|
auto syncObject = std::static_pointer_cast<type::KSyncObject>(object);
|
|
if(syncObject->signalled) {
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Success);
|
|
return;
|
|
}
|
|
state.thisThread->waitObjects.push_back(syncObject);
|
|
syncObject->waitThreads.push_back(state.thisThread->pid);
|
|
}
|
|
state.thisThread->timeout = GetCurrTimeNs() + state.nce->GetRegister(Xreg::X3);
|
|
state.thisThread->status = type::KThread::ThreadStatus::WaitSync;
|
|
}
|
|
|
|
void ArbitrateLock(DeviceState &state) {
|
|
if (state.nce->GetRegister(Wreg::W2) != state.thisThread->handle)
|
|
throw exception("A process requested locking a thread on behalf of another process");
|
|
state.thisProcess->MutexLock(state.nce->GetRegister(Xreg::X1));
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Success);
|
|
}
|
|
|
|
void ArbitrateUnlock(DeviceState &state) {
|
|
state.thisProcess->MutexUnlock(state.nce->GetRegister(Xreg::X0));
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Success);
|
|
}
|
|
|
|
void WaitProcessWideKeyAtomic(DeviceState &state) {
|
|
auto mtxAddr = state.nce->GetRegister(Xreg::X0);
|
|
if (state.nce->GetRegister(Wreg::W2) != state.thisThread->handle)
|
|
throw exception("svcWaitProcessWideKeyAtomic was called on behalf of another thread");
|
|
state.thisProcess->MutexUnlock(mtxAddr);
|
|
auto &cvarVec = state.thisProcess->condVarMap[state.nce->GetRegister(Xreg::X1)];
|
|
for (auto thread = cvarVec.begin();; thread++) {
|
|
if ((*thread)->priority < state.thisThread->priority) {
|
|
cvarVec.insert(thread, state.thisThread);
|
|
break;
|
|
} else if (thread + 1 == cvarVec.end()) {
|
|
cvarVec.push_back(state.thisThread);
|
|
break;
|
|
}
|
|
}
|
|
state.thisThread->status = type::KThread::ThreadStatus::WaitCondVar;
|
|
state.thisThread->timeout = GetCurrTimeNs() + state.nce->GetRegister(Xreg::X3);
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Success);
|
|
}
|
|
|
|
void SignalProcessWideKey(DeviceState &state) {
|
|
auto address = state.nce->GetRegister(Xreg::X0);
|
|
auto count = state.nce->GetRegister(Wreg::W1);
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Success);
|
|
if (!state.thisProcess->condVarMap.count(address))
|
|
return; // No threads to awaken
|
|
auto &cvarVec = state.thisProcess->condVarMap[address];
|
|
count = std::min(count, static_cast<u32>(cvarVec.size()));
|
|
for (uint index = 0; index < count; index++)
|
|
cvarVec[index]->status = type::KThread::ThreadStatus::Runnable;
|
|
cvarVec.erase(cvarVec.begin(), cvarVec.begin() + count);
|
|
if (cvarVec.empty())
|
|
state.thisProcess->condVarMap.erase(address);
|
|
}
|
|
|
|
void ConnectToNamedPort(DeviceState &state) {
|
|
char port[constant::PortSize + 1]{0}; // +1 so string will always be null terminated
|
|
state.os->thisProcess->ReadMemory(port, state.nce->GetRegister(Xreg::X1), constant::PortSize);
|
|
if (std::strcmp(port, "sm:") == 0)
|
|
state.nce->SetRegister(Wreg::W1, state.os->serviceManager.NewSession(service::Service::sm));
|
|
else
|
|
throw exception(fmt::format("svcConnectToNamedPort tried connecting to invalid port: \"{}\"", port));
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Success);
|
|
}
|
|
|
|
void SendSyncRequest(DeviceState &state) {
|
|
state.os->serviceManager.SyncRequestHandler(static_cast<handle_t>(state.nce->GetRegister(Xreg::X0)));
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Success);
|
|
}
|
|
|
|
void OutputDebugString(DeviceState &state) {
|
|
std::string debug(state.nce->GetRegister(Xreg::X1), '\0');
|
|
state.os->thisProcess->ReadMemory((void *) debug.data(), state.nce->GetRegister(Xreg::X0), state.nce->GetRegister(Xreg::X1));
|
|
std::string::size_type pos = 0;
|
|
while ((pos = debug.find("\r\n", pos)) != std::string::npos)
|
|
debug.erase(pos, 2);
|
|
state.logger->Write(Logger::Info, "Debug Output: {}", debug);
|
|
state.nce->SetRegister(Wreg::W0, 0);
|
|
}
|
|
|
|
void GetInfo(DeviceState &state) {
|
|
state.logger->Write(Logger::Debug, "svcGetInfo called with ID0: {}, ID1: {}", state.nce->GetRegister(Wreg::W1), state.nce->GetRegister(Xreg::X3));
|
|
switch (state.nce->GetRegister(Wreg::W1)) {
|
|
case constant::infoState::AllowedCpuIdBitmask:
|
|
case constant::infoState::AllowedThreadPriorityMask:
|
|
case constant::infoState::IsCurrentProcessBeingDebugged:
|
|
case constant::infoState::TitleId:
|
|
case constant::infoState::PrivilegedProcessId:
|
|
state.nce->SetRegister(Xreg::X1, 0);
|
|
break;
|
|
case constant::infoState::AliasRegionBaseAddr:
|
|
state.nce->SetRegister(Xreg::X1, constant::MapAddr);
|
|
break;
|
|
case constant::infoState::AliasRegionSize:
|
|
state.nce->SetRegister(Xreg::X1, constant::MapSize);
|
|
break;
|
|
case constant::infoState::HeapRegionBaseAddr:
|
|
state.nce->SetRegister(Xreg::X1, state.os->thisProcess->memoryRegionMap.at(memory::Region::Heap)->address);
|
|
break;
|
|
case constant::infoState::HeapRegionSize:
|
|
state.nce->SetRegister(Xreg::X1, state.os->thisProcess->memoryRegionMap.at(memory::Region::Heap)->size);
|
|
break;
|
|
case constant::infoState::TotalMemoryAvailable:
|
|
state.nce->SetRegister(Xreg::X1, constant::TotalPhyMem);
|
|
break;
|
|
case constant::infoState::TotalMemoryUsage:
|
|
state.nce->SetRegister(Xreg::X1, state.os->thisProcess->memoryRegionMap.at(memory::Region::Heap)->address + state.thisProcess->mainThreadStackSz + state.thisProcess->GetProgramSize());
|
|
break;
|
|
case constant::infoState::AddressSpaceBaseAddr:
|
|
state.nce->SetRegister(Xreg::X1, constant::BaseAddr);
|
|
break;
|
|
case constant::infoState::AddressSpaceSize:
|
|
state.nce->SetRegister(Xreg::X1, constant::BaseSize);
|
|
break;
|
|
case constant::infoState::StackRegionBaseAddr:
|
|
state.nce->SetRegister(Xreg::X1, state.thisThread->stackTop);
|
|
break;
|
|
case constant::infoState::StackRegionSize:
|
|
state.nce->SetRegister(Xreg::X1, state.thisProcess->mainThreadStackSz);
|
|
break;
|
|
case constant::infoState::PersonalMmHeapSize:
|
|
state.nce->SetRegister(Xreg::X1, constant::TotalPhyMem);
|
|
break;
|
|
case constant::infoState::PersonalMmHeapUsage:
|
|
state.nce->SetRegister(Xreg::X1, state.os->thisProcess->memoryRegionMap.at(memory::Region::Heap)->address + state.thisProcess->mainThreadStackSz);
|
|
break;
|
|
case constant::infoState::TotalMemoryAvailableWithoutMmHeap:
|
|
state.nce->SetRegister(Xreg::X1, constant::TotalPhyMem); // TODO: NPDM specifies SystemResourceSize, subtract that from this
|
|
break;
|
|
case constant::infoState::TotalMemoryUsedWithoutMmHeap:
|
|
state.nce->SetRegister(Xreg::X1, state.os->thisProcess->memoryRegionMap.at(memory::Region::Heap)->address + state.thisProcess->mainThreadStackSz); // TODO: Same as above
|
|
break;
|
|
case constant::infoState::UserExceptionContextAddr:
|
|
state.nce->SetRegister(Xreg::X1, state.thisProcess->tlsPages[0]->Get(0));
|
|
break;
|
|
default:
|
|
state.logger->Write(Logger::Warn, "Unimplemented svcGetInfo with ID0: {}, ID1: {}", state.nce->GetRegister(Wreg::W1), state.nce->GetRegister(Xreg::X3));
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Unimpl);
|
|
return;
|
|
}
|
|
state.nce->SetRegister(Wreg::W0, constant::status::Success);
|
|
}
|
|
|
|
void ExitProcess(DeviceState &state) {
|
|
state.os->KillThread(state.thisProcess->mainThread);
|
|
}
|
|
}
|