summaryrefslogtreecommitdiffstats
path: root/src/core
diff options
context:
space:
mode:
Diffstat (limited to 'src/core')
-rw-r--r--src/core/debugger/debugger.cpp161
-rw-r--r--src/core/debugger/gdbstub.cpp151
-rw-r--r--src/core/debugger/gdbstub.h1
-rw-r--r--src/core/hle/kernel/k_event.cpp15
-rw-r--r--src/core/hle/kernel/k_page_table.h3
-rw-r--r--src/core/hle/kernel/service_thread.cpp27
-rw-r--r--src/core/hle/result.h76
7 files changed, 336 insertions, 98 deletions
diff --git a/src/core/debugger/debugger.cpp b/src/core/debugger/debugger.cpp
index 339f971e6..1a8e02e6a 100644
--- a/src/core/debugger/debugger.cpp
+++ b/src/core/debugger/debugger.cpp
@@ -27,12 +27,21 @@ static void AsyncReceiveInto(Readable& r, Buffer& buffer, Callback&& c) {
const u8* buffer_start = reinterpret_cast<const u8*>(&buffer);
std::span<const u8> received_data{buffer_start, buffer_start + bytes_read};
c(received_data);
+ AsyncReceiveInto(r, buffer, c);
}
-
- AsyncReceiveInto(r, buffer, c);
});
}
+template <typename Callback>
+static void AsyncAccept(boost::asio::ip::tcp::acceptor& acceptor, Callback&& c) {
+ acceptor.async_accept([&, c](const boost::system::error_code& error, auto&& peer_socket) {
+ if (!error.failed()) {
+ c(peer_socket);
+ AsyncAccept(acceptor, c);
+ }
+ });
+}
+
template <typename Readable, typename Buffer>
static std::span<const u8> ReceiveInto(Readable& r, Buffer& buffer) {
static_assert(std::is_trivial_v<Buffer>);
@@ -59,9 +68,7 @@ namespace Core {
class DebuggerImpl : public DebuggerBackend {
public:
- explicit DebuggerImpl(Core::System& system_, u16 port)
- : system{system_}, signal_pipe{io_context}, client_socket{io_context} {
- frontend = std::make_unique<GDBStub>(*this, system);
+ explicit DebuggerImpl(Core::System& system_, u16 port) : system{system_} {
InitializeServer(port);
}
@@ -70,39 +77,42 @@ public:
}
bool SignalDebugger(SignalInfo signal_info) {
- {
- std::scoped_lock lk{connection_lock};
+ std::scoped_lock lk{connection_lock};
- if (stopped) {
- // Do not notify the debugger about another event.
- // It should be ignored.
- return false;
- }
-
- // Set up the state.
- stopped = true;
- info = signal_info;
+ if (stopped || !state) {
+ // Do not notify the debugger about another event.
+ // It should be ignored.
+ return false;
}
+ // Set up the state.
+ stopped = true;
+ state->info = signal_info;
+
// Write a single byte into the pipe to wake up the debug interface.
- boost::asio::write(signal_pipe, boost::asio::buffer(&stopped, sizeof(stopped)));
+ boost::asio::write(state->signal_pipe, boost::asio::buffer(&stopped, sizeof(stopped)));
+
return true;
}
+ // These functions are callbacks from the frontend, and the lock will be held.
+ // There is no need to relock it.
+
std::span<const u8> ReadFromClient() override {
- return ReceiveInto(client_socket, client_data);
+ return ReceiveInto(state->client_socket, state->client_data);
}
void WriteToClient(std::span<const u8> data) override {
- boost::asio::write(client_socket, boost::asio::buffer(data.data(), data.size_bytes()));
+ boost::asio::write(state->client_socket,
+ boost::asio::buffer(data.data(), data.size_bytes()));
}
void SetActiveThread(Kernel::KThread* thread) override {
- active_thread = thread;
+ state->active_thread = thread;
}
Kernel::KThread* GetActiveThread() override {
- return active_thread;
+ return state->active_thread;
}
private:
@@ -113,65 +123,78 @@ private:
// Run the connection thread.
connection_thread = std::jthread([&, port](std::stop_token stop_token) {
+ Common::SetCurrentThreadName("Debugger");
+
try {
// Initialize the listening socket and accept a new client.
tcp::endpoint endpoint{boost::asio::ip::address_v4::any(), port};
tcp::acceptor acceptor{io_context, endpoint};
- acceptor.async_accept(client_socket, [](const auto&) {});
- io_context.run_one();
- io_context.restart();
+ AsyncAccept(acceptor, [&](auto&& peer) { AcceptConnection(std::move(peer)); });
- if (stop_token.stop_requested()) {
- return;
+ while (!stop_token.stop_requested() && io_context.run()) {
}
-
- ThreadLoop(stop_token);
} catch (const std::exception& ex) {
LOG_CRITICAL(Debug_GDBStub, "Stopping server: {}", ex.what());
}
});
}
- void ShutdownServer() {
- connection_thread.request_stop();
- io_context.stop();
- connection_thread.join();
- }
+ void AcceptConnection(boost::asio::ip::tcp::socket&& peer) {
+ LOG_INFO(Debug_GDBStub, "Accepting new peer connection");
- void ThreadLoop(std::stop_token stop_token) {
- Common::SetCurrentThreadName("Debugger");
+ std::scoped_lock lk{connection_lock};
+
+ // Ensure everything is stopped.
+ PauseEmulation();
+
+ // Set up the new frontend.
+ frontend = std::make_unique<GDBStub>(*this, system);
+
+ // Set the new state. This will tear down any existing state.
+ state = ConnectionState{
+ .client_socket{std::move(peer)},
+ .signal_pipe{io_context},
+ .info{},
+ .active_thread{},
+ .client_data{},
+ .pipe_data{},
+ };
// Set up the client signals for new data.
- AsyncReceiveInto(signal_pipe, pipe_data, [&](auto d) { PipeData(d); });
- AsyncReceiveInto(client_socket, client_data, [&](auto d) { ClientData(d); });
+ AsyncReceiveInto(state->signal_pipe, state->pipe_data, [&](auto d) { PipeData(d); });
+ AsyncReceiveInto(state->client_socket, state->client_data, [&](auto d) { ClientData(d); });
// Set the active thread.
UpdateActiveThread();
// Set up the frontend.
frontend->Connected();
+ }
- // Main event loop.
- while (!stop_token.stop_requested() && io_context.run()) {
- }
+ void ShutdownServer() {
+ connection_thread.request_stop();
+ io_context.stop();
+ connection_thread.join();
}
void PipeData(std::span<const u8> data) {
- switch (info.type) {
+ std::scoped_lock lk{connection_lock};
+
+ switch (state->info.type) {
case SignalType::Stopped:
case SignalType::Watchpoint:
// Stop emulation.
PauseEmulation();
// Notify the client.
- active_thread = info.thread;
+ state->active_thread = state->info.thread;
UpdateActiveThread();
- if (info.type == SignalType::Watchpoint) {
- frontend->Watchpoint(active_thread, *info.watchpoint);
+ if (state->info.type == SignalType::Watchpoint) {
+ frontend->Watchpoint(state->active_thread, *state->info.watchpoint);
} else {
- frontend->Stopped(active_thread);
+ frontend->Stopped(state->active_thread);
}
break;
@@ -179,8 +202,8 @@ private:
frontend->ShuttingDown();
// Wait for emulation to shut down gracefully now.
- signal_pipe.close();
- client_socket.shutdown(boost::asio::socket_base::shutdown_both);
+ state->signal_pipe.close();
+ state->client_socket.shutdown(boost::asio::socket_base::shutdown_both);
LOG_INFO(Debug_GDBStub, "Shut down server");
break;
@@ -188,17 +211,16 @@ private:
}
void ClientData(std::span<const u8> data) {
+ std::scoped_lock lk{connection_lock};
+
const auto actions{frontend->ClientData(data)};
for (const auto action : actions) {
switch (action) {
case DebuggerAction::Interrupt: {
- {
- std::scoped_lock lk{connection_lock};
- stopped = true;
- }
+ stopped = true;
PauseEmulation();
UpdateActiveThread();
- frontend->Stopped(active_thread);
+ frontend->Stopped(state->active_thread);
break;
}
case DebuggerAction::Continue:
@@ -206,15 +228,15 @@ private:
break;
case DebuggerAction::StepThreadUnlocked:
MarkResumed([&] {
- active_thread->SetStepState(Kernel::StepState::StepPending);
- active_thread->Resume(Kernel::SuspendType::Debug);
- ResumeEmulation(active_thread);
+ state->active_thread->SetStepState(Kernel::StepState::StepPending);
+ state->active_thread->Resume(Kernel::SuspendType::Debug);
+ ResumeEmulation(state->active_thread);
});
break;
case DebuggerAction::StepThreadLocked: {
MarkResumed([&] {
- active_thread->SetStepState(Kernel::StepState::StepPending);
- active_thread->Resume(Kernel::SuspendType::Debug);
+ state->active_thread->SetStepState(Kernel::StepState::StepPending);
+ state->active_thread->Resume(Kernel::SuspendType::Debug);
});
break;
}
@@ -254,15 +276,14 @@ private:
template <typename Callback>
void MarkResumed(Callback&& cb) {
Kernel::KScopedSchedulerLock sl{system.Kernel()};
- std::scoped_lock cl{connection_lock};
stopped = false;
cb();
}
void UpdateActiveThread() {
const auto& threads{ThreadList()};
- if (std::find(threads.begin(), threads.end(), active_thread) == threads.end()) {
- active_thread = threads[0];
+ if (std::find(threads.begin(), threads.end(), state->active_thread) == threads.end()) {
+ state->active_thread = threads[0];
}
}
@@ -274,18 +295,22 @@ private:
System& system;
std::unique_ptr<DebuggerFrontend> frontend;
+ boost::asio::io_context io_context;
std::jthread connection_thread;
std::mutex connection_lock;
- boost::asio::io_context io_context;
- boost::process::async_pipe signal_pipe;
- boost::asio::ip::tcp::socket client_socket;
- SignalInfo info;
- Kernel::KThread* active_thread;
- bool pipe_data;
- bool stopped;
+ struct ConnectionState {
+ boost::asio::ip::tcp::socket client_socket;
+ boost::process::async_pipe signal_pipe;
+
+ SignalInfo info;
+ Kernel::KThread* active_thread;
+ std::array<u8, 4096> client_data;
+ bool pipe_data;
+ };
- std::array<u8, 4096> client_data;
+ std::optional<ConnectionState> state{};
+ bool stopped{};
};
Debugger::Debugger(Core::System& system, u16 port) {
diff --git a/src/core/debugger/gdbstub.cpp b/src/core/debugger/gdbstub.cpp
index 884229c77..a64a9ac64 100644
--- a/src/core/debugger/gdbstub.cpp
+++ b/src/core/debugger/gdbstub.cpp
@@ -606,6 +606,8 @@ void GDBStub::HandleQuery(std::string_view command) {
} else if (command.starts_with("StartNoAckMode")) {
no_ack = true;
SendReply(GDB_STUB_REPLY_OK);
+ } else if (command.starts_with("Rcmd,")) {
+ HandleRcmd(Common::HexStringToVector(command.substr(5), false));
} else {
SendReply(GDB_STUB_REPLY_EMPTY);
}
@@ -645,6 +647,155 @@ void GDBStub::HandleVCont(std::string_view command, std::vector<DebuggerAction>&
}
}
+constexpr std::array<std::pair<const char*, Kernel::Svc::MemoryState>, 22> MemoryStateNames{{
+ {"----- Free -----", Kernel::Svc::MemoryState::Free},
+ {"Io ", Kernel::Svc::MemoryState::Io},
+ {"Static ", Kernel::Svc::MemoryState::Static},
+ {"Code ", Kernel::Svc::MemoryState::Code},
+ {"CodeData ", Kernel::Svc::MemoryState::CodeData},
+ {"Normal ", Kernel::Svc::MemoryState::Normal},
+ {"Shared ", Kernel::Svc::MemoryState::Shared},
+ {"AliasCode ", Kernel::Svc::MemoryState::AliasCode},
+ {"AliasCodeData ", Kernel::Svc::MemoryState::AliasCodeData},
+ {"Ipc ", Kernel::Svc::MemoryState::Ipc},
+ {"Stack ", Kernel::Svc::MemoryState::Stack},
+ {"ThreadLocal ", Kernel::Svc::MemoryState::ThreadLocal},
+ {"Transfered ", Kernel::Svc::MemoryState::Transfered},
+ {"SharedTransfered", Kernel::Svc::MemoryState::SharedTransfered},
+ {"SharedCode ", Kernel::Svc::MemoryState::SharedCode},
+ {"Inaccessible ", Kernel::Svc::MemoryState::Inaccessible},
+ {"NonSecureIpc ", Kernel::Svc::MemoryState::NonSecureIpc},
+ {"NonDeviceIpc ", Kernel::Svc::MemoryState::NonDeviceIpc},
+ {"Kernel ", Kernel::Svc::MemoryState::Kernel},
+ {"GeneratedCode ", Kernel::Svc::MemoryState::GeneratedCode},
+ {"CodeOut ", Kernel::Svc::MemoryState::CodeOut},
+ {"Coverage ", Kernel::Svc::MemoryState::Coverage},
+}};
+
+static constexpr const char* GetMemoryStateName(Kernel::Svc::MemoryState state) {
+ for (size_t i = 0; i < MemoryStateNames.size(); i++) {
+ if (std::get<1>(MemoryStateNames[i]) == state) {
+ return std::get<0>(MemoryStateNames[i]);
+ }
+ }
+ return "Unknown ";
+}
+
+static constexpr const char* GetMemoryPermissionString(const Kernel::Svc::MemoryInfo& info) {
+ if (info.state == Kernel::Svc::MemoryState::Free) {
+ return " ";
+ }
+
+ switch (info.permission) {
+ case Kernel::Svc::MemoryPermission::ReadExecute:
+ return "r-x";
+ case Kernel::Svc::MemoryPermission::Read:
+ return "r--";
+ case Kernel::Svc::MemoryPermission::ReadWrite:
+ return "rw-";
+ default:
+ return "---";
+ }
+}
+
+static VAddr GetModuleEnd(Kernel::KPageTable& page_table, VAddr base) {
+ Kernel::Svc::MemoryInfo mem_info;
+ VAddr cur_addr{base};
+
+ // Expect: r-x Code (.text)
+ mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
+ cur_addr = mem_info.base_address + mem_info.size;
+ if (mem_info.state != Kernel::Svc::MemoryState::Code ||
+ mem_info.permission != Kernel::Svc::MemoryPermission::ReadExecute) {
+ return cur_addr - 1;
+ }
+
+ // Expect: r-- Code (.rodata)
+ mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
+ cur_addr = mem_info.base_address + mem_info.size;
+ if (mem_info.state != Kernel::Svc::MemoryState::Code ||
+ mem_info.permission != Kernel::Svc::MemoryPermission::Read) {
+ return cur_addr - 1;
+ }
+
+ // Expect: rw- CodeData (.data)
+ mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
+ cur_addr = mem_info.base_address + mem_info.size;
+ return cur_addr - 1;
+}
+
+void GDBStub::HandleRcmd(const std::vector<u8>& command) {
+ std::string_view command_str{reinterpret_cast<const char*>(&command[0]), command.size()};
+ std::string reply;
+
+ auto* process = system.CurrentProcess();
+ auto& page_table = process->PageTable();
+
+ if (command_str == "get info") {
+ Loader::AppLoader::Modules modules;
+ system.GetAppLoader().ReadNSOModules(modules);
+
+ reply = fmt::format("Process: {:#x} ({})\n"
+ "Program Id: {:#018x}\n",
+ process->GetProcessID(), process->GetName(), process->GetProgramID());
+ reply +=
+ fmt::format("Layout:\n"
+ " Alias: {:#012x} - {:#012x}\n"
+ " Heap: {:#012x} - {:#012x}\n"
+ " Aslr: {:#012x} - {:#012x}\n"
+ " Stack: {:#012x} - {:#012x}\n"
+ "Modules:\n",
+ page_table.GetAliasRegionStart(), page_table.GetAliasRegionEnd(),
+ page_table.GetHeapRegionStart(), page_table.GetHeapRegionEnd(),
+ page_table.GetAliasCodeRegionStart(), page_table.GetAliasCodeRegionEnd(),
+ page_table.GetStackRegionStart(), page_table.GetStackRegionEnd());
+
+ for (const auto& [vaddr, name] : modules) {
+ reply += fmt::format(" {:#012x} - {:#012x} {}\n", vaddr,
+ GetModuleEnd(page_table, vaddr), name);
+ }
+ } else if (command_str == "get mappings") {
+ reply = "Mappings:\n";
+ VAddr cur_addr = 0;
+
+ while (true) {
+ using MemoryAttribute = Kernel::Svc::MemoryAttribute;
+
+ auto mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
+
+ if (mem_info.state != Kernel::Svc::MemoryState::Inaccessible ||
+ mem_info.base_address + mem_info.size - 1 != std::numeric_limits<u64>::max()) {
+ const char* state = GetMemoryStateName(mem_info.state);
+ const char* perm = GetMemoryPermissionString(mem_info);
+
+ const char l = True(mem_info.attribute & MemoryAttribute::Locked) ? 'L' : '-';
+ const char i = True(mem_info.attribute & MemoryAttribute::IpcLocked) ? 'I' : '-';
+ const char d = True(mem_info.attribute & MemoryAttribute::DeviceShared) ? 'D' : '-';
+ const char u = True(mem_info.attribute & MemoryAttribute::Uncached) ? 'U' : '-';
+
+ reply +=
+ fmt::format(" {:#012x} - {:#012x} {} {} {}{}{}{} [{}, {}]\n",
+ mem_info.base_address, mem_info.base_address + mem_info.size - 1,
+ perm, state, l, i, d, u, mem_info.ipc_count, mem_info.device_count);
+ }
+
+ const uintptr_t next_address = mem_info.base_address + mem_info.size;
+ if (next_address <= cur_addr) {
+ break;
+ }
+
+ cur_addr = next_address;
+ }
+ } else if (command_str == "help") {
+ reply = "Commands:\n get info\n get mappings\n";
+ } else {
+ reply = "Unknown command.\nCommands:\n get info\n get mappings\n";
+ }
+
+ std::span<const u8> reply_span{reinterpret_cast<u8*>(&reply.front()), reply.size()};
+ SendReply(Common::HexToString(reply_span, false));
+}
+
Kernel::KThread* GDBStub::GetThreadByID(u64 thread_id) {
const auto& threads{system.GlobalSchedulerContext().GetThreadList()};
for (auto* thread : threads) {
diff --git a/src/core/debugger/gdbstub.h b/src/core/debugger/gdbstub.h
index 0b0f56e4b..368197920 100644
--- a/src/core/debugger/gdbstub.h
+++ b/src/core/debugger/gdbstub.h
@@ -32,6 +32,7 @@ private:
void ExecuteCommand(std::string_view packet, std::vector<DebuggerAction>& actions);
void HandleVCont(std::string_view command, std::vector<DebuggerAction>& actions);
void HandleQuery(std::string_view command);
+ void HandleRcmd(const std::vector<u8>& command);
void HandleBreakpointInsert(std::string_view command);
void HandleBreakpointRemove(std::string_view command);
std::vector<char>::const_iterator CommandEnd() const;
diff --git a/src/core/hle/kernel/k_event.cpp b/src/core/hle/kernel/k_event.cpp
index 27f70e5c5..d973853ab 100644
--- a/src/core/hle/kernel/k_event.cpp
+++ b/src/core/hle/kernel/k_event.cpp
@@ -20,8 +20,12 @@ void KEvent::Initialize(KProcess* owner) {
m_readable_event.Initialize(this);
// Set our owner process.
- m_owner = owner;
- m_owner->Open();
+ // HACK: this should never be nullptr, but service threads don't have a
+ // proper parent process yet.
+ if (owner != nullptr) {
+ m_owner = owner;
+ m_owner->Open();
+ }
// Mark initialized.
m_initialized = true;
@@ -50,8 +54,11 @@ Result KEvent::Clear() {
void KEvent::PostDestroy(uintptr_t arg) {
// Release the event count resource the owner process holds.
KProcess* owner = reinterpret_cast<KProcess*>(arg);
- owner->GetResourceLimit()->Release(LimitableResource::EventCountMax, 1);
- owner->Close();
+
+ if (owner != nullptr) {
+ owner->GetResourceLimit()->Release(LimitableResource::EventCountMax, 1);
+ owner->Close();
+ }
}
} // namespace Kernel
diff --git a/src/core/hle/kernel/k_page_table.h b/src/core/hle/kernel/k_page_table.h
index 950850291..f1ca785d7 100644
--- a/src/core/hle/kernel/k_page_table.h
+++ b/src/core/hle/kernel/k_page_table.h
@@ -320,6 +320,9 @@ public:
constexpr VAddr GetAliasCodeRegionStart() const {
return m_alias_code_region_start;
}
+ constexpr VAddr GetAliasCodeRegionEnd() const {
+ return m_alias_code_region_end;
+ }
constexpr VAddr GetAliasCodeRegionSize() const {
return m_alias_code_region_end - m_alias_code_region_start;
}
diff --git a/src/core/hle/kernel/service_thread.cpp b/src/core/hle/kernel/service_thread.cpp
index f5c2ab23f..e6e41ac34 100644
--- a/src/core/hle/kernel/service_thread.cpp
+++ b/src/core/hle/kernel/service_thread.cpp
@@ -40,7 +40,6 @@ private:
std::mutex m_session_mutex;
std::map<KServerSession*, std::shared_ptr<SessionRequestManager>> m_sessions;
KEvent* m_wakeup_event;
- KProcess* m_process;
KThread* m_thread;
std::atomic<bool> m_shutdown_requested;
const std::string m_service_name;
@@ -180,39 +179,17 @@ ServiceThread::Impl::~Impl() {
// Close thread.
m_thread->Close();
-
- // Close process.
- m_process->Close();
}
ServiceThread::Impl::Impl(KernelCore& kernel_, const std::string& service_name)
: kernel{kernel_}, m_service_name{service_name} {
- // Initialize process.
- m_process = KProcess::Create(kernel);
- KProcess::Initialize(m_process, kernel.System(), service_name,
- KProcess::ProcessType::KernelInternal, kernel.GetSystemResourceLimit());
-
- // Reserve a new event from the process resource limit
- KScopedResourceReservation event_reservation(m_process, LimitableResource::EventCountMax);
- ASSERT(event_reservation.Succeeded());
-
// Initialize event.
m_wakeup_event = KEvent::Create(kernel);
- m_wakeup_event->Initialize(m_process);
-
- // Commit the event reservation.
- event_reservation.Commit();
-
- // Reserve a new thread from the process resource limit
- KScopedResourceReservation thread_reservation(m_process, LimitableResource::ThreadCountMax);
- ASSERT(thread_reservation.Succeeded());
+ m_wakeup_event->Initialize(nullptr);
// Initialize thread.
m_thread = KThread::Create(kernel);
- ASSERT(KThread::InitializeDummyThread(m_thread, m_process).IsSuccess());
-
- // Commit the thread reservation.
- thread_reservation.Commit();
+ ASSERT(KThread::InitializeDummyThread(m_thread, nullptr).IsSuccess());
// Start thread.
m_host_thread = std::jthread([this] { LoopProcess(); });
diff --git a/src/core/hle/result.h b/src/core/hle/result.h
index 56c990728..240f06689 100644
--- a/src/core/hle/result.h
+++ b/src/core/hle/result.h
@@ -28,30 +28,49 @@ enum class ErrorModule : u32 {
Loader = 9,
CMIF = 10,
HIPC = 11,
+ TMA = 12,
+ DMNT = 13,
+ GDS = 14,
PM = 15,
NS = 16,
+ BSDSockets = 17,
HTC = 18,
+ TSC = 19,
NCMContent = 20,
SM = 21,
RO = 22,
+ GC = 23,
SDMMC = 24,
OVLN = 25,
SPL = 26,
+ Socket = 27,
+ HTCLOW = 29,
+ DDSF = 30,
+ HTCFS = 31,
+ Async = 32,
+ Util = 33,
+ TIPC = 35,
+ ANIF = 37,
ETHC = 100,
I2C = 101,
GPIO = 102,
UART = 103,
+ CPAD = 104,
Settings = 105,
+ FTM = 106,
WLAN = 107,
XCD = 108,
+ TMP451 = 109,
NIFM = 110,
Hwopus = 111,
+ LSM6DS3 = 112,
Bluetooth = 113,
VI = 114,
NFP = 115,
Time = 116,
FGM = 117,
OE = 118,
+ BH1730FVC = 119,
PCIe = 120,
Friends = 121,
BCAT = 122,
@@ -65,7 +84,7 @@ enum class ErrorModule : u32 {
AHID = 130,
Qlaunch = 132,
PCV = 133,
- OMM = 134,
+ USBPD = 134,
BPC = 135,
PSM = 136,
NIM = 137,
@@ -75,18 +94,22 @@ enum class ErrorModule : u32 {
NSD = 141,
PCTL = 142,
BTM = 143,
+ LA = 144,
ETicket = 145,
NGC = 146,
ERPT = 147,
APM = 148,
+ CEC = 149,
Profiler = 150,
ErrorUpload = 151,
+ LIDBE = 152,
Audio = 153,
NPNS = 154,
NPNSHTTPSTREAM = 155,
ARP = 157,
SWKBD = 158,
BOOT = 159,
+ NetDiag = 160,
NFCMifare = 161,
UserlandAssert = 162,
Fatal = 163,
@@ -94,17 +117,68 @@ enum class ErrorModule : u32 {
SPSM = 165,
BGTC = 167,
UserlandCrash = 168,
+ SASBUS = 169,
+ PI = 170,
+ AudioCtrl = 172,
+ LBL = 173,
+ JIT = 175,
+ HDCP = 176,
+ OMM = 177,
+ PDM = 178,
+ OLSC = 179,
SREPO = 180,
Dauth = 181,
+ STDFU = 182,
+ DBG = 183,
+ DHCPS = 186,
+ SPI = 187,
+ AVM = 188,
+ PWM = 189,
+ RTC = 191,
+ Regulator = 192,
+ LED = 193,
+ SIO = 195,
+ PCM = 196,
+ CLKRST = 197,
+ POWCTL = 198,
+ AudioOld = 201,
HID = 202,
LDN = 203,
+ CS = 204,
Irsensor = 205,
Capture = 206,
Manu = 208,
ATK = 209,
+ WEB = 210,
+ LCS = 211,
GRC = 212,
+ Repair = 213,
+ Album = 214,
+ RID = 215,
Migration = 216,
MigrationLdcServ = 217,
+ HIDBUS = 218,
+ ENS = 219,
+ WebSocket = 223,
+ DCDMTP = 227,
+ PGL = 228,
+ Notification = 229,
+ INS = 230,
+ LP2P = 231,
+ RCD = 232,
+ LCM40607 = 233,
+ PRC = 235,
+ TMAHTC = 237,
+ ECTX = 238,
+ MNPP = 239,
+ HSHL = 240,
+ CAPMTP = 242,
+ DP2HDMI = 244,
+ Cradle = 245,
+ SProfile = 246,
+ NDRM = 250,
+ TSPM = 499,
+ DevMenu = 500,
GeneralWebApplet = 800,
WifiWebAuthApplet = 809,
WhitelistedApplet = 810,
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-03 16:33:56 +0200