Skip to content

Commit aabaa47

Browse files
PataterPatater
committed
rpc2: Add RPC2
1 parent 0a5106f commit aabaa47

File tree

3 files changed

+355
-0
lines changed

3 files changed

+355
-0
lines changed

‎api/inc/rpc2.h

+131
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,131 @@
1+
/*
2+
* Copyright (c) 2017, ARM Limited, All Rights Reserved
3+
* SPDX-License-Identifier: Apache-2.0
4+
*
5+
* Licensed under the Apache License, Version 2.0 (the "License"); you may
6+
* not use this file except in compliance with the License.
7+
* You may obtain a copy of the License at
8+
*
9+
* http://www.apache.org/licenses/LICENSE-2.0
10+
*
11+
* Unless required by applicable law or agreed to in writing, software
12+
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
13+
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14+
* See the License for the specific language governing permissions and
15+
* limitations under the License.
16+
*/
17+
#ifndef __UVISOR_API_RPC2_H__
18+
#define __UVISOR_API_RPC2_H__
19+
20+
#include "api/inc/uvisor_exports.h"
21+
#include <stdint.h>
22+
#include <stddef.h>
23+
24+
typedef struct {
25+
uint32_t magic;
26+
} rpc2_gateway_t;
27+
28+
typedef int (* rpc2_fnptr_t)(uint32_t p0, uint32_t p1, uint32_t p2, uint32_t p3,
29+
int box_id_caller);
30+
31+
/** RPC Call Descriptor
32+
*
33+
* This is the descriptor sent by RPC senders and handled by RPC receivers.
34+
*
35+
* @param[in] p0 first parameter
36+
* @param[in] p1 second parameter
37+
* @param[in] p2 third parameter
38+
* @param[in] p3 fourth parameter
39+
* @param[in] fnptr the function to call
40+
* @param[in] completion_port the port number to wait for completion on
41+
*/
42+
typedef struct uvisor_rpc2_call {
43+
uint32_t p0;
44+
uint32_t p1;
45+
uint32_t p2;
46+
uint32_t p3;
47+
rpc2_fnptr_t fnptr;
48+
size_t completion_port;
49+
} uvisor_rpc2_call_t;
50+
51+
/** RPC Return Descriptor
52+
*
53+
* This is the descriptor sent by RPC receivers and handled by RPC senders.
54+
*
55+
* @param[in] ret the return value from the call
56+
*/
57+
typedef struct uvisor_rpc2_return {
58+
uint32_t ret;
59+
} uvisor_rpc2_return_t;
60+
61+
/** RPC Completion Cookie
62+
*
63+
* This is used to wait for an RPC to complete.
64+
*
65+
* @param[in] completion_port the port number to wait for completion on
66+
* @param[in] box_id the id of the box we expect completion from
67+
*/
68+
typedef struct uvisor_rpc2_cookie {
69+
size_t completion_port;
70+
int box_id;
71+
} uvisor_rpc2_cookie_t;
72+
73+
/** Wait for incoming RPC.
74+
*
75+
* @param fn_ptr_array an array of RPC function targets that this call to
76+
* `rpc_fncall_waitfor` should handle RPC to
77+
* @param fn_count the number of function targets in this array
78+
* @param box_id an ID of a box that is allowed to send to this box, or
79+
* UVISOR_BOX_ID_ANY to allow messages from any box
80+
* @param timeout_ms specifies how long to wait (in ms) for an incoming
81+
* RPC message before returning
82+
*/
83+
UVISOR_EXTERN int rpc_waitfor(const rpc2_fnptr_t fn_array[], size_t fn_count, int box_id, uint32_t timeout_ms);
84+
85+
/** Start an asynchronous RPC.
86+
*
87+
* After this call successfully completes, the caller can, at any time in any
88+
* thread, wait on the cookie to get the result of the call.
89+
* @param[in] p0 first parameter
90+
* @param[in] p1 second parameter
91+
* @param[in] p2 third parameter
92+
* @param[in] p3 fourth parameter
93+
* @param[in] fnptr the function to call
94+
* @param[in] box_id the ID of the box to call the function within
95+
* @param[out] cookie wait on this cookie to get the result of the call
96+
* @returns non-zero on error, zero on success
97+
*/
98+
UVISOR_EXTERN int rpc_async(uint32_t p0, uint32_t p1, uint32_t p2, uint32_t p3,
99+
const rpc2_fnptr_t fnptr, int box_id, uvisor_rpc2_cookie_t * cookie);
100+
101+
/** Wait for an outgoing RPC to finish.
102+
*
103+
* Wait for the result of a previously started asynchronous RPC. After this
104+
* call, ret will contain the return value of the RPC. The return value of this
105+
* function may indicate that there was an error or a timeout with non-zero.
106+
*
107+
* @param cookie[in] The cookie to wait on for the result of an asynchronous RPC
108+
* @param timeout_ms[in] How long to wait (in ms) for the asynchronous RPC
109+
* message to finish before returning
110+
* @param ret[out] The return value resulting from the finished RPC to
111+
* the target function. Use NULL when don't care.
112+
* @returns Non-zero on error or timeout, zero on successful wait
113+
*/
114+
UVISOR_EXTERN int rpc_wait(uvisor_rpc2_cookie_t cookie, uint32_t timeout_ms, uint32_t * ret);
115+
116+
/** Start an asynchronous RPC with a gateway.
117+
*
118+
* After this call successfully completes, the caller can, at any time in any
119+
* thread, wait on the cookie to get the result of the call.
120+
* @param[in] p0 first parameter
121+
* @param[in] p1 second parameter
122+
* @param[in] p2 third parameter
123+
* @param[in] p3 fourth parameter
124+
* @param[in] gateway the address of the RPC gateway
125+
* @param[out] cookie wait on this cookie to get the result of the call
126+
* @returns non-zero on error, zero on success
127+
*/
128+
UVISOR_EXTERN int rpc_gateway_async(uint32_t p0, uint32_t p1, uint32_t p2, uint32_t p3,
129+
const rpc2_gateway_t * gateway, uvisor_rpc2_cookie_t * cookie);
130+
131+
#endif

‎api/inc/uvisor-lib.h

+1
Original file line numberDiff line numberDiff line change
@@ -34,6 +34,7 @@
3434
#include "api/inc/interrupts.h"
3535
#include "api/inc/register_gateway.h"
3636
#include "api/inc/rpc.h"
37+
#include "api/inc/rpc2.h"
3738
#include "api/inc/ipc.h"
3839
#include "api/inc/rpc_gateway.h"
3940
#include "api/inc/secure_access.h"

‎api/src/rpc2.c

+223
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,223 @@
1+
/*
2+
* Copyright (c) 2017, ARM Limited, All Rights Reserved
3+
* SPDX-License-Identifier: Apache-2.0
4+
*
5+
* Licensed under the Apache License, Version 2.0 (the "License"); you may
6+
* not use this file except in compliance with the License.
7+
* You may obtain a copy of the License at
8+
*
9+
* http://www.apache.org/licenses/LICENSE-2.0
10+
*
11+
* Unless required by applicable law or agreed to in writing, software
12+
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
13+
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14+
* See the License for the specific language governing permissions and
15+
* limitations under the License.
16+
*/
17+
#include "api/inc/rpc2.h"
18+
#include "api/inc/ipc.h"
19+
20+
/* A generic port for all incoming RPC. */
21+
static const size_t UVISOR_RPC_PORT = 'f'; /* 'f' is for function. That's good enough for me. */
22+
23+
static uint32_t wait_for_all(uint32_t wait_tokens)
24+
{
25+
uint32_t done_tokens = 0;
26+
static const uint32_t timeout_ms = 0;
27+
static const uint32_t delay_iterations = 100000;
28+
29+
/* Spin until all tokens complete. */
30+
while (ipc_waitforall(wait_tokens, &done_tokens, timeout_ms))
31+
{
32+
/* Waste time a bit. */
33+
/* FIXME: When we can run RTOS in other boxes, or have a uVisor
34+
* scheduler yield or sleep function, remove this room heater loop. */
35+
for (volatile int i = 0; i <= delay_iterations; i++);
36+
}
37+
38+
return done_tokens;
39+
}
40+
41+
static int do_rpc(int caller_box_id, uvisor_rpc2_call_t * rpc_msg)
42+
{
43+
int status;
44+
uint32_t done_tokens;
45+
uvisor_rpc2_return_t rpc_ret;
46+
uvisor_ipc_desc_t desc;
47+
48+
/* Do the RPC. */
49+
rpc_ret.ret = rpc_msg->fnptr(rpc_msg->p0, rpc_msg->p1, rpc_msg->p2, rpc_msg->p3,
50+
caller_box_id);
51+
52+
/* Send the RPC response to the port the caller box expects. */
53+
desc.box_id = caller_box_id;
54+
desc.port = rpc_msg->completion_port;
55+
desc.len = sizeof(rpc_ret);
56+
57+
status = ipc_send(&desc, &rpc_ret);
58+
if (status) {
59+
return status;
60+
}
61+
62+
/* Wait for the send to complete, to keep the IPC descriptor and RPC
63+
* response in memory long enough for uVisor to read them (before they go
64+
* out of scope). */
65+
done_tokens = wait_for_all(desc.token);
66+
if (!(done_tokens & desc.token)) {
67+
/* Token we wanted didn't complete */
68+
return -1;
69+
}
70+
71+
return 0;
72+
}
73+
74+
static int handle_rpc(int caller_box_id, uvisor_rpc2_call_t * rpc_msg, const rpc2_fnptr_t fn_array[], size_t fn_count)
75+
{
76+
size_t i;
77+
/* Check if the target function is in the fn_array */
78+
for (i = 0; i < fn_count; ++i) {
79+
if (fn_array[i] == rpc_msg->fnptr) {
80+
return do_rpc(caller_box_id, rpc_msg);
81+
}
82+
}
83+
84+
/* The RPC target was not in the list of acceptable RPC targets. */
85+
return -1;
86+
}
87+
88+
int rpc_waitfor(const rpc2_fnptr_t fn_array[], size_t fn_count, int box_id, uint32_t timeout_ms)
89+
{
90+
int status;
91+
uvisor_ipc_desc_t desc = {0};
92+
uvisor_rpc2_call_t rpc_msg;
93+
94+
/* Receive the RPC response over the generic RPC port. */
95+
desc.box_id = box_id;
96+
desc.port = UVISOR_RPC_PORT;
97+
desc.len = sizeof(rpc_msg);
98+
99+
status = ipc_recv(&desc, &rpc_msg);
100+
if (status) {
101+
return status;
102+
}
103+
104+
/* Wait for the receive to complete. */
105+
if (timeout_ms == 0) {
106+
/* Try once. */
107+
uint32_t done_tokens = 0;
108+
status = ipc_waitforall(desc.token, &done_tokens, timeout_ms);
109+
if (status) {
110+
return status;
111+
}
112+
113+
/* See if done_tokens matches */
114+
if (done_tokens != desc.token) {
115+
/* Not good. No match. Fail. */
116+
return -1;
117+
}
118+
} else {
119+
/* Spin forever */
120+
wait_for_all(desc.token);
121+
}
122+
123+
/* Handle the RPC */
124+
handle_rpc(desc.box_id, &rpc_msg, fn_array, fn_count);
125+
126+
return 0;
127+
}
128+
129+
int rpc_async(uint32_t p0, uint32_t p1, uint32_t p2, uint32_t p3,
130+
const rpc2_fnptr_t fnptr, int box_id, uvisor_rpc2_cookie_t *cookie)
131+
{
132+
int status;
133+
uint32_t done_tokens;
134+
size_t completion_port;
135+
uvisor_rpc2_call_t rpc_msg = {0};
136+
uvisor_ipc_desc_t desc = {0};
137+
138+
/* Allocate a return port to receive a response on. */
139+
completion_port = 0; /* XXX TODO */
140+
141+
/* Build the RPC message. */
142+
rpc_msg.p0 = p0;
143+
rpc_msg.p1 = p1;
144+
rpc_msg.p2 = p2;
145+
rpc_msg.p3 = p3;
146+
rpc_msg.fnptr = fnptr;
147+
rpc_msg.completion_port = completion_port;
148+
149+
/* Send the message to the generic RPC port. */
150+
desc.box_id = box_id;
151+
desc.port = UVISOR_RPC_PORT;
152+
desc.len = sizeof(rpc_msg);
153+
154+
status = ipc_send(&desc, &rpc_msg);
155+
if (status) {
156+
return status;
157+
}
158+
159+
/* Wait for the send to complete, to keep the IPC descriptor and RPC
160+
* message in memory long enough for uVisor to read them (before they go
161+
* out of scope). */
162+
done_tokens = wait_for_all(desc.token);
163+
if (!(done_tokens & desc.token)) {
164+
/* Token we wanted didn't complete */
165+
return -1;
166+
}
167+
168+
/* The message has been sent. Update the cookie with the port we should wait on. */
169+
cookie->completion_port = completion_port;
170+
cookie->box_id = box_id;
171+
172+
return 0;
173+
}
174+
175+
int rpc_wait(uvisor_rpc2_cookie_t cookie, uint32_t timeout_ms, uint32_t * ret)
176+
{
177+
int status;
178+
uvisor_ipc_desc_t desc = {0};
179+
uvisor_rpc2_return_t rpc_ret = {0};
180+
181+
/* Receive the RPC response over the negotiated port for the call. */
182+
desc.box_id = cookie.box_id;
183+
desc.port = cookie.completion_port;
184+
desc.len = sizeof(rpc_ret);
185+
186+
status = ipc_recv(&desc, &rpc_ret);
187+
if (status) {
188+
return status;
189+
}
190+
191+
/* Wait for the receive to complete. */
192+
if (timeout_ms == 0) {
193+
/* Try once. */
194+
uint32_t done_tokens = 0;
195+
status = ipc_waitforall(desc.token, &done_tokens, timeout_ms);
196+
if (status) {
197+
return status;
198+
}
199+
200+
/* See if done_tokens matches */
201+
if (done_tokens != desc.token) {
202+
/* Not good. No match. Fail. */
203+
return -1;
204+
}
205+
} else {
206+
/* Spin forever */
207+
wait_for_all(desc.token);
208+
}
209+
210+
/* If ret is provided, update ret with the RPC return value */
211+
if (ret) {
212+
*ret = rpc_ret.ret;
213+
}
214+
215+
return 0;
216+
}
217+
218+
int rpc_gateway_async(uint32_t p0, uint32_t p1, uint32_t p2, uint32_t p3,
219+
const rpc2_gateway_t * gateway, uvisor_rpc2_cookie_t * cookie)
220+
{
221+
/* TODO */
222+
return 0;
223+
}

0 commit comments

Comments
 (0)