mika/libnx
1
0
Fork 0
mirror of https://github.com/switchbrew/libnx.git synced 2025-06-29 16:22:39 +02:00
Code Issues Packages Projects Releases Wiki Activity

pm: update to use new-ipc

Browse Source
This commit is contained in:
Michael Scire 2019-09-20 12:16:54 -07:00
parent 10d07f3a8a
commit f465206082
2 changed files with 90 additions and 767 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
nx/include/switch/services/pm.h
View File

@ -79,10 +79,10 @@ Service* pmbmGetServiceSession(void);
Result pmdmntGetDebugProcesses(u32* out_count, u64* out_pids, size_t max_pids); Result pmdmntGetDebugProcesses(u32* out_count, u64* out_pids, size_t max_pids);
Result pmdmntStartProcess(u64 pid); Result pmdmntStartProcess(u64 pid);
Result pmdmntGetTitlePid(u64* pid_out, u64 title_id); Result pmdmntGetTitlePid(u64* pid_out, u64 title_id);
Result pmdmntEnableDebugForTitleId(Handle* handle_out, u64 title_id); Result pmdmntEnableDebugForTitleId(Event* out, u64 title_id);
Result pmdmntGetApplicationPid(u64* pid_out); Result pmdmntGetApplicationPid(u64* pid_out);
Result pmdmntEnableDebugForApplication(Handle* handle_out); Result pmdmntEnableDebugForApplication(Event* out);
Result pmdmntDisableDebug(void); Result pmdmntDisableDebug(u32 which);
Result pminfoGetTitleId(u64* title_id_out, u64 pid); Result pminfoGetTitleId(u64* title_id_out, u64 pid);

851
nx/source/services/pm.c
View File

@ -1,837 +1,160 @@
// Copyright 2017 plutoo // Copyright 2017 plutoo
#include "types.h" #define NX_SERVICE_ASSUME_NON_DOMAIN
#include "result.h" #include "service_guard.h"
#include "arm/atomics.h"
#include "kernel/ipc.h"
#include "runtime/hosversion.h" #include "runtime/hosversion.h"
#include "services/pm.h" #include "services/pm.h"
#include "services/sm.h"
static Service g_pmdmntSrv, g_pmshellSrv, g_pminfoSrv, g_pmbmSrv; #define PM_GENERATE_SERVICE_INIT(name) \
static u64 g_pmdmntRefCnt, g_pmshellRefCnt, g_pminfoRefCnt, g_pmbmRefCnt; static Service g_pm##name##Srv; \
\
Result pmdmntInitialize(void) NX_GENERATE_SERVICE_GUARD(pm##name); \
{ \
atomicIncrement64(&g_pmdmntRefCnt); Result _pm##name##Initialize(void) { \
return smGetService(&g_pm##name##Srv, "pm:"#name); \
if (serviceIsActive(&g_pmdmntSrv)) } \
return 0; \
void _pm##name##Cleanup(void) { \
return smGetService(&g_pmdmntSrv, "pm:dmnt"); serviceClose(&g_pm##name##Srv); \
} \
\
Service* pm##name##GetServiceSession(void) { \
return &g_pm##name##Srv; \
} }
void pmdmntExit(void) PM_GENERATE_SERVICE_INIT(dmnt);
{ PM_GENERATE_SERVICE_INIT(shell);
if (atomicDecrement64(&g_pmdmntRefCnt) == 0) { PM_GENERATE_SERVICE_INIT(info);
serviceClose(&g_pmdmntSrv); PM_GENERATE_SERVICE_INIT(bm);
}
}
Service* pmdmntGetServiceSession(void) {
return &g_pmdmntSrv;
}
Result pminfoInitialize(void)
{
atomicIncrement64(&g_pminfoRefCnt);
if (serviceIsActive(&g_pminfoSrv))
return 0;
return smGetService(&g_pminfoSrv, "pm:info");
}
void pminfoExit(void)
{
if (atomicDecrement64(&g_pminfoRefCnt) == 0) {
serviceClose(&g_pminfoSrv);
}
}
Service* pminfoGetServiceSession(void)
{
return &g_pminfoSrv;
}
Result pmshellInitialize(void)
{
atomicIncrement64(&g_pmshellRefCnt);
if (serviceIsActive(&g_pmshellSrv))
return 0;
return smGetService(&g_pmshellSrv, "pm:shell");
}
void pmshellExit(void)
{
if (atomicDecrement64(&g_pmshellRefCnt) == 0) {
serviceClose(&g_pmshellSrv);
}
}
Service* pmshellGetServiceSession(void)
{
return &g_pmshellSrv;
}
Result pmbmInitialize(void)
{
atomicIncrement64(&g_pmbmRefCnt);
if (serviceIsActive(&g_pmbmSrv))
return 0;
return smGetService(&g_pmbmSrv, "pm:bm");
}
void pmbmExit(void)
{
if (atomicDecrement64(&g_pmbmRefCnt) == 0) {
serviceClose(&g_pmbmSrv);
}
}
Service* pmbmGetServiceSession(void)
{
return &g_pmbmSrv;
}
Result pmdmntGetDebugProcesses(u32* out_count, u64* out_pids, size_t max_pids) { Result pmdmntGetDebugProcesses(u32* out_count, u64* out_pids, size_t max_pids) {
IpcCommand c; const u64 cmd_id = hosversionAtLeast(5,0,0) ? 0 : 1;
ipcInitialize(&c); return serviceDispatchOut(&g_pmdmntSrv, cmd_id, *out_count,
ipcAddRecvBuffer(&c, out_pids, sizeof(*out_pids) * max_pids, BufferType_Normal); .buffer_attrs = {
SfBufferAttr_HipcMapAlias | SfBufferAttr_Out,
struct { },
u64 magic; .buffers = {
u64 cmd_id; { out_pids, max_pids * sizeof(*out_pids) },
} *raw; },
);
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = hosversionAtLeast(5,0,0) ? 0 : 1;
Result rc = serviceIpcDispatch(&g_pmdmntSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
u32 out_count;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc)) {
if (out_count) *out_count = resp->out_count;
}
}
return rc;
} }
Result pmdmntStartProcess(u64 pid) { Result pmdmntStartProcess(u64 pid) {
IpcCommand c; const u64 cmd_id = hosversionAtLeast(5,0,0) ? 1 : 2;
ipcInitialize(&c); return serviceDispatchIn(&g_pmdmntSrv, cmd_id, pid);
struct {
u64 magic;
u64 cmd_id;
u64 pid;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = hosversionAtLeast(5,0,0) ? 1 : 2;
raw->pid = pid;
Result rc = serviceIpcDispatch(&g_pmdmntSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
}
return rc;
} }
Result pmdmntGetTitlePid(u64* pid_out, u64 title_id) { Result pmdmntGetTitlePid(u64* pid_out, u64 title_id) {
IpcCommand c; const u64 cmd_id = hosversionAtLeast(5,0,0) ? 2 : 3;
ipcInitialize(&c); return serviceDispatchInOut(&g_pmdmntSrv, cmd_id, title_id, *pid_out);
struct {
u64 magic;
u64 cmd_id;
u64 title_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = hosversionAtLeast(5,0,0) ? 2 : 3;
raw->title_id = title_id;
Result rc = serviceIpcDispatch(&g_pmdmntSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
u64 pid;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc)) {
*pid_out = resp->pid;
}
}
return rc;
} }
Result pmdmntEnableDebugForTitleId(Handle* handle_out, u64 title_id) { Result pmdmntEnableDebugForTitleId(Event* out_event, u64 title_id) {
IpcCommand c; const u64 cmd_id = hosversionAtLeast(5,0,0) ? 3 : 4;
ipcInitialize(&c); Handle event = INVALID_HANDLE;
Result rc = serviceDispatchIn(&g_pmdmntSrv, cmd_id, title_id,
struct { .out_handle_attrs = { SfOutHandleAttr_HipcCopy },
u64 magic; .out_handles = &event,
u64 cmd_id; );
u64 title_id; if (R_SUCCEEDED(rc))
} *raw; eventLoadRemote(out_event, event, true);
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = hosversionAtLeast(5,0,0) ? 3 : 4;
raw->title_id = title_id;
Result rc = serviceIpcDispatch(&g_pmdmntSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc)) {
*handle_out = r.Handles[0];
}
}
return rc;
}
Result pminfoGetTitleId(u64* title_id_out, u64 pid) {
IpcCommand c;
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
u64 pid;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 0;
raw->pid = pid;
Result rc = serviceIpcDispatch(&g_pminfoSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
u64 title_id;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc)) {
*title_id_out = resp->title_id;
}
}
return rc; return rc;
} }
Result pmdmntGetApplicationPid(u64* pid_out) { Result pmdmntGetApplicationPid(u64* pid_out) {
IpcCommand c; const u64 cmd_id = hosversionAtLeast(5,0,0) ? 4 : 5;
ipcInitialize(&c); return serviceDispatchOut(&g_pmdmntSrv, cmd_id, *pid_out);
}
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = hosversionAtLeast(5,0,0) ? 4 : 5;
Result rc = serviceIpcDispatch(&g_pmdmntSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
u64 pid;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc)) {
*pid_out = resp->pid;
}
}
Result pmdmntEnableDebugForApplication(Event* out_event) {
const u64 cmd_id = hosversionAtLeast(5,0,0) ? 5 : 6;
Handle event = INVALID_HANDLE;
Result rc = serviceDispatch(&g_pmdmntSrv, cmd_id,
.out_handle_attrs = { SfOutHandleAttr_HipcCopy },
.out_handles = &event,
);
if (R_SUCCEEDED(rc))
eventLoadRemote(out_event, event, true);
return rc; return rc;
} }
Result pmdmntEnableDebugForApplication(Handle* handle_out) { Result pmdmntDisableDebug(u32 which) {
IpcCommand c;
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = hosversionAtLeast(5,0,0) ? 5 : 6;
Result rc = serviceIpcDispatch(&g_pmdmntSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc)) {
*handle_out = r.Handles[0];
}
}
return rc;
}
Result pmdmntDisableDebug(void) {
if (hosversionBefore(6,0,0)) return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer); if (hosversionBefore(6,0,0)) return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
return serviceDispatchIn(&g_pmdmntSrv, 6, which);
IpcCommand c;
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 6;
Result rc = serviceIpcDispatch(&g_pmdmntSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
}
return rc;
} }
Result pmshellLaunchProcess(u32 launch_flags, u64 titleID, u64 storageID, u64 *pid) { Result pmshellLaunchProcess(u32 launch_flags, u64 titleID, u64 storageID, u64 *pid) {
IpcCommand c; const struct {
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
u32 launch_flags; u32 launch_flags;
u64 titleID; u64 titleID;
u64 storageID; u64 storageID;
} *raw; } in = { launch_flags, titleID, storageID };
return serviceDispatchInOut(&g_pmshellSrv, 0, in, *pid);
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 0;
raw->launch_flags = launch_flags;
raw->titleID = titleID;
raw->storageID = storageID;
Result rc = serviceIpcDispatch(&g_pmshellSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
u64 pid;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc) && pid) *pid = resp->pid;
}
return rc;
} }
Result pmshellTerminateProcessByProcessId(u64 processID) { Result pmshellTerminateProcessByProcessId(u64 processID) {
IpcCommand c; return serviceDispatchIn(&g_pmshellSrv, 1, processID);
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
u64 processID;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 1;
raw->processID = processID;
Result rc = serviceIpcDispatch(&g_pmshellSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
}
return rc;
} }
Result pmshellTerminateProcessByTitleId(u64 titleID) { Result pmshellTerminateProcessByTitleId(u64 titleID) {
IpcCommand c; return serviceDispatchIn(&g_pmshellSrv, 2, titleID);
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
u64 titleID;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 2;
raw->titleID = titleID;
Result rc = serviceIpcDispatch(&g_pmshellSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
}
return rc;
} }
Result pmshellGetProcessEvent(Event* out) { Result pmshellGetProcessEvent(Event* out_event) {
IpcCommand c; Handle event = INVALID_HANDLE;
ipcInitialize(&c); Result rc = serviceDispatch(&g_pmshellSrv, 3,
.out_handle_attrs = { SfOutHandleAttr_HipcCopy },
struct { .out_handles = &event,
u64 magic; );
u64 cmd_id; if (R_SUCCEEDED(rc))
} *raw; eventLoadRemote(out_event, event, true);
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 3;
Result rc = serviceIpcDispatch(&g_pmshellSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc)) {
eventLoadRemote(out, r.Handles[0], true);
}
}
return rc; return rc;
} }
Result pmshellGetProcessEventInfo(PmProcessEventInfo* out) { Result pmshellGetProcessEventInfo(PmProcessEventInfo* out) {
IpcCommand c; _Static_assert(sizeof(out->event) == sizeof(u32), "PmProcessEvent");
ipcInitialize(&c); return serviceDispatchOut(&g_pmshellSrv, 4, *out);
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 4;
Result rc = serviceIpcDispatch(&g_pmshellSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
u32 event;
u32 pad;
u64 process_id;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc)) {
if (out) {
out->event = (PmProcessEvent)resp->event;
out->process_id = resp->process_id;
}
}
}
return rc;
} }
Result pmshellFinalizeDeadProcess(u64 pid) { Result pmshellFinalizeDeadProcess(u64 pid) {
if (hosversionAtLeast(5,0,0)) return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer); if (hosversionAtLeast(5,0,0)) return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
return serviceDispatchIn(&g_pmshellSrv, 5, pid);
IpcCommand c;
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
u64 pid;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 5;
raw->pid = pid;
Result rc = serviceIpcDispatch(&g_pmshellSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
}
return rc;
} }
Result pmshellClearProcessExceptionOccurred(u64 pid) { Result pmshellClearProcessExceptionOccurred(u64 pid) {
if (hosversionAtLeast(5,0,0)) return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer); if (hosversionAtLeast(5,0,0)) return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
return serviceDispatchIn(&g_pmshellSrv, 6, pid);
IpcCommand c;
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
u64 pid;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 6;
raw->pid = pid;
Result rc = serviceIpcDispatch(&g_pmshellSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
}
return rc;
} }
Result pmshellNotifyBootFinished(void) { Result pmshellNotifyBootFinished(void) {
IpcCommand c; const u64 cmd_id = hosversionAtLeast(5,0,0) ? 5 : 7;
ipcInitialize(&c); return serviceDispatch(&g_pmshellSrv, cmd_id);
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = hosversionAtLeast(5,0,0) ? 5 : 7;
Result rc = serviceIpcDispatch(&g_pmshellSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
}
return rc;
} }
Result pmshellGetApplicationPid(u64* pid_out) { Result pmshellGetApplicationPid(u64* pid_out) {
IpcCommand c; const u64 cmd_id = hosversionAtLeast(5,0,0) ? 6 : 8;
ipcInitialize(&c); return serviceDispatchOut(&g_pmshellSrv, cmd_id, *pid_out);
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = hosversionAtLeast(5,0,0) ? 6 : 8;
Result rc = serviceIpcDispatch(&g_pmshellSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
u64 pid;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc)) {
*pid_out = resp->pid;
}
}
return rc;
} }
Result pmshellBoostSystemMemoryResourceLimit(u64 boost_size) { Result pmshellBoostSystemMemoryResourceLimit(u64 boost_size) {
if (hosversionBefore(4,0,0)) return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer); if (hosversionBefore(4,0,0)) return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
const u64 cmd_id = hosversionAtLeast(5,0,0) ? 7 : 9;
IpcCommand c; return serviceDispatchIn(&g_pmshellSrv, cmd_id, boost_size);
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
u64 boost_size;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = hosversionAtLeast(5,0,0) ? 7 : 9;
raw->boost_size = boost_size;
Result rc = serviceIpcDispatch(&g_pmshellSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
}
return rc;
} }
Result pmshellBoostSystemThreadResourceLimit(void) { Result pmshellBoostSystemThreadResourceLimit(void) {
if (hosversionBefore(7,0,0)) return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer); if (hosversionBefore(7,0,0)) return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
return serviceDispatch(&g_pmshellSrv, 8);
}
IpcCommand c; Result pminfoGetTitleId(u64* title_id_out, u64 pid) {
ipcInitialize(&c); return serviceDispatchInOut(&g_pminfoSrv, 0, pid, *title_id_out);
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 8;
Result rc = serviceIpcDispatch(&g_pmshellSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
}
return rc;
} }
Result pmbmGetBootMode(PmBootMode *out) { Result pmbmGetBootMode(PmBootMode *out) {
IpcCommand c; _Static_assert(sizeof(*out) == sizeof(u32), "PmBootMode");
ipcInitialize(&c); return serviceDispatchOut(&g_pmbmSrv, 0, *out);
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 0;
Result rc = serviceIpcDispatch(&g_pmbmSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
u32 boot_mode;
} *resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc) && out) {
*out = (PmBootMode)resp->boot_mode;
}
}
return rc;
} }
Result pmbmSetMaintenanceBoot(void) { Result pmbmSetMaintenanceBoot(void) {
IpcCommand c; return serviceDispatch(&g_pmbmSrv, 1);
ipcInitialize(&c);
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = ipcPrepareHeader(&c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 1;
Result rc = serviceIpcDispatch(&g_pmbmSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
ipcParse(&r);
struct {
u64 magic;
u64 result;
} *resp = r.Raw;
rc = resp->result;
}
return rc;
} }