1 #include "MsTypes.h"
2 #include "utopia_private.h"
3 #include "MsOS.h"
4
5 #ifdef MSOS_TYPE_LINUX_KERNEL
6 #include <linux/string.h>
7 #include <linux/slab.h>
8 #include <linux/mutex.h>
9 #include <linux/syscalls.h> // for syscall
10 #else
11 #include <stdio.h>
12 #include <unistd.h> /* for usleep */
13 #include <string.h>
14 #include <stdlib.h>
15 #include <sys/ioctl.h>
16 #include <fcntl.h>
17 #endif
18 #include "drvIPAUTH.h"
19
20 #include "utopia.h"
21 #include "utopia_dapi.h"
22 #include <errno.h>
23 #include "mdrv_semutex_io.h"
24
25 #if defined(MSOS_TYPE_LINUX_KERNEL) || defined(ANDROID) || defined(TV_OS)
26 #include <linux/sem.h>
27 #else
28 #include <sys/sem.h>
29 #endif
30
31 #define DEADLOCK_DEBUG 0
32
33 #if DEADLOCK_DEBUG == 1
34 #include <execinfo.h>
35 #endif
36
37 #if defined(CONFIG_UTOPIA_FRAMEWORK_DISABLE_SYSTEM_V_IPCS) && defined(TV_OS)
38 #define DISABLE_SYSCALL 1
39 #endif
40
41 MS_U32 bt_threshold = 30000; /* 30 sec */
42 MS_U32 bt_period = 3000; /* 3 sec */
43
44 // length should be the same to definition
45 extern char moduleNames[][40];
46 extern char rpoolNames[][40];
47 extern char ResourceNames[][40];
48 extern unsigned int moduleMode[];
49
50
51 #if defined(MSOS_TYPE_LINUX_KERNEL) || defined(ANDROID) || defined(TV_OS)
52 # if defined(CONFIG_ARM_CA7) || defined(CONFIG_ARM_CA9) || \
53 defined(CONFIG_ARM_CA12) || defined(MCU_ARM_9) || defined(MCU_ARM_CA12) || defined(CONFIG_ARM_CA53)
54
55
56
57 #if defined (__aarch64__)
58 #define SYS_semop 193
59 #define SYS_semget 190
60 #define SYS_semctl 191
61 #else
62 #define SYS_semop 298
63 #define SYS_semget 299
64 #define SYS_semctl 300
65 #endif
66
67 long int syscall (long int __sysno, ...);
68
semop(int __semid,struct sembuf * __sops,size_t __nsops)69 int semop (int __semid, struct sembuf *__sops, size_t __nsops)
70 {
71 return syscall(SYS_semop, __semid, __sops, __nsops);
72 }
73
semget(key_t __key,int __nsems,int __semflg)74 int semget (key_t __key, int __nsems, int __semflg)
75 {
76 return syscall(SYS_semget, __key, __nsems, __semflg);
77 }
78
semctl(int __semid,int __semnum,int __cmd,int __counter)79 int semctl (int __semid, int __semnum, int __cmd, int __counter)
80 {
81 return syscall(SYS_semctl, __semid, __semnum, __cmd, __counter);
82 }
83 # else
84 int semop (int __semid, struct sembuf *__sops, size_t __nsops);
85 int semget (key_t __key, int __nsems, int __semflg);
86 int semctl (int __semid, int __semnum, int __cmd, int __counter);
87 # endif
88 #endif
89
90 UTOPIA_SHM_ID* utopiaShmIdArray[50]; // FIXME: enum
91 MS_U32 utopiaShmIdIndex = 0;
92
93 struct shm_info {
94 void* va;
95 char name[40]; // FIXME: array length should be unify
96 };
97
98 /*
99 * could be equal to MAX_SHM_CLIENT_NUM=320 defined in MsOS_linux.c
100 * cause we ues shm id as table index, there may be holes in the table
101 */
102 #define SHM_INFO_TABLE_LENGTH 300
103 struct shm_info shm_info_table[SHM_INFO_TABLE_LENGTH] = {{NULL, ""}};
104
105 extern UTOPIA_PRIVATE* psUtopiaPrivate;
106
107 enum eObjectType
108 {
109 E_TYPE_INSTANCE,
110 E_TYPE_MODULE,
111 E_TYPE_MODULE_SHM,
112 E_TYPE_RESOURCE_POOL,
113 E_TYPE_RESOURCE,
114 };
115
116 #if !defined(DISABLE_SYSCALL)
117 /* 1st field: the n-th semaphore in set */
118 /* 2nd field: up/down operation */
119 /* 3rd field: ??? */
120 struct sembuf op_down[1] = {{0, -1, 0}};
obtain_sem(MS_U32 u32SemID)121 static inline MS_U32 obtain_sem(MS_U32 u32SemID)
122 {
123 return semop(u32SemID, &op_down[0], 1);
124 }
125
126 struct sembuf op_up[1] = {{0, 1, 0}};
release_sem(MS_U32 u32SemID)127 static inline MS_U32 release_sem(MS_U32 u32SemID)
128 {
129 return semop(u32SemID, &op_up[0], 1);
130 }
131 #endif
132
shmid2va(MS_U32 u32ShmID)133 static inline void* shmid2va(MS_U32 u32ShmID)
134 {
135 if (u32ShmID == 0xFFFFFFFF)
136 return NULL;
137 return shm_info_table[u32ShmID].va;
138 }
139
140 #if 0 //coverity (PW.DECLARED_BUT_NOT_REFERENCED) cannot code suppression
141 static inline MS_U32 isFirstCreation(void* pUnknown, enum eObjectType eObjectType)
142 {
143 switch(eObjectType)
144 {
145 case E_TYPE_MODULE_SHM:
146 return TO_MODULE_SHM_PTR(pUnknown)->shmid_self.ID == 0;
147 case E_TYPE_RESOURCE:
148 return TO_RESOURCE_PTR(pUnknown)->shmid_self.ID == 0;
149 case E_TYPE_RESOURCE_POOL:
150 return TO_RPOOL_PTR(pUnknown)->shmid_self.ID == 0;
151 default:
152 printu("[utopia param error] type is not supported in %s\n",
153 __FUNCTION__);
154 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
155 }
156 }
157 #endif
158
159 /*
160 * u32ShmSize: user specified shared memory size
161 * shmName: user specified shared memory name
162 * p32RetShmID: for returning shared memory id
163 * return: shared memory address in virtual
164 */
shm_malloc(MS_U32 u32ShmSize,char * shmName,void ** ppRetAddr,MS_U32 * pu32RetShmID)165 static MS_U32 shm_malloc(MS_U32 u32ShmSize, char* shmName,
166 void** ppRetAddr, MS_U32* pu32RetShmID)
167 {
168 MS_U32 u32RetShmID = 0, u32RetShmSize= 0;
169 MS_U32 u32QueryRet, u32CreateRet, u32StatusRet;
170 MS_VIRT vaRetAddr = 0;
171
172 /* FIXME: if shm exist, maybe query is enough to fill shm_info_table */
173 /* --> no need to create again? */
174
175 /* check param. */
176 if (MSOS_BRANCH_PREDICTION_UNLIKELY(strcmp(shmName, "") == 0)) {
177 printu("[utopia param error] shm name string should not be empty\n");
178 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
179 }
180
181 /*
182 * u32QueryRet: 0 for not found
183 * 1 for existence
184 * u32RetShmID: 0 for not found
185 * n for created share mem id, start from 1
186 */
187 u32QueryRet = MsOS_SHM_GetId((MS_U8*)shmName, u32ShmSize, &u32RetShmID
188 , &vaRetAddr, &u32RetShmSize, MSOS_SHM_QUERY);
189
190 /*
191 * MsOS_SHM_GetId need to be called for each process
192 * to set up per-process shmid2va table
193 * it's ok for duplicated calls with same shmName
194 */
195
196 /*
197 * u32CreateRet: 0 for failed creation
198 * 1 for successful creation
199 * u32RetShmID: 0 for not found
200 * n for created share mem id, start from 1
201 */
202 u32CreateRet = MsOS_SHM_GetId((MS_U8*)shmName, u32ShmSize, &u32RetShmID
203 , &vaRetAddr, &u32RetShmSize, MSOS_SHM_CREATE);
204 if (MSOS_BRANCH_PREDICTION_UNLIKELY(u32CreateRet == 0)) {
205 printu("[utopia shm error] something wrong in MsOS_SHM_GetId\n");
206 printu("is SHM_SIZE reached?\n");
207 printu("is MAX_SHM_CLIENT_NUM reached?\n");
208 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
209 }
210
211 /* check whether table limit is reached? */
212 if (MSOS_BRANCH_PREDICTION_UNLIKELY(u32RetShmID >= SHM_INFO_TABLE_LENGTH)) {
213 printu("[utopia shm error] shm id %d exceeds shm-info table length %d\n"
214 , (int)u32RetShmID, SHM_INFO_TABLE_LENGTH);
215 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
216 }
217
218 /* it has already been registered */
219 if (shm_info_table[u32RetShmID].va != NULL) {
220 printu("[utopia shm warning] \
221 register duplicated shared memory ID %d: %s@%p\n"
222 , (int)u32RetShmID, shm_info_table[u32RetShmID].name
223 , shm_info_table[u32RetShmID].va);
224 } else { /* fill the table */
225 shm_info_table[u32RetShmID].va = (void*)vaRetAddr;
226 strncpy(shm_info_table[u32RetShmID].name
227 , shmName, sizeof(shm_info_table[0].name));
228 }
229
230 /*
231 * u32QueryRet: TRUE for success, FALSE for failure
232 * if failure --> first time allocation, memset to 0
233 */
234 if (u32QueryRet != 1) {
235 memset((void*)vaRetAddr, 0, u32RetShmSize);
236 u32StatusRet = UTOPIA_STATUS_SUCCESS;
237 } else
238 u32StatusRet = UTOPIA_STATUS_SHM_EXIST;
239
240 *pu32RetShmID = u32RetShmID;
241 *ppRetAddr = (void*)vaRetAddr;
242 return u32StatusRet;
243 }
244
next_resource(void * pUnkown,enum eObjectType eObjectType)245 static UTOPIA_RESOURCE* next_resource(void* pUnkown
246 , enum eObjectType eObjectType)
247 {
248 switch(eObjectType)
249 {
250 case E_TYPE_RESOURCE_POOL:
251 return (UTOPIA_RESOURCE*)shmid2va(
252 ((UTOPIA_RESOURCE_POOL*)pUnkown)->shmid_resource_head.ID);
253 case E_TYPE_RESOURCE:
254 return (UTOPIA_RESOURCE*)shmid2va(
255 ((UTOPIA_RESOURCE*)pUnkown)->shmid_next_resource.ID);
256 default:
257 printu("[utopia error] type is not supported in %s\n", __FUNCTION__);
258 RET_OR_BLOCK(NULL);
259 }
260 }
261
262 #if DEADLOCK_DEBUG == 1
print_trace(void)263 void print_trace(void)
264 {
265 void *array[10];
266 size_t size;
267 char **strings;
268 size_t i;
269
270 size = backtrace (array, 10);
271 strings = backtrace_symbols (array, size);
272
273 printu ("Obtained %zd stack frames.\n", size);
274
275 for (i = 0; i < size; i++)
276 printu ("%s\n", strings[i]);
277
278 free (strings);
279 }
280 #endif
281
282 /* return located module address or NULL if not found */
locate_module(MS_U32 u32ModuleID)283 static void* locate_module(MS_U32 u32ModuleID)
284 {
285 UTOPIA_MODULE* pLocatedModule = psUtopiaPrivate->psModuleHead;
286
287 while (pLocatedModule != NULL && pLocatedModule->u32ModuleID != u32ModuleID)
288 pLocatedModule = pLocatedModule->psNext;
289
290 return pLocatedModule;
291 }
292
293 /*
294 * case 1: there's no resource pool --> *ppRPool = NULL & *ppRPoolPrev = NULL
295 * case 2: at least one resource pool exists, but not the located one
296 * --> *ppRPool = NULL & *ppRPoolPrev != NULL
297 * case 3: at least one resource pool exists, and so is the located one
298 * --> *ppRPool != NULL & ppRPoolPrev doesn't matter
299 */
locate_resource_pool(UTOPIA_MODULE * pModule,MS_U32 u32LocatedRPoolID,UTOPIA_RESOURCE_POOL ** ppRPool,UTOPIA_RESOURCE_POOL ** ppRPoolPrev)300 static MS_U32 locate_resource_pool(UTOPIA_MODULE* pModule, MS_U32 u32LocatedRPoolID
301 , UTOPIA_RESOURCE_POOL** ppRPool, UTOPIA_RESOURCE_POOL** ppRPoolPrev)
302 {
303 UTOPIA_RESOURCE_POOL* pRPool
304 = TO_RPOOL_PTR(shmid2va(pModule->psModuleShm->shmid_rpool_head.ID));
305 UTOPIA_RESOURCE_POOL* pRPoolPrev = NULL;
306
307 while (pRPool != NULL && pRPool->u32PoolID != u32LocatedRPoolID)
308 {
309 pRPoolPrev = pRPool;
310 pRPool = TO_RPOOL_PTR(shmid2va(pRPool->shmid_next_rpool.ID));
311 }
312
313 *ppRPool = pRPool;
314 *ppRPoolPrev = pRPoolPrev;
315 return 0;
316 }
317
locate_resource(UTOPIA_RESOURCE_POOL * pRPool,MS_U32 u32LocatedResourceID,UTOPIA_RESOURCE ** ppRes,UTOPIA_RESOURCE ** ppResPrev)318 static MS_U32 locate_resource(UTOPIA_RESOURCE_POOL* pRPool
319 , MS_U32 u32LocatedResourceID, UTOPIA_RESOURCE** ppRes
320 , UTOPIA_RESOURCE** ppResPrev)
321 {
322 UTOPIA_RESOURCE* pRes
323 = TO_RESOURCE_PTR(shmid2va(pRPool->shmid_resource_head.ID));
324 UTOPIA_RESOURCE* pResPrev = NULL;
325
326 while (pRes != NULL
327 && (pRes->shmid_self.ID != u32LocatedResourceID))
328 {
329 pResPrev = pRes;
330 pRes = TO_RESOURCE_PTR(shmid2va(pRes->shmid_next_resource.ID));
331 }
332
333 *ppRes = pRes;
334 *ppResPrev = pResPrev;
335 return 0;
336 }
337
UtopiaInstanceCreate(MS_U32 u32PrivateSize,void ** ppInstance)338 MS_U32 UtopiaInstanceCreate(MS_U32 u32PrivateSize, void** ppInstance)
339 {
340 UTOPIA_INSTANCE* pInstance = NULL;
341
342 /* check param. */
343 if (MSOS_BRANCH_PREDICTION_UNLIKELY(ppInstance == NULL))
344 {
345 printu("[utopia param error] instance ppointer should not be null\n");
346 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
347 }
348
349 pInstance = malloc(sizeof(UTOPIA_INSTANCE));
350 if(MSOS_BRANCH_PREDICTION_LIKELY(pInstance != NULL)) //Coverity
351 {
352 memset(pInstance, 0, sizeof(UTOPIA_INSTANCE));
353 pInstance->pPrivate = malloc(u32PrivateSize);
354 if(pInstance->pPrivate != NULL)
355 memset(pInstance->pPrivate, 0, u32PrivateSize);
356 else
357 printu("[utopia error] Line: %d pInstance->pPrivate == NULL\n",__LINE__);
358 *ppInstance = pInstance;
359 }
360 else
361 {
362 printu("[utopia malloc error] Line: %d pInstance == NULL\n",__LINE__);
363 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
364 }
365 return UTOPIA_STATUS_SUCCESS;
366 }
367
UtopiaInstanceDelete(void * pInstance)368 MS_U32 UtopiaInstanceDelete(void* pInstance)
369 {
370 free(TO_INSTANCE_PTR(pInstance)->pPrivate);
371 free(pInstance);
372
373 return UTOPIA_STATUS_SUCCESS;
374 }
375
UtopiaInstanceGetPrivate(void * pInstance,void ** ppPrivate)376 MS_U32 UtopiaInstanceGetPrivate(void* pInstance, void** ppPrivate)
377 {
378 /* check param. */
379 if (MSOS_BRANCH_PREDICTION_UNLIKELY(pInstance == NULL))
380 {
381 printu("[utopia param error] instance pointer should not be null\n");
382 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
383 }
384 else if (MSOS_BRANCH_PREDICTION_UNLIKELY(ppPrivate == NULL))
385 {
386 printu("[utopia param error] private ppointer should not be null\n");
387 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
388 }
389 else
390 {
391 *ppPrivate = TO_INSTANCE_PTR(pInstance)->pPrivate;
392 }
393 return UTOPIA_STATUS_SUCCESS;
394 }
395
UtopiaInstanceGetModule(void * pInstance,void ** ppModule)396 MS_U32 UtopiaInstanceGetModule(void* pInstance, void** ppModule)
397 {
398 /* check param. */
399 if (MSOS_BRANCH_PREDICTION_UNLIKELY(pInstance == NULL))
400 {
401 printu("[uopia param error] instance pointer should not be null\n");
402 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
403 }
404 else if (MSOS_BRANCH_PREDICTION_UNLIKELY(ppModule == NULL))
405 {
406 printu("[utopia param error] module ppointer should not be null\n");
407 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
408 }
409 else
410 {
411 *ppModule = TO_INSTANCE_PTR(pInstance)->psModule;
412 }
413
414 /* check module pointer */
415 if (MSOS_BRANCH_PREDICTION_UNLIKELY(*ppModule == NULL))
416 {
417 printu("[utopia param error] module pointer should not be null\n");
418 printu("forgot to call UtopiaOpen first?\n");
419 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
420 }
421
422 return UTOPIA_STATUS_SUCCESS;
423 }
424
UtopiaInstanceGetModuleID(void * pInstance,MS_U32 * pu32ModuleID)425 MS_U32 UtopiaInstanceGetModuleID(void* pInstance, MS_U32* pu32ModuleID)
426 {
427 *pu32ModuleID = TO_INSTANCE_PTR(pInstance)->psModule->u32ModuleID;
428 return UTOPIA_STATUS_SUCCESS;
429 }
430
UtopiaInstanceGetModuleVersion(void * pInstance,MS_U32 * pu32Version)431 MS_U32 UtopiaInstanceGetModuleVersion(void* pInstance, MS_U32* pu32Version)
432 {
433 *pu32Version = TO_INSTANCE_PTR(pInstance)->psModule->u32Version;
434 return UTOPIA_STATUS_SUCCESS;
435 }
436
UtopiaInstanceGetAppRequiredModuleVersion(void * pInstance,MS_U32 * pu32ModuleVersion)437 MS_U32 UtopiaInstanceGetAppRequiredModuleVersion(void* pInstance
438 , MS_U32* pu32ModuleVersion)
439 {
440 *pu32ModuleVersion = TO_INSTANCE_PTR(pInstance)->u32AppRequireModuleVersion;
441 return UTOPIA_STATUS_SUCCESS;
442 }
443
444 /*
445 * assume one module for each driver
446 * otherwise they have to pass module name as parameter
447 */
UtopiaModuleCreate(MS_U32 u32ModuleID,MS_U32 u32PrivateSize,void ** ppModule)448 MS_U32 UtopiaModuleCreate(MS_U32 u32ModuleID
449 , MS_U32 u32PrivateSize, void** ppModule)
450 {
451 MS_U32 u32ShmID, u32Status;
452 UTOPIA_MODULE_SHM* pModuleShm = NULL;
453 UTOPIA_MODULE* pModule = NULL;
454 void* pPrivate = NULL;
455 char privateName[50]; // FIXME: potential bug
456
457 /* 1. create module@shm */
458 u32Status = shm_malloc(sizeof(UTOPIA_MODULE_SHM),
459 moduleNames[u32ModuleID], (void**)&pModuleShm, &u32ShmID);
460 if (u32Status == UTOPIA_STATUS_SUCCESS)
461 {
462 pModuleShm->shmid_self.ID = u32ShmID;
463 strncpy(pModuleShm->shmid_self.name, moduleNames[u32ModuleID]
464 , sizeof(pModuleShm->shmid_self.name));
465 pModuleShm->shmid_rpool_head.ID = 0xFFFFFFFF;
466 }
467
468 /* 2. create module */
469 pModule = malloc(sizeof(UTOPIA_MODULE));
470 if(pModule != NULL) //Coverity
471 {
472 memset(pModule, 0, sizeof(UTOPIA_MODULE));
473 pModule->u32ModuleID = u32ModuleID;
474 pModule->psModuleShm = pModuleShm;
475
476 /* 3. create private of module */
477 snprintf(privateName, sizeof(privateName)
478 , "%s_PRI", moduleNames[u32ModuleID]);
479 u32Status = shm_malloc(u32PrivateSize, privateName,
480 &pPrivate, &(pModule->shmid_private.ID));
481 if((u32Status == UTOPIA_STATUS_SUCCESS)||(u32Status == UTOPIA_STATUS_SHM_EXIST)) //Coverity
482 {
483 /* 4. initial str private */
484 pModule->shmid_str.ID=0xFFFFFFFF;
485 *ppModule = pModule;
486 }
487 else
488 {
489 printu("[utopia malloc error] Line: %d shm_malloc fail\n",__LINE__);
490 u32Status = UTOPIA_STATUS_FAIL;
491 }
492 }
493 else
494 {
495 printu("[utopia malloc error] Line: %d pModule == NULL\n",__LINE__);
496 u32Status = UTOPIA_STATUS_FAIL;
497 }
498 return u32Status;
499 }
500
UtopiaModuleGetPrivate(void * pModule,void ** ppPrivate)501 MS_U32 UtopiaModuleGetPrivate(void* pModule, void** ppPrivate)
502 {
503 *ppPrivate = shmid2va(TO_MODULE_PTR(pModule)->shmid_private.ID);
504 return UTOPIA_STATUS_SUCCESS;
505 }
506
UtopiaModuleSetSTRPrivate(void * pModule,MS_U32 u32STRPrivateSize)507 MS_U32 UtopiaModuleSetSTRPrivate(void* pModule, MS_U32 u32STRPrivateSize)
508 {
509 void* pPrivate = NULL;
510 char privateName[50]; // FIXME: potential bug
511 MS_U32 shmid_str=0xFFFFFFFF;
512 MS_U32 u32Status = 0;
513
514 /* check str private exist? */
515 if (MSOS_BRANCH_PREDICTION_UNLIKELY(!pModule))
516 {
517 printu("[utopia param error] module pointer should not be null\n");
518 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
519 }
520 if (MSOS_BRANCH_PREDICTION_UNLIKELY(0xFFFFFFFF != TO_MODULE_PTR(pModule)->shmid_str.ID))
521 {
522 printu("[utopia module error] set duplicated STR private of module: %s\n"
523 , moduleNames[TO_MODULE_PTR(pModule)->u32ModuleID]);
524 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
525 }
526
527 /* create str private of module */
528 snprintf(privateName, sizeof(privateName)
529 , "%s_STR", moduleNames[TO_MODULE_PTR(pModule)->u32ModuleID]);
530 u32Status = shm_malloc(u32STRPrivateSize, privateName,
531 &pPrivate, &shmid_str);
532
533 if((u32Status != UTOPIA_STATUS_SUCCESS)&&(u32Status != UTOPIA_STATUS_SHM_EXIST)) //Coverity
534 {
535 printu("[utopia malloc error] Line: %d shm_malloc fail\n",__LINE__);
536 }
537
538 TO_MODULE_PTR(pModule)->shmid_str.ID = shmid_str;
539
540 return UTOPIA_STATUS_SUCCESS;
541 }
542
UtopiaModuleGetSTRPrivate(void * pModule,void ** ppPrivate)543 MS_U32 UtopiaModuleGetSTRPrivate(void* pModule, void** ppPrivate)
544 {
545 /* check str private exist? */
546 if (MSOS_BRANCH_PREDICTION_UNLIKELY(!pModule))
547 {
548 printu("[utopia param error] module pointer should not be null\n");
549 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
550 }
551 if (MSOS_BRANCH_PREDICTION_UNLIKELY(0xFFFFFFFF == TO_MODULE_PTR(pModule)->shmid_str.ID))
552 {
553 printu("[utopia module error] NULL STR private of module: %s\n"
554 , moduleNames[TO_MODULE_PTR(pModule)->u32ModuleID]);
555 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
556 }
557
558 *ppPrivate = shmid2va(TO_MODULE_PTR(pModule)->shmid_str.ID);
559 return UTOPIA_STATUS_SUCCESS;
560 }
561
562 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
UtopiaModuleRegisterMdbNode(char sMdbNodeName[MDB_NODE_NAME_MAX],FUtopiaMdbIoctl fpMdbIoctl)563 MS_U32 UtopiaModuleRegisterMdbNode(char sMdbNodeName[MDB_NODE_NAME_MAX], FUtopiaMdbIoctl fpMdbIoctl)
564 {
565 printu("UtopiaModuleRegisterMdbNode: %s\n", sMdbNodeName);
566 //todo
567 return UTOPIA_STATUS_SUCCESS;
568 }
569
UtopiaCreateMdbNode()570 MS_U32 UtopiaCreateMdbNode()
571 {
572 //todo
573 return UTOPIA_STATUS_SUCCESS;
574 }
575
UtopiaModuleGetLocalInstantList(MS_U32 u32ModuleID,void * pLastInstance)576 void* UtopiaModuleGetLocalInstantList(MS_U32 u32ModuleID, void* pLastInstance)
577 {
578 //todo
579 return UTOPIA_STATUS_SUCCESS;
580 }
581
MdbPrint(MS_U64 * u64ReqHdl,const char * fmt,...)582 MS_U32 MdbPrint(MS_U64* u64ReqHdl, const char* fmt, ...)
583 {
584 //todo
585 return UTOPIA_STATUS_SUCCESS;
586 }
587 #endif
588
UtopiaModuleRegister(void * pModuleTmp)589 MS_U32 UtopiaModuleRegister(void* pModuleTmp)
590 {
591 UTOPIA_MODULE* pModule = TO_MODULE_PTR(pModuleTmp);
592 UTOPIA_MODULE* pLocatedModule = NULL;
593
594 /* check para. */
595 if (MSOS_BRANCH_PREDICTION_UNLIKELY(pModule == NULL))
596 {
597 printu("[utopia param error] module pointer should not be null\n");
598 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
599 }
600
601 pLocatedModule = TO_MODULE_PTR(locate_module(pModule->u32ModuleID));
602 if (pLocatedModule == NULL) /* module is not yet registered */
603 {
604 /* insert module into list head */
605 printu("[utopia info] register module: %s\n"
606 , moduleNames[pModule->u32ModuleID]);
607 pModule->psNext = psUtopiaPrivate->psModuleHead;
608 psUtopiaPrivate->psModuleHead = pModule;
609 return UTOPIA_STATUS_SUCCESS;
610 }
611 else /* module is already registered */
612 printu("[utopia module warning] register duplicated module: %s\n"
613 , moduleNames[pModule->u32ModuleID]);
614 return UTOPIA_STATUS_SHM_EXIST;
615 }
616
UtopiaModuleSetupFunctionPtr(void * pModuleTmp,FUtopiaOpen fpOpen,FUtopiaClose fpClose,FUtopiaIOctl fpIoctl)617 MS_U32 UtopiaModuleSetupFunctionPtr(void* pModuleTmp
618 , FUtopiaOpen fpOpen, FUtopiaClose fpClose, FUtopiaIOctl fpIoctl)
619 {
620 UTOPIA_MODULE* pModule = TO_MODULE_PTR(pModuleTmp);
621
622 pModule->fpOpen = fpOpen;
623 pModule->fpClose = fpClose;
624 pModule->fpIoctl = fpIoctl;
625
626 return UTOPIA_STATUS_SUCCESS;
627 }
628
UtopiaModuleSetupSTRFunctionPtr(void * pModuleTmp,FUtopiaSTR fpSTR)629 MS_U32 UtopiaModuleSetupSTRFunctionPtr(void* pModuleTmp, FUtopiaSTR fpSTR)
630 {
631 UTOPIA_MODULE* pModule = TO_MODULE_PTR(pModuleTmp);
632
633 if (MSOS_BRANCH_PREDICTION_UNLIKELY(!pModuleTmp))
634 {
635 printu("[utopia param error] module pointer should not be null\n");
636 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
637 }
638
639 pModule->fpSTR = fpSTR;
640
641 return UTOPIA_STATUS_SUCCESS;
642 }
643
UtopiaModuleSetVersion(void * pModule,MS_U32 u32Version)644 MS_U32 UtopiaModuleSetVersion(void* pModule, MS_U32 u32Version)
645 {
646 TO_MODULE_PTR(pModule)->u32Version = u32Version;
647
648 return UTOPIA_STATUS_SUCCESS;
649 }
650
UtopiaModuleGetDebugLevel(void * pInstance,MS_U32 * pu32DebugLevel)651 MS_U32 UtopiaModuleGetDebugLevel(void* pInstance, MS_U32* pu32DebugLevel)
652 {
653 *pu32DebugLevel = TO_INSTANCE_PTR(pInstance)->psModule->u32DeviceDebugLevel;
654 return UTOPIA_STATUS_SUCCESS;
655 }
656
UtopiaModuleGetPtr(MS_U32 u32ModuleID,void ** ppModule)657 MS_U32 UtopiaModuleGetPtr(MS_U32 u32ModuleID, void** ppModule)
658 {
659 *ppModule = locate_module(u32ModuleID);
660
661 return UTOPIA_STATUS_SUCCESS;
662 }
663
UtopiaResourceCreate(char * resourceName,MS_U32 u32PrivateSize,void ** ppResource)664 MS_U32 UtopiaResourceCreate(char* resourceName
665 , MS_U32 u32PrivateSize, void** ppResource)
666 {
667 MS_U32 u32RetShmID, u32Status, u32Ret;
668 UTOPIA_RESOURCE* pResource = NULL;
669 char privateName[50]; // FIXME: potential bug
670 void* pPrivate = NULL;
671
672 /* 1. create resource */
673 u32Status = shm_malloc(sizeof(UTOPIA_RESOURCE), resourceName,
674 (void**)&pResource, &(u32RetShmID));
675 if (u32Status == UTOPIA_STATUS_SUCCESS)
676 {
677 pResource->shmid_self.ID = u32RetShmID;
678 pResource->shmid_next_resource.ID = 0xFFFFFFFF;
679 }
680 *ppResource = pResource;
681
682 /* 2. create resource private */
683 snprintf(privateName, sizeof(privateName), "%s_PRI", resourceName);
684 u32Ret = shm_malloc(u32PrivateSize, privateName,
685 &pPrivate, &(pResource->shmid_private.ID));
686
687 if((u32Ret != UTOPIA_STATUS_SUCCESS)&&(u32Status != UTOPIA_STATUS_SHM_EXIST)) //Coverity
688 {
689 printu("[utopia malloc error] Line: %d shm_malloc fail\n",__LINE__);
690 }
691
692 return u32Status;
693 }
694
UtopiaResourceGetPrivate(void * pResource,void ** ppPrivate)695 MS_U32 UtopiaResourceGetPrivate(void* pResource, void** ppPrivate)
696 {
697 *ppPrivate = shmid2va(TO_RESOURCE_PTR(pResource)->shmid_private.ID);
698 return 0;
699 }
700
701 /*
702 * case 1: no resource pool -
703 * --> create resource pool & attach resource to it. combine with case 2
704 * case 2: resource pool exists, but no mathcing resource pool
705 * --> create resource pool & attach resource to it. combine with case 1
706 * case 3: resource pool exists, and there's matching resource pool
707 * --> attach resource to it
708 */
UtopiaResourceRegister(void * pModuleTmp,void * pResourceTmp,MS_U32 u32RPoolID)709 MS_U32 UtopiaResourceRegister(void* pModuleTmp
710 , void* pResourceTmp, MS_U32 u32RPoolID)
711 {
712 UTOPIA_MODULE* pModule = TO_MODULE_PTR(pModuleTmp);
713 UTOPIA_RESOURCE* pResource = TO_RESOURCE_PTR(pResourceTmp);
714 char rpoolName[50];
715 MS_U32 u32Status;
716
717 /* 1. deal with resource pool */
718 UTOPIA_RESOURCE_POOL* pRPool = NULL;
719 UTOPIA_RESOURCE_POOL* pRPoolPrev = NULL;
720 locate_resource_pool(pModule, u32RPoolID, &pRPool, &pRPoolPrev);
721
722 /* rpool semaphore has been created in this process */
723 if (pRPool != NULL && pRPool->u32ResourcesSemaphore != 0)
724 {
725 printu("[utopia rpool warning] %s has already been established in this process%s\n"
726 , moduleNames[pModule->u32ModuleID], pRPool->shmid_self.name);
727 return UTOPIA_STATUS_SHM_EXIST ;
728 }
729
730 /*
731 * case 1: there's no resource pool
732 * --> *ppRPool = NULL & *ppRPoolPrev = NULL
733 * case 2: at least one resource pool exists, but not the located one
734 * --> *ppRPool = NULL & *ppRPoolPrev != NULL
735 * case 3: at least one resource pool exists, and so is the located one
736 * --> *ppRPool != NULL & ppRPoolPrev doesn't matter
737 */
738 if (pRPool == NULL) { /* case 1 or 2 */
739 MS_U32 u32RetRPoolShmID = 0;
740 MS_U32 u32ModuleID = pModule->u32ModuleID;
741
742 snprintf(rpoolName, sizeof(rpoolName), "%s_%d"
743 , rpoolNames[u32ModuleID], (int)u32RPoolID);
744 u32Status = shm_malloc(sizeof(UTOPIA_RESOURCE_POOL), rpoolName,
745 (void**)&pRPool, &u32RetRPoolShmID);
746 if (u32Status == UTOPIA_STATUS_SUCCESS)
747 {
748 pRPool->shmid_self.ID = u32RetRPoolShmID;
749 strncpy(pRPool->shmid_self.name, rpoolName
750 , sizeof(pRPool->shmid_self.name));
751 pRPool->u32PoolID = u32RPoolID;
752 pRPool->shmid_next_rpool.ID = 0xFFFFFFFF;
753 pRPool->shmid_resource_head.ID = 0xFFFFFFFF;
754 pRPool->u32MutexID = MsOS_CreateNamedMutex((MS_S8*)rpoolName);
755 pRPool->u32ResourcesSemaphore = 0;
756 }
757 /* check param. */
758 if (pResource->shmid_rpool.ID != 0)
759 {
760 return UTOPIA_STATUS_SUCCESS;
761 }
762
763 /* set up connection */
764 if (pRPoolPrev == NULL) // case 1
765 {
766 pModule->psModuleShm->shmid_rpool_head.ID = u32RetRPoolShmID;
767 }
768 else /* case 2 */
769 {
770 pRPoolPrev->shmid_next_rpool.ID = u32RetRPoolShmID;
771 }
772
773 pModule->psModuleShm->u32ResourcePoolTotal++;
774 }
775
776 /* 2. deal with resource */
777 pResource->shmid_rpool = pRPool->shmid_self;
778
779 UTOPIA_RESOURCE* pTargetRes = NULL;
780 UTOPIA_RESOURCE* pTargetResPrev = NULL;
781 locate_resource(pRPool, pResource->shmid_self.ID
782 , &pTargetRes, &pTargetResPrev);
783 /* case 1: there's no resource in pool */
784 /* --> pTargetRes = NULL, pTargetResPrev = NULL */
785 /* case 2: at least one resource exists, but not the located one */
786 /* --> pTargetRes = NULL, pTargetResPrev != NULL */
787 /* case 3: at least one resource exists, and so is the located one */
788 /* --> pTargetRes != NULL, pTargetResPrev doesn't matter */
789 if (pTargetRes == NULL) /* case 1 or 2 */
790 {
791 if (pTargetResPrev == NULL) /* case 1 */
792 {
793 pRPool->shmid_resource_head.ID = pResource->shmid_self.ID;
794 }
795 else /* case 2 */
796 {
797 pTargetResPrev->shmid_next_resource.ID = pResource->shmid_self.ID;
798 }
799 pRPool->u32ResourceTotal++;
800
801 return UTOPIA_STATUS_SUCCESS;
802 }
803 else /* case 3 */
804 {
805 /* duplicated registration: it may be registered by other process */
806 return UTOPIA_STATUS_SHM_EXIST ;
807 }
808 }
809
UtopiaResourceTryObtain(void * pModuleTmp,MS_U32 u32RPoolID,void ** ppResource)810 MS_U32 UtopiaResourceTryObtain(void* pModuleTmp
811 , MS_U32 u32RPoolID, void** ppResource)
812 {
813 UTOPIA_MODULE* pModule = TO_MODULE_PTR(pModuleTmp);
814 UTOPIA_RESOURCE_POOL* pLocatedRPool = NULL;
815 UTOPIA_RESOURCE_POOL* pLocatedRPoolPrev = NULL;
816 UTOPIA_RESOURCE* pAvailResource = NULL;
817 locate_resource_pool(pModule, u32RPoolID
818 , &pLocatedRPool, &pLocatedRPoolPrev);
819
820 if (!(pLocatedRPool->u32ResourceAvail))
821 return UTOPIA_STATUS_NO_RESOURCE;
822 #if defined(DISABLE_SYSCALL)
823 //flag =-1 : try lock. flag =0 : lock. others : not implement yet.
824 MsOS_ObtainNamedSemaphore(pLocatedRPool->u32ResourcesSemaphore, -1);
825 #else
826 obtain_sem(pLocatedRPool->u32ResourcesSemaphore);
827 #endif
828
829 pAvailResource = next_resource(pLocatedRPool, E_TYPE_RESOURCE_POOL);
830 MsOS_LockMutex(pLocatedRPool->u32MutexID, 0);
831 while (pAvailResource != NULL)
832 {
833 if (!(pAvailResource->bInUse))
834 {
835 pAvailResource->bInUse = true;
836 *ppResource = pAvailResource;
837 pLocatedRPool->u32ResourceAvail--;
838 MsOS_UnlockMutex(pLocatedRPool->u32MutexID, 0);
839 return UTOPIA_STATUS_SUCCESS;
840 }
841 else
842 {
843 pAvailResource = next_resource(pAvailResource, E_TYPE_RESOURCE);
844 }
845 }
846 MsOS_UnlockMutex(pLocatedRPool->u32MutexID, 0);
847
848 printu("[utopia resource error] code flow should not reach here\n");
849 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
850 }
851
UtopiaResourceObtain(void * pModTmp,MS_U32 u32RPoolID,void ** ppResource)852 MS_U32 UtopiaResourceObtain(void* pModTmp, MS_U32 u32RPoolID, void** ppResource)
853 {
854 // MS_S32 ret; /* check semop return value */ //coverity ret unused
855
856 #if DEADLOCK_DEBUG == 1
857 MS_U32 count = 0;
858 while(UTOPIA_STATUS_NO_RESOURCE ==
859 UtopiaResourceTryObtain(pModTmp, u32RPoolID, ppResource))
860 {
861 usleep(1000);
862 count++;
863 if ((count >= bt_threshold) && ((count % bt_period) == 0))
864 {
865 printu("%s deadlock!!!???\n",
866 moduleNames[TO_MODULE_PTR(pModTmp)->u32ModuleID]);
867 print_trace ();
868 }
869 }
870 return 0;
871 #endif
872
873 /* check param. */
874 if (MSOS_BRANCH_PREDICTION_UNLIKELY(pModTmp == NULL))
875 {
876 printu("[utopia param error] module pointer should not be null\n");
877 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
878 }
879 if (MSOS_BRANCH_PREDICTION_UNLIKELY(ppResource == NULL))
880 {
881 printu("[utopia param error] resource ppointer should not be null\n");
882 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
883 }
884
885 UTOPIA_MODULE* pModule = TO_MODULE_PTR(pModTmp);
886 UTOPIA_RESOURCE_POOL* pLocatedRPool = NULL;
887 UTOPIA_RESOURCE_POOL* pLocatedRPoolPrev = NULL;
888 UTOPIA_RESOURCE* pAvailResource = NULL;
889 locate_resource_pool(pModule, u32RPoolID
890 , &pLocatedRPool, &pLocatedRPoolPrev);
891 if (MSOS_BRANCH_PREDICTION_UNLIKELY(!pLocatedRPool))
892 {
893 printu("[utopia param error] non-registered rpool id?\n");
894 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
895 }
896
897 #if defined(DISABLE_SYSCALL)
898 //flag =-1 : try lock. flag =0 : lock. others : not implement yet.
899 if (MSOS_BRANCH_PREDICTION_UNLIKELY(FALSE == MsOS_ObtainNamedSemaphore(pLocatedRPool->u32ResourcesSemaphore, 0)))//coverity
900 {
901 printu("[utopia] obtain sem error :%d.\n", errno);
902 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
903 }
904 #else
905 retry:
906 // ret = obtain_sem(pLocatedRPool->u32ResourcesSemaphore);
907 // if (ret < 0) /* -1 for error */
908 if (0 > obtain_sem(pLocatedRPool->u32ResourcesSemaphore))//coverity
909 {
910 switch(errno)
911 {
912 case EINTR:
913 goto retry;
914 default:
915 printu("[utopia error] unexpected errno: %d\n", errno);
916 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
917 }
918 }
919 #endif
920
921 pAvailResource = next_resource(pLocatedRPool, E_TYPE_RESOURCE_POOL);
922 MsOS_LockMutex(pLocatedRPool->u32MutexID, 0);
923 while (pAvailResource != NULL)
924 {
925 if (!(pAvailResource->bInUse))
926 {
927 pAvailResource->bInUse = true;
928 *ppResource = pAvailResource;
929 pLocatedRPool->u32ResourceAvail--;
930 MsOS_UnlockMutex(pLocatedRPool->u32MutexID, 0);
931 return UTOPIA_STATUS_SUCCESS;
932 }
933 else
934 {
935 pAvailResource = next_resource(pAvailResource, E_TYPE_RESOURCE);
936 }
937 }
938 MsOS_UnlockMutex(pLocatedRPool->u32MutexID, 0);
939
940 printu("[utopia error] code flow should not reach here\n");
941 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
942 }
943
UtopiaResourceRelease(void * pResource)944 MS_U32 UtopiaResourceRelease(void* pResource)
945 {
946 UTOPIA_RESOURCE_POOL* pRPool
947 = RESOURCE_PTR_TO_RPOOL_PTR(TO_RESOURCE_PTR(pResource));
948 if(MSOS_BRANCH_PREDICTION_UNLIKELY(pRPool == NULL)) //Coverity
949 {
950 printu("[utopia error] Line: %d pRPool == NULL\n",__LINE__);
951 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
952 }
953 /* modify resource before releasing it, to avoid race condition */
954 MsOS_LockMutex(pRPool->u32MutexID, 0);
955 TO_RESOURCE_PTR(pResource)->bInUse = false;
956 pRPool->u32ResourceAvail++;
957 #if defined(DISABLE_SYSCALL)
958 MsOS_ReleaseNamedSemaphore(pRPool->u32ResourcesSemaphore, 0);
959 #else
960 release_sem(pRPool->u32ResourcesSemaphore);
961 #endif
962 MsOS_UnlockMutex(pRPool->u32MutexID, 0);
963
964 return UTOPIA_STATUS_SUCCESS;
965 }
966
UtopiaModuleAddResourceStart(void * psModuleTmp,MS_U32 u32PoolID)967 MS_U32 UtopiaModuleAddResourceStart(void* psModuleTmp, MS_U32 u32PoolID)
968 {
969 return UTOPIA_STATUS_SUCCESS;
970 }
971
972 #define PERMS 0666
973 #define SEM_NUM 1
974 /* semaphore num isn't equal to resource count */
set_rpool_sem(void * pModuleTmp,MS_U32 u32RPoolID,MS_U32 reset)975 static MS_U32 set_rpool_sem(void* pModuleTmp, MS_U32 u32RPoolID, MS_U32 reset)
976 {
977 #if defined(DISABLE_SYSCALL)
978 MS_S32 s32SemaphoreID;
979 #else
980 MS_U32 u32SemaphoreID;
981 #endif
982 UTOPIA_MODULE* pModule = TO_MODULE_PTR(pModuleTmp);
983
984 UTOPIA_RESOURCE_POOL* pLocatedRPool = NULL;
985 UTOPIA_RESOURCE_POOL* pLocatedRPoolPrev = NULL;
986 locate_resource_pool(pModule, u32RPoolID
987 , &pLocatedRPool, &pLocatedRPoolPrev);
988
989 if (!reset && /* no need to check for reset case */
990 pLocatedRPool->u32ResourcesSemaphore != 0 &&
991 pLocatedRPool->u32ResourcesSemaphore != 0xFFFFFFFF)
992 return UTOPIA_STATUS_RPOOL_ESTABLISHED;
993
994 #if defined(DISABLE_SYSCALL)
995 if (reset)
996 {
997 if (MSOS_BRANCH_PREDICTION_LIKELY(TRUE == MsOS_ResetNamedSemaphore(pLocatedRPool->u32ResourcesSemaphore)))
998 pLocatedRPool->u32ResourceAvail = pLocatedRPool->u32ResourceTotal;
999 else
1000 {
1001 printu("[utopia semaphore error] reset semaphore fail.\n");
1002 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
1003 }
1004 }
1005 else
1006 {
1007 s32SemaphoreID = MsOS_CreateNamedSemaphore(pLocatedRPool->shmid_self.name, pLocatedRPool->u32ResourceTotal);
1008 if (MSOS_BRANCH_PREDICTION_UNLIKELY(s32SemaphoreID < 0))
1009 {
1010 printu("[utopia semaphore error] create semaphore fail.\n");
1011 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
1012 }
1013 pLocatedRPool->u32ResourceAvail = pLocatedRPool->u32ResourceTotal;
1014 pLocatedRPool->u32ResourcesSemaphore = s32SemaphoreID;
1015 }
1016 #else
1017 MS_U32 u32ShmId, u32BufSize, u32Ret;
1018 MS_VIRT vaShm;
1019 u32Ret = MsOS_SHM_GetId((MS_U8*)"sem_key_start", sizeof(MS_U32)
1020 , &u32ShmId, &vaShm, &u32BufSize, MSOS_SHM_QUERY);
1021 MS_U32* pu32SemKey = NULL;
1022 if (MSOS_BRANCH_PREDICTION_LIKELY(u32Ret == TRUE))
1023 pu32SemKey = (MS_U32*)vaShm;
1024 else {
1025 printu("[utopia semaphore error] sem_key_start@shm can't be found\n");
1026 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
1027 }
1028
1029 /*
1030 * use sem key to create sem id
1031 * IPC_CREATE: if sem id exists, return it
1032 * if sem id doesn't exist, create one & return it
1033 * return 0 or 0xFFFFFFFF means fail, but i don't know why~
1034 */
1035 u32SemaphoreID = semget(*pu32SemKey, 0, IPC_CREAT | PERMS); // why 0 here???
1036 if(u32SemaphoreID == 0 || (unsigned int)u32SemaphoreID == 0xFFFFFFFF)
1037 {
1038
1039 u32SemaphoreID = semget(*pu32SemKey, SEM_NUM, IPC_CREAT | PERMS);
1040 /* create success, increase *pu32SemKey for next sem create */
1041 if ((u32SemaphoreID != 0 && (unsigned int)u32SemaphoreID != 0xFFFFFFFF))
1042 {
1043 (*pu32SemKey)++;
1044 }
1045
1046 while(u32SemaphoreID == 0 || (unsigned int)u32SemaphoreID == 0xFFFFFFFF)
1047 {
1048 u32SemaphoreID = semget(*pu32SemKey, SEM_NUM, IPC_CREAT | PERMS);
1049 (*pu32SemKey)++;
1050 }
1051 if (MSOS_BRANCH_PREDICTION_UNLIKELY(u32SemaphoreID < 0))
1052 {
1053 printu("[utopia semaphore error] create semaphore fail\n");
1054 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
1055 }
1056
1057 /* "0" is the semaphore id in sem. set which we got by semget */
1058 semctl(u32SemaphoreID, 0, SETVAL, pLocatedRPool->u32ResourceTotal);
1059 } else {
1060 (*pu32SemKey)++;
1061 }
1062 pLocatedRPool->u32ResourceAvail = pLocatedRPool->u32ResourceTotal;
1063 pLocatedRPool->u32ResourcesSemaphore = u32SemaphoreID;
1064 #endif
1065
1066 return UTOPIA_STATUS_SUCCESS;
1067 }
1068
UtopiaModuleAddResourceEnd(void * pModuleTmp,MS_U32 u32RPoolID)1069 MS_U32 UtopiaModuleAddResourceEnd(void* pModuleTmp, MS_U32 u32RPoolID)
1070 {
1071 return (MS_U32)set_rpool_sem(pModuleTmp, u32RPoolID, 0);
1072 }
1073
UtopiaModuleResetPool(void * pModuleTmp,MS_U32 u32RPoolID)1074 MS_U32 UtopiaModuleResetPool(void* pModuleTmp, MS_U32 u32RPoolID)
1075 {
1076 UTOPIA_RESOURCE_POOL* pLocatedRPool = NULL;
1077 UTOPIA_RESOURCE_POOL* pLocatedRPoolPrev = NULL;
1078 UTOPIA_RESOURCE* pAvailResource = NULL;
1079
1080 locate_resource_pool(pModuleTmp, u32RPoolID
1081 , &pLocatedRPool, &pLocatedRPoolPrev);
1082 pAvailResource = next_resource(pLocatedRPool, E_TYPE_RESOURCE_POOL);
1083 MsOS_LockMutex(pLocatedRPool->u32MutexID, 0);
1084 while (pAvailResource != NULL)
1085 {
1086 pAvailResource->bInUse = false;
1087 pAvailResource = next_resource(pAvailResource, E_TYPE_RESOURCE);
1088 }
1089 MsOS_UnlockMutex(pLocatedRPool->u32MutexID, 0);
1090
1091 return set_rpool_sem(pModuleTmp, u32RPoolID, 1);
1092 }
1093
UtopiaSetIPAUTH(ST_IPAUTH_SHARED_VARS * IpControl,MS_U8 * gCusID,MS_U8 * gCusHash)1094 MS_U32 UtopiaSetIPAUTH(ST_IPAUTH_SHARED_VARS *IpControl, MS_U8 *gCusID, MS_U8 *gCusHash)
1095 {
1096 MS_S32 s32UtopiaFd;
1097 UTOPIA_AUTH_IPCHECK_ARG* sIPCheckArg;
1098 UTOPIA_AUTH_HASHINFO_ARG* sHashInfoArg;
1099
1100 s32UtopiaFd = open("/proc/utopia", O_RDWR);
1101 if(0 > s32UtopiaFd)
1102 {
1103 printf("open /proc/utopia fail\n");
1104 close(s32UtopiaFd);
1105 return UTOPIA_STATUS_FAIL;
1106 }
1107 sIPCheckArg=malloc(sizeof(UTOPIA_AUTH_IPCHECK_ARG));
1108 if(sIPCheckArg == NULL)//coverity
1109 {
1110 printf("sIPCheckArg=malloc(sizeof(UTOPIA_AUTH_IPCHECK_ARG)) fail\n");
1111 close(s32UtopiaFd);
1112 return UTOPIA_STATUS_FAIL;
1113 }
1114 memcpy(sIPCheckArg,IpControl,sizeof(UTOPIA_AUTH_IPCHECK_ARG));
1115 if(ioctl(s32UtopiaFd,UTOPIA_IOCTL_AUTH_SetIPCheck,sIPCheckArg))//coverity
1116 {
1117 printf("[%s][%d] Fail!!!!\n",__FUNCTION__,__LINE__);
1118 free(sIPCheckArg);
1119 close(s32UtopiaFd);
1120 return UTOPIA_STATUS_FAIL;
1121 }
1122
1123 sHashInfoArg=malloc(sizeof(UTOPIA_AUTH_HASHINFO_ARG));
1124 if(sHashInfoArg == NULL)//coverity
1125 {
1126 printf("sHashInfoArg=malloc(sizeof(UTOPIA_AUTH_HASHINFO_ARG)) fail\n");
1127 free(sIPCheckArg);
1128 close(s32UtopiaFd);
1129 return UTOPIA_STATUS_FAIL;
1130 }
1131 memcpy(sHashInfoArg->u8CusID,gCusID,sizeof(sHashInfoArg->u8CusID));
1132 memcpy(sHashInfoArg->u8CusHash,gCusHash,sizeof(sHashInfoArg->u8CusHash));
1133 if(ioctl(s32UtopiaFd,UTOPIA_IOCTL_AUTH_SetHashInfo,sHashInfoArg))//coverity
1134 {
1135 printf("[%s][%d] Fail!!!!\n",__FUNCTION__,__LINE__);
1136 free(sIPCheckArg);
1137 free(sHashInfoArg);
1138 close(s32UtopiaFd);
1139 return UTOPIA_STATUS_FAIL;
1140 }
1141
1142 close(s32UtopiaFd);
1143 free(sIPCheckArg);
1144 free(sHashInfoArg);
1145 return 0;
1146 }
1147
1148
UtopiaModuleQueryMode(MS_U32 u32ModuleID)1149 MS_U32 UtopiaModuleQueryMode(MS_U32 u32ModuleID)
1150 {
1151 if(moduleMode[u32ModuleID]&KERNEL_MODE)
1152 return KERNEL_MODE;
1153 else
1154 return 0;
1155 }
1156