mika/libnx
1
0
Fork 0
mirror of https://github.com/switchbrew/libnx.git synced 2025-06-28 15:52: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 pmdmntStartProcess(u64 pid);
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 pmdmntEnableDebugForApplication(Handle* handle_out);
Result pmdmntDisableDebug(void);
Result pmdmntEnableDebugForApplication(Event* out);
Result pmdmntDisableDebug(u32 which);
Result pminfoGetTitleId(u64* title_id_out, u64 pid);

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

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