MmRpc: Add Input Paramter Checking to APIs
[ipc/ipcdev.git] / packages / ti / ipc / mm / MmRpc.c
1 /*
2  * Copyright (c) 2012-2015, Texas Instruments Incorporated
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * *  Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  *
12  * *  Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * *  Neither the name of Texas Instruments Incorporated nor the names of
17  *    its contributors may be used to endorse or promote products derived
18  *    from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
33 /*
34  *  ======== MmRpc.c ========
35  */
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #include <sys/ioctl.h>
42 #include <fcntl.h>
43 #include <unistd.h>
44 #include <string.h>
46 #include <stdint.h> /* should be in linux/rpmsg_rpc.h */
47 #include <stddef.h> /* should be in linux/rpmsg_rpc.h */
51 #if defined(KERNEL_INSTALL_DIR)
53 #ifdef linux
54 #define _linux_ linux
55 #undef linux
56 #endif
58 #define linux_version_include(kd) <kd/include/generated/uapi/linux/version.h>
59 #include linux_version_include(KERNEL_INSTALL_DIR)
61 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0)
62 #define linux_include(kd,m) <kd/include/linux/m.h>
63 #else
64 #define linux_include(kd,m) <kd/include/uapi/linux/m.h>
65 #endif
67 #include linux_include(KERNEL_INSTALL_DIR,rpmsg_rpc)
69 #ifdef _linux_
70 #define linux _linux
71 #undef _linux_
72 #endif
74 #elif defined(IPC_BUILDOS_QNX)
76 #include <ti/ipc/rpmsg_rpc.h>
78 #elif defined(IPC_BUILDOS_ANDROID)
79 #include <uapi/linux/rpmsg_rpc.h>
81 #else
82 #error Unsupported Operating System
83 #endif
85 #include "MmRpc.h"
87 #if defined(KERNEL_INSTALL_DIR) || defined(IPC_BUILDOS_ANDROID)
88 static int MmRpc_bufHandle(MmRpc_Handle handle, int cmd, int num,
89         MmRpc_BufDesc *desc);
90 #endif
93 /*
94  *  ======== MmRpc_Object ========
95  */
96 typedef struct {
97     int                         fd;         /* device file descriptor */
98     struct rppc_create_instance connect;    /* connection object */
99 } MmRpc_Object;
101 /*
102  *  ======== MmRpc_Params_init ========
103  */
104 void MmRpc_Params_init(MmRpc_Params *params)
106     params->reserved = 0;
109 /*
110  *  ======== MmRpc_create ========
111  */
112 int MmRpc_create(const char *service, const MmRpc_Params *params,
113         MmRpc_Handle *handlePtr)
115     int             status = MmRpc_S_SUCCESS;
116     MmRpc_Object *  obj;
117     char            cbuf[RPPC_MAX_INST_NAMELEN+16];
119     if (service == NULL || handlePtr == NULL) {
120         status = MmRpc_E_INVALIDPARAM;
121         goto leave;
122     }
124     /* allocate the instance object */
125     obj = (MmRpc_Object *)calloc(1, sizeof(MmRpc_Object));
127     if (obj == NULL) {
128         status = MmRpc_E_FAIL;
129         goto leave;
130     }
132     /* open the driver */
133     sprintf(cbuf, "/dev/%s", service);
134     obj->fd = open(cbuf, O_RDWR);
136     if (obj->fd < 0) {
137         printf("MmRpc_create: Error: open failed, name=%s\n", cbuf);
138         status = MmRpc_E_FAIL;
139         goto leave;
140     }
142     strncpy(obj->connect.name, service, (RPPC_MAX_INST_NAMELEN - 1));
143     obj->connect.name[RPPC_MAX_INST_NAMELEN - 1] = '\0';
145     /* create a server instance, rebind its address to this file descriptor */
146     status = ioctl(obj->fd, RPPC_IOC_CREATE, &obj->connect);
148     if (status < 0) {
149         printf("MmRpc_create: Error: connect failed\n");
150         status = MmRpc_E_FAIL;
151         goto leave;
152     }
154 leave:
155     if (status < 0) {
156         if ((obj != NULL) && (obj->fd >= 0)) {
157             close(obj->fd);
158         }
159         if (obj != NULL) {
160             free(obj);
161         }
162         if (handlePtr) {
163             *handlePtr = NULL;
164         }
165     }
166     else {
167         *handlePtr = (MmRpc_Handle)obj;
168     }
170     return(status);
173 /*
174  *  ======== MmRpc_delete ========
175  */
176 int MmRpc_delete(MmRpc_Handle *handlePtr)
178     int status = MmRpc_S_SUCCESS;
179     MmRpc_Object *obj;
181     if (handlePtr == NULL) {
182         return MmRpc_E_INVALIDPARAM;
183     }
185     obj = (MmRpc_Object *)(*handlePtr);
187     /* close the device */
188     if ((obj != NULL) && (obj->fd >= 0)) {
189         close(obj->fd);
190     }
192     /* free the instance object */
193     free((void *)(*handlePtr));
194     *handlePtr = NULL;
196     return(status);
199 /*
200  *  ======== MmRpc_call ========
201  */
202 int MmRpc_call(MmRpc_Handle handle, MmRpc_FxnCtx *ctx, int32_t *ret)
204     int status = MmRpc_S_SUCCESS;
205     MmRpc_Object *obj = (MmRpc_Object *)handle;
206     struct rppc_function *rpfxn;
207     struct rppc_function_return reply_msg;
208     MmRpc_Param *param;
209     void *msg;
210     int len;
211     int i;
213     if (handle == NULL || ctx == NULL || ret == NULL) {
214         status = MmRpc_E_INVALIDPARAM;
215         goto leave;
216     }
218     /* combine params and translation array into one contiguous message */
219     len = sizeof(struct rppc_function) +
220                 (ctx->num_xlts * sizeof(struct rppc_param_translation));
221     msg = (void *)calloc(len, sizeof(char));
223     if (msg == NULL) {
224         printf("MmRpc_call: Error: msg alloc failed\n");
225         status = MmRpc_E_FAIL;
226         goto leave;
227     }
229     /* copy function parameters into message */
230     rpfxn = (struct rppc_function *)msg;
231     rpfxn->fxn_id = ctx->fxn_id;
232     rpfxn->num_params = ctx->num_params;
234     for (i = 0; i < ctx->num_params; i++) {
235         param = &ctx->params[i];
237         switch (param->type) {
238             case MmRpc_ParamType_Scalar:
239                 rpfxn->params[i].type = RPPC_PARAM_TYPE_ATOMIC;
240                 rpfxn->params[i].size = param->param.scalar.size;
241                 rpfxn->params[i].data = param->param.scalar.data;
242                 rpfxn->params[i].base = 0;
243                 rpfxn->params[i].fd = 0;
244                 break;
246             case MmRpc_ParamType_Ptr:
247                 rpfxn->params[i].type = RPPC_PARAM_TYPE_PTR;
248                 rpfxn->params[i].size = param->param.ptr.size;
249                 rpfxn->params[i].data = param->param.ptr.addr;
250                 rpfxn->params[i].base = param->param.ptr.addr;
251                 rpfxn->params[i].fd = param->param.ptr.handle;
252                 break;
254             case MmRpc_ParamType_OffPtr:
255                 rpfxn->params[i].type = RPPC_PARAM_TYPE_PTR;
256                 rpfxn->params[i].size = param->param.offPtr.size;
257                 rpfxn->params[i].data = param->param.offPtr.base +
258                         param->param.offPtr.offset;
259                 rpfxn->params[i].base = param->param.offPtr.base;
260                 rpfxn->params[i].fd = param->param.offPtr.handle;
261                 break;
263             default:
264                 printf("MmRpc_call: Error: invalid parameter type\n");
265                 status = MmRpc_E_INVALIDPARAM;
266                 goto leave;
267                 break;
268         }
269     }
271     /* copy offset array into message */
272     rpfxn->num_translations = ctx->num_xlts;
274     for (i = 0; i < ctx->num_xlts; i++) {
275         /* pack the pointer translation entry */
276         rpfxn->translations[i].index = ctx->xltAry[i].index;
277         rpfxn->translations[i].offset = ctx->xltAry[i].offset;
278         rpfxn->translations[i].base = ctx->xltAry[i].base;
279         rpfxn->translations[i].fd = (int32_t)ctx->xltAry[i].handle;
280     }
282     /* send message for remote execution */
283     status = write(obj->fd, msg, len);
285     if (status < 0) {
286         printf("MmRpc_call: Error: write failed\n");
287         status = MmRpc_E_FAIL;
288         goto leave;
289     }
291     /* wait for return status from remote service */
292     status = read(obj->fd, &reply_msg, sizeof(struct rppc_function_return));
294     if (status < 0) {
295         printf("MmRpc_call: Error: read failed\n");
296         status = MmRpc_E_FAIL;
297         goto leave;
298     }
299     else if (status != sizeof(struct rppc_function_return)) {
300         printf("MmRpc_call: Error: reply bytes=%d, expected %d\n",
301                 status, sizeof(struct rppc_function_return));
302         status = MmRpc_E_FAIL;
303         goto leave;
304     }
305     else {
306         status = MmRpc_S_SUCCESS;
307     }
309     *ret = (int32_t)reply_msg.status;
311 leave:
312     if (msg != NULL) {
313         free(msg);
314     }
316     return(status);
319 /*
320  *  ======== MmRcp_release ========
321  */
322 int MmRpc_release(MmRpc_Handle handle, MmRpc_BufType type, int num,
323         MmRpc_BufDesc *desc)
325     int stat = MmRpc_S_SUCCESS;
327     switch (type) {
329 #if defined(KERNEL_INSTALL_DIR) || defined(IPC_BUILDOS_ANDROID)
330         case MmRpc_BufType_Handle:
331             stat = MmRpc_bufHandle(handle, RPPC_IOC_BUFUNREGISTER, num, desc);
332             break;
334 #elif defined(IPC_BUILDOS_QNX)
335         case MmRpc_BufType_Ptr:
336             break;
337 #endif
338         default:
339             printf("MmRpc_release: Error: unsupported type value: %d\n", type);
340             stat = MmRpc_E_INVALIDPARAM;
341             break;
342     }
344     if (stat < 0) {
345         printf("MmRpc_release: Error: unable to release buffer\n");
346     }
348     return(stat);
351 /*
352  *  ======== MmRcp_use ========
353  */
354 int MmRpc_use(MmRpc_Handle handle, MmRpc_BufType type, int num,
355         MmRpc_BufDesc *desc)
357     int stat = MmRpc_S_SUCCESS;
359     switch (type) {
361 #if defined(KERNEL_INSTALL_DIR) || defined(IPC_BUILDOS_ANDROID)
362         case MmRpc_BufType_Handle:
363             stat = MmRpc_bufHandle(handle, RPPC_IOC_BUFREGISTER, num, desc);
364             break;
366 #elif defined(IPC_BUILDOS_QNX)
367         case MmRpc_BufType_Ptr:
368             break;
369 #endif
370         default:
371             printf("MmRpc_use: Error: unsupported type value: %d\n", type);
372             stat = MmRpc_E_INVALIDPARAM;
373             break;
374     }
376     if (stat < 0) {
377         printf("MmRpc_use: Error: unable to declare buffer use\n");
378     }
380     return(stat);
383 #if defined(KERNEL_INSTALL_DIR) || defined(IPC_BUILDOS_ANDROID)
384 /*
385  *  ======== MmRpc_bufHandle ========
386  */
387 int MmRpc_bufHandle(MmRpc_Handle handle, int cmd, int num, MmRpc_BufDesc *desc)
389     int stat = MmRpc_S_SUCCESS;
390     MmRpc_Object *obj = (MmRpc_Object *)handle;
391     int i;
392     struct rppc_buf_fds reg = { num, NULL };
394     if (handle == NULL || desc == NULL) {
395         stat = MmRpc_E_INVALIDPARAM;
396         goto leave;
397     }
399     reg.fds = (int32_t *)malloc(num * sizeof(int32_t));
401     if (reg.fds == NULL) {
402         stat = MmRpc_E_NOMEM;
403         goto leave;
404     }
406     for (i = 0; i < num; i++) {
407         reg.fds[i] = desc[i].handle;
408     }
410     stat = ioctl(obj->fd, cmd, &reg);
412     if (stat < 0) {
413         stat = MmRpc_E_SYS;
414     }
416 leave:
417     if (reg.fds != NULL) {
418         free(reg.fds);
419     }
421     return(stat);
423 #endif