/external/mbed-os/features/FEATURE_UVISOR/includes/uvisor/api/inc/rpc_gateway.h

https://github.com/adamgreen/gcc4mbed · C Header · 272 lines · 170 code · 36 blank · 66 comment · 0 complexity · 327d5f903494fa4389117ad2e5b94045 MD5 · raw file 

    

  1. /*
    2. 

  2.  * Copyright (c) 2016, ARM Limited, All Rights Reserved
    3. 

  3.  * SPDX-License-Identifier: Apache-2.0
    4. 

  4.  *
    5. 

  5.  * Licensed under the Apache License, Version 2.0 (the "License"); you may
    6. 

  6.  * not use this file except in compliance with the License.
    7. 

  7.  * You may obtain a copy of the License at
    8. 

  8.  *
    9. 

  9.  * http://www.apache.org/licenses/LICENSE-2.0
    10. 

  10.  *
    11. 

  11.  * Unless required by applicable law or agreed to in writing, software
    12. 

  12.  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
    13. 

  13.  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14. 

  14.  * See the License for the specific language governing permissions and
    15. 

  15.  * limitations under the License.
    16. 

  16.  */
    17. 

  17. #ifndef __UVISOR_API_RPC_GATEWAY_H__
    18. 

  18. #define __UVISOR_API_RPC_GATEWAY_H__
    19. 

  19. 

  20. #include "api/inc/rpc_gateway_exports.h"
    21. 

  21. #include "api/inc/rpc.h"
    22. 

  22. #include "api/inc/uvisor_exports.h"
    23. 

  23. #include <stdint.h>
    24. 

  24. 

  25. /** Synchronous RPC Gateway
    26. 

  26.  *
    27. 

  27.  * This macro declares a new function pointer (with no name mangling) named
    28. 

  28.  * `gw_name` to perform a remote procedure call (RPC) to the target function
    29. 

  29.  * given by `fn_name`. RPCs are assembled into a read-only flash structure that
    30. 

  30.  * is read and validated by uVisor before performing the operation.
    31. 

  31.  *
    32. 

  32.  * Create function with following signature:
    33. 

  33.  * UVISOR_EXTERN fn_ret gw_name(uint32_t a, uint32_t b);
    34. 

  34.  *
    35. 

  35.  * @param box_name[in] The name of the source box as declared in
    36. 

  36.  *                     `UVISOR_BOX_CONFIG`
    37. 

  37.  * @param gw_name[in]  The new, callable function pointer for initiating an RPC from the caller's box
    38. 

  38.  * @param fn_name[in]  The function that will run in the callee's box as an RPC target
    39. 

  39.  * @param fn_ret[in]   The return type of the function being designated as an
    40. 

  40.  *                     RPC target
    41. 

  41.  * @param __VA_ARGS__  The type of each parameter passed to the target
    42. 

  42.  *                     function. There can be up to 4 parameters in a target
    43. 

  43.  *                     function. Each parameter must be no more than uint32_t
    44. 

  44.  *                     in size. If the RPC target function accepts no
    45. 

  45.  *                     arguments, pass `void` here.
    46. 

  46.  */
    47. 

  47. #define UVISOR_BOX_RPC_GATEWAY_SYNC(box_name, gw_name, fn_name, fn_ret, ...) \
    48. 

  48.     UVISOR_STATIC_ASSERT(sizeof(fn_ret) <= sizeof(uint32_t), gw_name ## _return_type_too_big); \
    49. 

  49.     _UVISOR_BOX_RPC_GATEWAY_ARG_CHECK(gw_name, __VA_ARGS__) \
    50. 

  50.     _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_DECL(fn_name, gw_name ## _rpc_gateway, __VA_ARGS__) \
    51. 

  51.     /* Instanstiate the gateway. This gets resolved at link-time. */ \
    52. 

  52.     UVISOR_EXTERN TRPCGateway const gw_name ## _rpc_gateway = { \
    53. 

  53.         .ldr_pc   = LDR_PC_PC_IMM_OPCODE(__UVISOR_OFFSETOF(TRPCGateway, ldr_pc), \
    54. 

  54.                                          __UVISOR_OFFSETOF(TRPCGateway, caller)), \
    55. 

  55.         .magic    = UVISOR_RPC_GATEWAY_MAGIC_SYNC, \
    56. 

  56.         .box_ptr  = (uint32_t) &box_name ## _cfg_ptr, \
    57. 

  57.         .target = (uint32_t) fn_name, \
    58. 

  58.         .caller = (uint32_t) _sgw_sync_ ## fn_name, \
    59. 

  59.     }; \
    60. 

  60.     _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER(fn_name, gw_name ## _rpc_gateway, __VA_ARGS__) \
    61. 

  61.     \
    62. 

  62.     /* Pointer to the gateway we just created. The pointer is located in a
    63. 

  63.      * discoverable linker section. */ \
    64. 

  64.     __attribute__((section(".keep.uvisor.rpc_gateway_ptr"))) \
    65. 

  65.     uint32_t const gw_name ## _rpc_gateway_ptr = (uint32_t) &gw_name ## _rpc_gateway; \
    66. 

  66.     \
    67. 

  67.     /* Declare the actual gateway. */ \
    68. 

  68.     UVISOR_EXTERN_C_BEGIN \
    69. 

  69.         fn_ret (*gw_name)(__VA_ARGS__) __attribute__((section(".rodata"))) = (fn_ret (*)(__VA_ARGS__)) ((uint32_t) &gw_name ## _rpc_gateway + 1); \
    70. 

  70.     UVISOR_EXTERN_C_END
    71. 

  71. 

  72. /** Asynchronous RPC Gateway
    73. 

  73.  *
    74. 

  74.  * This macro declares a new function pointer (with no name mangling) named
    75. 

  75.  * `gw_name` to perform a remote procedure call (RPC) to the target function
    76. 

  76.  * given by `fn_name`. RPCs are assembled into a read-only flash structure that
    77. 

  77.  * is read and validated by uVisor before performing the operation.
    78. 

  78.  *
    79. 

  79.  * Create function with following signature:
    80. 

  80.  * UVISOR_EXTERN uvisor_rpc_result_t gw_name(uint32_t a, uint32_t b);
    81. 

  81.  *
    82. 

  82.  * @param box_name[in] The name of the source box as declared in
    83. 

  83.  *                     `UVISOR_BOX_CONFIG`
    84. 

  84.  * @param gw_name[in]  The new, callable function pointer for initiating an RPC from the caller's box
    85. 

  85.  * @param fn_name[in]  The function that will run in the callee's box as an RPC target
    86. 

  86.  * @param fn_ret[in]   The return type of the function being designated as an
    87. 

  87.  *                     RPC target
    88. 

  88.  * @param __VA_ARGS__  The type of each parameter passed to the target
    89. 

  89.  *                     function. There can be up to 4 parameters in a target
    90. 

  90.  *                     function. Each parameter must be no more than uint32_t
    91. 

  91.  *                     in size. If the RPC target function accepts no
    92. 

  92.  *                     arguments, pass `void` here.
    93. 

  93.  */
    94. 

  94. #define UVISOR_BOX_RPC_GATEWAY_ASYNC(box_name, gw_name, fn_name, fn_ret, ...) \
    95. 

  95.     UVISOR_STATIC_ASSERT(sizeof(fn_ret) <= sizeof(uint32_t), gw_name ## _return_type_too_big); \
    96. 

  96.     _UVISOR_BOX_RPC_GATEWAY_ARG_CHECK(gw_name, __VA_ARGS__) \
    97. 

  97.     _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_DECL(fn_name, gw_name ## _rpc_gateway, __VA_ARGS__) \
    98. 

  98.     /* Instanstiate the gateway. This gets resolved at link-time. */ \
    99. 

  99.     UVISOR_EXTERN TRPCGateway const gw_name ## _rpc_gateway = { \
    100. 

  100.         .ldr_pc   = LDR_PC_PC_IMM_OPCODE(__UVISOR_OFFSETOF(TRPCGateway, ldr_pc), \
    101. 

  101.                                          __UVISOR_OFFSETOF(TRPCGateway, caller)), \
    102. 

  102.         .magic    = UVISOR_RPC_GATEWAY_MAGIC_ASYNC, \
    103. 

  103.         .box_ptr  = (uint32_t) &box_name ## _cfg_ptr, \
    104. 

  104.         .target = (uint32_t) fn_name, \
    105. 

  105.         .caller = (uint32_t) _sgw_async_ ## fn_name, \
    106. 

  106.     }; \
    107. 

  107.     _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER(fn_name, gw_name ## _rpc_gateway, __VA_ARGS__) \
    108. 

  108.     \
    109. 

  109.     /* Pointer to the gateway we just created. The pointer is located in a
    110. 

  110.      * discoverable linker section. */ \
    111. 

  111.     __attribute__((section(".keep.uvisor.rpc_gateway_ptr"))) \
    112. 

  112.     uint32_t const gw_name ## _rpc_gateway_ptr = (uint32_t) &gw_name ## _rpc_gateway; \
    113. 

  113.     \
    114. 

  114.     /* Declare the actual gateway. */ \
    115. 

  115.     UVISOR_EXTERN_C_BEGIN \
    116. 

  116.         uvisor_rpc_result_t (*gw_name)(__VA_ARGS__) __attribute__((section(".rodata"))) = (uvisor_rpc_result_t (*)(__VA_ARGS__)) ((uint32_t) &gw_name ## _rpc_gateway + 1); \
    117. 

  117.     UVISOR_EXTERN_C_END
    118. 

  118. 

  119. #define _UVISOR_BOX_RPC_GATEWAY_ARG_CHECK(gw_name, ...) \
    120. 

  120.     __UVISOR_BOX_MACRO(__VA_ARGS__, _UVISOR_BOX_RPC_GATEWAY_ARG_CHECK_4, \
    121. 

  121.                                     _UVISOR_BOX_RPC_GATEWAY_ARG_CHECK_3, \
    122. 

  122.                                     _UVISOR_BOX_RPC_GATEWAY_ARG_CHECK_2, \
    123. 

  123.                                     _UVISOR_BOX_RPC_GATEWAY_ARG_CHECK_1, \
    124. 

  124.                                     _UVISOR_BOX_RPC_GATEWAY_ARG_CHECK_0)(gw_name, __VA_ARGS__)
    125. 

  125. 

  126. #define _UVISOR_BOX_RPC_GATEWAY_ARG_CHECK_0(gw_name)
    127. 

  127. 

  128. #define _UVISOR_BOX_RPC_GATEWAY_ARG_CHECK_1(gw_name, p0_type) \
    129. 

  129.     UVISOR_STATIC_ASSERT(sizeof(p0_type) <= sizeof(uint32_t), gw_name ## _param_0_too_big);
    130. 

  130. 

  131. #define _UVISOR_BOX_RPC_GATEWAY_ARG_CHECK_2(gw_name, p0_type, p1_type) \
    132. 

  132.     UVISOR_STATIC_ASSERT(sizeof(p0_type) <= sizeof(uint32_t), gw_name ## _param_0_too_big); \
    133. 

  133.     UVISOR_STATIC_ASSERT(sizeof(p1_type) <= sizeof(uint32_t), gw_name ## _param_1_too_big);
    134. 

  134. 

  135. #define _UVISOR_BOX_RPC_GATEWAY_ARG_CHECK_3(gw_name, p0_type, p1_type, p2_type) \
    136. 

  136.     UVISOR_STATIC_ASSERT(sizeof(p0_type) <= sizeof(uint32_t), gw_name ## _param_0_too_big); \
    137. 

  137.     UVISOR_STATIC_ASSERT(sizeof(p1_type) <= sizeof(uint32_t), gw_name ## _param_1_too_big); \
    138. 

  138.     UVISOR_STATIC_ASSERT(sizeof(p2_type) <= sizeof(uint32_t), gw_name ## _param_2_too_big);
    139. 

  139. 

  140. #define _UVISOR_BOX_RPC_GATEWAY_ARG_CHECK_4(gw_name, p0_type, p1_type, p2_type, p3_type) \
    141. 

  141.     UVISOR_STATIC_ASSERT(sizeof(p0_type) <= sizeof(uint32_t), gw_name ## _param_0_too_big); \
    142. 

  142.     UVISOR_STATIC_ASSERT(sizeof(p1_type) <= sizeof(uint32_t), gw_name ## _param_1_too_big); \
    143. 

  143.     UVISOR_STATIC_ASSERT(sizeof(p2_type) <= sizeof(uint32_t), gw_name ## _param_2_too_big); \
    144. 

  144.     UVISOR_STATIC_ASSERT(sizeof(p3_type) <= sizeof(uint32_t), gw_name ## _param_3_too_big);
    145. 

  145. 

  146. #define _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_DECL(fn_name, gateway, ...) \
    147. 

  147.     __UVISOR_BOX_MACRO(__VA_ARGS__, _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_4_DECL, \
    148. 

  148.                                     _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_3_DECL, \
    149. 

  149.                                     _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_2_DECL, \
    150. 

  150.                                     _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_1_DECL, \
    151. 

  151.                                     _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_0_DECL)(fn_name, gateway, __VA_ARGS__)
    152. 

  152. 

  153. #define _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER(fn_name, gateway, ...) \
    154. 

  154.     __UVISOR_BOX_MACRO(__VA_ARGS__, _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_4, \
    155. 

  155.                                     _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_3, \
    156. 

  156.                                     _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_2, \
    157. 

  157.                                     _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_1, \
    158. 

  158.                                     _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_0)(fn_name, gateway, __VA_ARGS__)
    159. 

  159. 

  160. #define _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_0_DECL(fn_name, gateway, ...) \
    161. 

  161.     static uint32_t _sgw_sync_ ## fn_name(void);
    162. 

  162. 

  163. #define _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_0(fn_name, gateway, ...) \
    164. 

  164.     static uint32_t _sgw_sync_ ## fn_name(void) \
    165. 

  165.     { \
    166. 

  166.         return rpc_fncall_sync(0, 0, 0, 0, &gateway); \
    167. 

  167.     }
    168. 

  168. 

  169. #define _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_1_DECL(fn_name, gateway, ...) \
    170. 

  170.     static uint32_t _sgw_sync_ ## fn_name(uint32_t p0);
    171. 

  171. 

  172. #define _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_1(fn_name, gateway, ...) \
    173. 

  173.     static uint32_t _sgw_sync_ ## fn_name(uint32_t p0) \
    174. 

  174.     { \
    175. 

  175.         return rpc_fncall_sync(p0, 0, 0, 0, &gateway); \
    176. 

  176.     }
    177. 

  177. 

  178. #define _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_2_DECL(fn_name, gateway, ...) \
    179. 

  179.     static uint32_t _sgw_sync_ ## fn_name(uint32_t p0, uint32_t p1);
    180. 

  180. 

  181. #define _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_2(fn_name, gateway, ...) \
    182. 

  182.     static uint32_t _sgw_sync_ ## fn_name(uint32_t p0, uint32_t p1) \
    183. 

  183.     { \
    184. 

  184.         return rpc_fncall_sync(p0, p1, 0, 0, &gateway); \
    185. 

  185.     }
    186. 

  186. 

  187. #define _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_3_DECL(fn_name, gateway, ...) \
    188. 

  188.     static uint32_t _sgw_sync_ ## fn_name(uint32_t p0, uint32_t p1, uint32_t p2);
    189. 

  189. 

  190. #define _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_3(fn_name, gateway, ...) \
    191. 

  191.     static uint32_t _sgw_sync_ ## fn_name(uint32_t p0, uint32_t p1, uint32_t p2) \
    192. 

  192.     { \
    193. 

  193.         return rpc_fncall_sync(p0, p1, p2, 0, &gateway); \
    194. 

  194.     }
    195. 

  195. 

  196. #define _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_4_DECL(fn_name, gateway, ...) \
    197. 

  197.     static uint32_t _sgw_sync_ ## fn_name(uint32_t p0, uint32_t p1, uint32_t p2, uint32_t p3);
    198. 

  198. 

  199. #define _UVISOR_BOX_RPC_GATEWAY_SYNC_CALLER_4(fn_name, gateway, ...) \
    200. 

  200.     static uint32_t _sgw_sync_ ## fn_name(uint32_t p0, uint32_t p1, uint32_t p2, uint32_t p3) \
    201. 

  201.     { \
    202. 

  202.         return rpc_fncall_sync(p0, p1, p2, p3, &gateway); \
    203. 

  203.     }
    204. 

  204. 

  205. #define _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_DECL(fn_name, gateway, ...) \
    206. 

  206.     __UVISOR_BOX_MACRO(__VA_ARGS__, _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_4_DECL, \
    207. 

  207.                                     _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_3_DECL, \
    208. 

  208.                                     _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_2_DECL, \
    209. 

  209.                                     _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_1_DECL, \
    210. 

  210.                                     _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_0_DECL)(fn_name, gateway, __VA_ARGS__)
    211. 

  211. 

  212. #define _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER(fn_name, gateway, ...) \
    213. 

  213.     __UVISOR_BOX_MACRO(__VA_ARGS__, _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_4, \
    214. 

  214.                                     _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_3, \
    215. 

  215.                                     _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_2, \
    216. 

  216.                                     _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_1, \
    217. 

  217.                                     _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_0)(fn_name, gateway, __VA_ARGS__)
    218. 

  218. 

  219. #define _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_0_DECL(fn_name, gateway, ...) \
    220. 

  220.     static uvisor_rpc_result_t _sgw_async_ ## fn_name(void);
    221. 

  221. 

  222. #define _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_0(fn_name, gateway, ...) \
    223. 

  223.     static uvisor_rpc_result_t _sgw_async_ ## fn_name(void) \
    224. 

  224.     { \
    225. 

  225.         return rpc_fncall_async(0, 0, 0, 0, &gateway); \
    226. 

  226.     }
    227. 

  227. 

  228. #define _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_1_DECL(fn_name, gateway, ...) \
    229. 

  229.     static uvisor_rpc_result_t _sgw_async_ ## fn_name(uint32_t p0);
    230. 

  230. 

  231. #define _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_1(fn_name, gateway, ...) \
    232. 

  232.     static uvisor_rpc_result_t _sgw_async_ ## fn_name(uint32_t p0) \
    233. 

  233.     { \
    234. 

  234.         return rpc_fncall_async(p0, 0, 0, 0, &gateway); \
    235. 

  235.     }
    236. 

  236. 

  237. #define _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_2_DECL(fn_name, gateway, ...) \
    238. 

  238.     static uvisor_rpc_result_t _sgw_async_ ## fn_name(uint32_t p0, uint32_t p1);
    239. 

  239. 

  240. #define _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_2(fn_name, gateway, ...) \
    241. 

  241.     static uvisor_rpc_result_t _sgw_async_ ## fn_name(uint32_t p0, uint32_t p1) \
    242. 

  242.     { \
    243. 

  243.         return rpc_fncall_async(p0, p1, 0, 0, &gateway); \
    244. 

  244.     }
    245. 

  245. 

  246. #define _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_3_DECL(fn_name, gateway, ...) \
    247. 

  247.     static uvisor_rpc_result_t _sgw_async_ ## fn_name(uint32_t p0, uint32_t p1, uint32_t p2);
    248. 

  248. 

  249. #define _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_3(fn_name, gateway, ...) \
    250. 

  250.     static uvisor_rpc_result_t _sgw_async_ ## fn_name(uint32_t p0, uint32_t p1, uint32_t p2) \
    251. 

  251.     { \
    252. 

  252.         return rpc_fncall_async(p0, p1, p2, 0, &gateway); \
    253. 

  253.     }
    254. 

  254. 

  255. #define _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_4_DECL(fn_name, gateway, ...) \
    256. 

  256.     static uvisor_rpc_result_t _sgw_async_ ## fn_name(uint32_t p0, uint32_t p1, uint32_t p2, uint32_t p3);
    257. 

  257. 

  258. #define _UVISOR_BOX_RPC_GATEWAY_ASYNC_CALLER_4(fn_name, gateway, ...) \
    259. 

  259.     static uvisor_rpc_result_t _sgw_async_ ## fn_name(uint32_t p0, uint32_t p1, uint32_t p2, uint32_t p3) \
    260. 

  260.     { \
    261. 

  261.         return rpc_fncall_async(p0, p1, p2, p3, &gateway); \
    262. 

  262.     }
    263. 

  263. 

  264. /* This function is private to uvisor-lib, but needs to be publicly visible for
    265. 

  265.  * the RPC gateway creation macros to work. */
    266. 

  266. UVISOR_EXTERN uint32_t rpc_fncall_sync(uint32_t p0, uint32_t p1, uint32_t p2, uint32_t p3, const TRPCGateway * gateway);
    267. 

  267. 

  268. /* This function is private to uvisor-lib, but needs to be publicly visible for
    269. 

  269.  * the RPC gateway creation macros to work. */
    270. 

  270. UVISOR_EXTERN uvisor_rpc_result_t rpc_fncall_async(uint32_t p0, uint32_t p1, uint32_t p2, uint32_t p3, const TRPCGateway * gateway);
    271. 

  271. 

  272. #endif /* __UVISOR_API_RPC_GATEWAY_H__ */
    273.