mika/libnx
1
0
Fork 0
mirror of https://github.com/switchbrew/libnx.git synced 2025-06-21 20:42:44 +02:00
Code Issues Packages Projects Releases Wiki Activity

ro: update to use new-ipc

Browse Source
This commit is contained in:
Michael Scire 2019-09-20 12:17:57 -07:00
parent f5f768ea5c
commit 76daefae78
1 changed files with 49 additions and 256 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

305
nx/source/services/ro.c
View File

@ -1,86 +1,60 @@
// Copyright 2018 SciresM // Copyright 2018 SciresM
#define NX_SERVICE_ASSUME_NON_DOMAIN
#include <string.h> #include <string.h>
#include "types.h" #include "service_guard.h"
#include "result.h"
#include "arm/atomics.h"
#include "kernel/ipc.h"
#include "runtime/hosversion.h" #include "runtime/hosversion.h"
#include "services/ro.h" #include "services/ro.h"
#include "services/sm.h"
static Service g_roSrv, g_ro1Srv, g_dmntSrv; static Service g_roSrv, g_ro1Srv, g_dmntSrv;
static u64 g_roRefCnt, g_ro1RefCnt, g_dmntRefCnt;
static Result _rosrvInitialize(Service* srv); NX_GENERATE_SERVICE_GUARD(ldrRo);
static Result _rosrvLoadNro(Service* srv, u64* out_address, u64 nro_address, u64 nro_size, u64 bss_address, u64 bss_size); NX_GENERATE_SERVICE_GUARD(ro1);
static Result _rosrvUnloadNro(Service* srv, u64 nro_address); NX_GENERATE_SERVICE_GUARD(roDmnt);
static Result _rosrvLoadNrr(Service* srv, u64 cmd_id, u64 nrr_address, u64 nrr_size);
static Result _rosrvUnloadNrr(Service* srv, u64 nrr_address);
Result ldrRoInitialize(void) { NX_INLINE Result _rosrvInitialize(Service* srv);
atomicIncrement64(&g_roRefCnt); NX_INLINE Result _rosrvLoadNro(Service* srv, u64* out_address, u64 nro_address, u64 nro_size, u64 bss_address, u64 bss_size);
NX_INLINE Result _rosrvUnloadNro(Service* srv, u64 nro_address);
if (serviceIsActive(&g_roSrv)) NX_INLINE Result _rosrvLoadNrr(Service* srv, u64 cmd_id, u64 nrr_address, u64 nrr_size);
return 0; NX_INLINE Result _rosrvUnloadNrr(Service* srv, u64 nrr_address);
Result _ldrRoInitialize(void) {
Result rc = smGetService(&g_roSrv, "ldr:ro"); Result rc = smGetService(&g_roSrv, "ldr:ro");
if (R_SUCCEEDED(rc))
if (R_SUCCEEDED(rc)) {
rc = _rosrvInitialize(&g_roSrv); rc = _rosrvInitialize(&g_roSrv);
}
return rc; return rc;
} }
void ldrRoExit(void) { void _ldrRoCleanup(void) {
if (atomicDecrement64(&g_roRefCnt) == 0) serviceClose(&g_roSrv);
serviceClose(&g_roSrv);
} }
Service* ldrRoGetServiceSession(void) { Service* ldrRoGetServiceSession(void) {
return &g_roSrv; return &g_roSrv;
} }
Result ro1Initialize(void) { Result _ro1Initialize(void) {
if (hosversionBefore(7,0,0)) return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer); if (hosversionBefore(7,0,0)) return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
atomicIncrement64(&g_ro1RefCnt);
if (serviceIsActive(&g_ro1Srv))
return 0;
Result rc = smGetService(&g_ro1Srv, "ro:1"); Result rc = smGetService(&g_ro1Srv, "ro:1");
if (R_SUCCEEDED(rc))
if (R_SUCCEEDED(rc)) {
rc = _rosrvInitialize(&g_ro1Srv); rc = _rosrvInitialize(&g_ro1Srv);
}
return rc; return rc;
} }
void ro1Exit(void) { void _ro1Cleanup(void) {
if (atomicDecrement64(&g_ro1RefCnt) == 0) serviceClose(&g_ro1Srv);
serviceClose(&g_ro1Srv);
} }
Service* ro1GetServiceSession(void) { Service* ro1GetServiceSession(void) {
return &g_ro1Srv; return &g_ro1Srv;
} }
Result roDmntInitialize(void) { Result _roDmntInitialize(void) {
if (hosversionBefore(3,0,0)) return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer); if (hosversionBefore(3,0,0)) return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
atomicIncrement64(&g_dmntRefCnt);
if (serviceIsActive(&g_dmntSrv))
return 0;
return smGetService(&g_dmntSrv, "ro:dmnt"); return smGetService(&g_dmntSrv, "ro:dmnt");
} }
void roDmntExit(void) { void _roDmntCleanup(void) {
if (atomicDecrement64(&g_dmntRefCnt) == 0) serviceClose(&g_dmntSrv);
serviceClose(&g_dmntSrv);
} }
Service* roDmntGetServiceSession(void) { Service* roDmntGetServiceSession(void) {
@ -88,198 +62,46 @@ Service* roDmntGetServiceSession(void) {
} }
Result _rosrvInitialize(Service* srv) { Result _rosrvInitialize(Service* srv) {
IpcCommand c; return serviceDispatch(srv, 4,
ipcInitialize(&c); .in_num_handles = 1,
ipcSendHandleCopy(&c, CUR_PROCESS_HANDLE); .in_handles = { CUR_PROCESS_HANDLE },
ipcSendPid(&c); );
struct {
u64 magic;
u64 cmd_id;
} *raw;
raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 4;
Result rc = serviceIpcDispatch(srv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
struct {
u64 magic;
u64 result;
} *resp;
serviceIpcParse(srv, &r, sizeof(*resp));
resp = r.Raw;
rc = resp->result;
}
return rc;
} }
Result _rosrvLoadNro(Service* srv, u64* out_address, u64 nro_address, u64 nro_size, u64 bss_address, u64 bss_size) { Result _rosrvLoadNro(Service* srv, u64* out_address, u64 nro_address, u64 nro_size, u64 bss_address, u64 bss_size) {
IpcCommand c; const struct {
ipcInitialize(&c); u64 pid_placeholder;
ipcSendPid(&c);
struct {
u64 magic;
u64 cmd_id;
u64 pid;
u64 nro_address; u64 nro_address;
u64 nro_size; u64 nro_size;
u64 bss_address; u64 bss_address;
u64 bss_size; u64 bss_size;
} *raw; } in = { 0, nro_address, nro_size, bss_address, bss_size };
return serviceDispatchInOut(srv, 0, in, *out_address, .in_send_pid = true);
raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 0;
raw->pid = 0;
raw->nro_address = nro_address;
raw->nro_size = nro_size;
raw->bss_address = bss_address;
raw->bss_size = bss_size;
Result rc = serviceIpcDispatch(srv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
struct {
u64 magic;
u64 result;
u64 out_address;
} *resp;
serviceIpcParse(srv, &r, sizeof(*resp));
resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc)) {
if (out_address) *out_address = resp->out_address;
}
}
return rc;
} }
Result _rosrvUnloadNro(Service* srv, u64 nro_address) { Result _rosrvUnloadNro(Service* srv, u64 nro_address) {
IpcCommand c; const struct {
ipcInitialize(&c); u64 pid_placeholder;
ipcSendPid(&c);
struct {
u64 magic;
u64 cmd_id;
u64 pid;
u64 nro_address; u64 nro_address;
} *raw; } in = { 0, nro_address };
return serviceDispatchIn(srv, 1, in, .in_send_pid = true);
raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 1;
raw->pid = 0;
raw->nro_address = nro_address;
Result rc = serviceIpcDispatch(srv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
struct {
u64 magic;
u64 result;
} *resp;
serviceIpcParse(srv, &r, sizeof(*resp));
resp = r.Raw;
rc = resp->result;
}
return rc;
} }
Result _rosrvLoadNrr(Service* srv, u64 cmd_id, u64 nrr_address, u64 nrr_size) { Result _rosrvLoadNrr(Service* srv, u64 cmd_id, u64 nrr_address, u64 nrr_size) {
IpcCommand c; const struct {
ipcInitialize(&c); u64 pid_placeholder;
ipcSendPid(&c);
struct {
u64 magic;
u64 cmd_id;
u64 pid;
u64 nrr_address; u64 nrr_address;
u64 nrr_size; u64 nrr_size;
} *raw; } in = { 0, nrr_address, nrr_size };
return serviceDispatchIn(srv, cmd_id, in, .in_send_pid = true);
raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = cmd_id;
raw->pid = 0;
raw->nrr_address = nrr_address;
raw->nrr_size = nrr_size;
Result rc = serviceIpcDispatch(srv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
struct {
u64 magic;
u64 result;
} *resp;
serviceIpcParse(srv, &r, sizeof(*resp));
resp = r.Raw;
rc = resp->result;
}
return rc;
} }
Result _rosrvUnloadNrr(Service* srv, u64 nrr_address) { Result _rosrvUnloadNrr(Service* srv, u64 nrr_address) {
IpcCommand c; const struct {
ipcInitialize(&c); u64 pid_placeholder;
ipcSendPid(&c);
struct {
u64 magic;
u64 cmd_id;
u64 pid;
u64 nrr_address; u64 nrr_address;
} *raw; } in = { 0, nrr_address };
return serviceDispatchIn(srv, 3, in, .in_send_pid = true);
raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 3;
raw->pid = 0;
raw->nrr_address = nrr_address;
Result rc = serviceIpcDispatch(srv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
struct {
u64 magic;
u64 result;
} *resp;
serviceIpcParse(srv, &r, sizeof(*resp));
resp = r.Raw;
rc = resp->result;
}
return rc;
} }
Result ldrRoLoadNro(u64* out_address, u64 nro_address, u64 nro_size, u64 bss_address, u64 bss_size) { Result ldrRoLoadNro(u64* out_address, u64 nro_address, u64 nro_size, u64 bss_address, u64 bss_size) {
@ -326,41 +148,12 @@ Result ro1LoadNrrEx(u64 nrr_address, u64 nrr_size) {
} }
Result roDmntGetModuleInfos(u64 pid, LoaderModuleInfo *out_module_infos, size_t max_out_modules, u32 *num_out) { Result roDmntGetModuleInfos(u64 pid, LoaderModuleInfo *out_module_infos, size_t max_out_modules, u32 *num_out) {
IpcCommand c; return serviceDispatchInOut(&g_dmntSrv, 0, pid, *num_out,
ipcInitialize(&c); .buffer_attrs = {
SfBufferAttr_HipcMapAlias | SfBufferAttr_Out,
ipcAddRecvBuffer(&c, out_module_infos, max_out_modules * sizeof(*out_module_infos), BufferType_Normal); },
.buffers = {
struct { { out_module_infos, max_out_modules * sizeof(*out_module_infos) },
u64 magic; },
u64 cmd_id; );
u64 pid;
} *raw;
raw = serviceIpcPrepareHeader(&g_dmntSrv, &c, sizeof(*raw));
raw->magic = SFCI_MAGIC;
raw->cmd_id = 0;
raw->pid = pid;
Result rc = serviceIpcDispatch(&g_dmntSrv);
if (R_SUCCEEDED(rc)) {
IpcParsedCommand r;
struct {
u64 magic;
u64 result;
u32 num_out;
} *resp;
serviceIpcParse(&g_dmntSrv, &r, sizeof(*resp));
resp = r.Raw;
rc = resp->result;
if (R_SUCCEEDED(rc) && num_out != NULL) {
*num_out = resp->num_out;
}
}
return rc;
} }