[ JIRA Id - ODUHIGH-573 ] Code changes upgraded to Gcc version 11.4.0
[o-du/l2.git] / src / mt / ss_gen.c
1 /*******************************************************************************
2 ################################################################################
3 #   Copyright (c) [2017-2019] [Radisys]                                        #
4 #                                                                              #
5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
6 #   you may 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,          #
13 #   WITHOUT 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 *******************************************************************************/
18 \f
19 /********************************************************************20**
20  
21      Name:     System Services -- general functions
22  
23      Type:     C source file
24  
25      Desc:     Source code for System Services startup and general
26                System Services.
27  
28      File:     ss_gen.c
29  
30 *********************************************************************21*/
31
32 \f
33 /* header include files (.h) */
34
35 #include <stdlib.h>
36 #include <unistd.h>
37 #include "envopt.h"        /* environment options */
38 #include "envdep.h"        /* environment dependent */
39 #include "envind.h"        /* environment independent */
40   
41 #include "gen.h"           /* general layer */
42 #include "ssi.h"           /* system services */
43
44 #include "ss_err.h"        /* errors */
45 #include "ss_dep.h"        /* implementation-specific */
46 #include "ss_queue.h"      /* queues */
47 #include "ss_task.h"       /* tasking */
48 #include "ss_msg.h"        /* messaging */
49 #include "ss_mem.h"        /* memory management interface */
50 #include "ss_gen.h"        /* general */
51 /*ss013.301: Fixed Warnings for 32/64 bit compilation*/
52 #ifdef SS_FBSED_TSK_REG
53 #include "cm_task.h"
54 #endif /* SS_FBSED_TSK_REG */
55 #include "cm_llist.h"
56 #include "cm_hash.h"
57 /* ss001.301: additions */
58 #include "cm_mem.h"        /* memory management */
59
60 /* header/extern include files (.x) */
61
62 #include "gen.x"           /* general layer */
63 #include "ssi.x"           /* system services */
64
65 #include "ss_dep.x"        /* implementation-specific */
66 #include "ss_queue.x"      /* queues */
67 #include "ss_task.x"       /* tasking */
68 #include "ss_timer.x"      /* timers */
69 #include "ss_strm.x"       /* STREAMS */
70 #include "ss_msg.x"        /* messaging */
71 #include "ss_mem.x"        /* memory management interface */
72 #include "ss_drvr.x"       /* driver tasks */
73 #ifdef SS_LOCKLESS_MEMORY
74 #include "cm_llist.x"
75 #include "cm_hash.x"
76 #include "cm_mem_wl.x"        /* common memory manager */
77 #else
78 #include "cm_mem.x"        /* common memory manager */
79 #endif /* SS_LOCKLESS_MEMORY */
80 #include "ss_gen.x"        /* general */
81 /* ss001.301: additions */
82 #ifdef SS_LOGGER_SUPPORT 
83 #include "cm_lib.x"
84 #endif /* SS_LOGGER_SUPPORT  */
85 #ifdef SS_MULTICORE_SUPPORT
86 #include "cm_llist.x"
87 #include "cm_hash.x"
88 #include "cm_mem.h"
89 #include "cm_mem_wl.x"
90 #include "cm_lib.x"
91 #endif
92
93 /* Cavium Changes:ss004.301 */
94 #ifdef SS_SEUM_CAVIUM
95 #include "cvmx-config.h"
96 #include "cvmx.h"
97 #endif /* SS_SEUM_CAVIUM */
98
99 /*ss011.301 : RMIOS release related changes*/
100 #ifdef SS_RMIOS
101 #include "mt_msgr.x"
102 #endif
103 /*ss013.301: Fixed Warnings for 32/64 bit compilation*/
104 #ifdef SS_FBSED_TSK_REG
105 #include "cm_task.x"
106 #endif /* SS_FBSED_TSK_REG */
107 #include <signal.h>
108 \f
109 /* public variable declarations */
110
111 /*ss014.301: SSI-4GMX related changes*/
112 #ifdef SS_4GMX_LCORE
113 volatile SsOs     osCp;           /* common OS control point */
114 #else
115 SsOs     osCp;           /* common OS control point */
116 #endif
117 /* for SGetOpt() */
118 extern S16 msOptInd;
119 extern S8  *msOptArg;
120 extern Txt **msArgv;
121 extern S16 msArgc;
122
123  
124 extern Cntr     cfgNumRegs;
125 extern SsRegCfg cfgRegInfo[SS_MAX_REGS];
126
127 \f
128 /* ss029.103: modification: multiple procId related changes */ 
129 #ifdef SS_MULTIPLE_PROCS
130 /* static functions */
131 static S16 SInsProcId ARGS((ProcId proc));
132 static S16 SRemProcId ARGS((ProcId proc));
133 static S16 SLockOsCp  ARGS((Void));
134 static S16 SULockOsCp ARGS((Void));
135 #endif /* SS_MULTIPLE_PROCS */
136
137 #ifdef SSI_STATIC_MEM_LEAK_DETECTION
138 static void InitializeForStaticMemLeak ARGS((void));
139 static void InitializeStaticMemAllocInfo ARGS((StaticMemAllocInfo* memAllocInfo));
140 uint32_t GetNextFreeIdx ARGS((StaticMemAllocInfo * memAllocInfo));
141 void FreeIdx ARGS((uint8_t* ptr, uint32_t idx, StaticMemAllocInfo* memAllocInfo,uint32_t size, char*
142       file, uint32_t line));
143 void LogForStaticMemLeak ARGS((StaticMemAllocInfo* memAllocInfo, char* file,
144       uint32_t line, uint32_t size, void* ptr, uint32_t idx));
145 static void PrintStaticMemAllocInfo ARGS((StaticMemAllocInfo* memAllocInfo, FILE
146       *opFile));
147 #endif
148 /* ss001.301: additions */
149
150 void DumpSSIDemandQDebugInformation()
151 {
152    uint32_t i,j;
153    RTLIN_DUMP_DEBUG("Demand Q Information\n");
154    RTLIN_DUMP_DEBUG("====================\n");
155    for(i = 0; i < osCp.numSTsks; i++)
156    {
157       SsSTskEntry* tskEntry = &(osCp.sTskTbl[i]);
158       
159       for(j = 0; j < SS_MAX_NUM_DQ; j++)
160       {
161 #ifndef ALIGN_64BIT
162          RTLIN_DUMP_DEBUG("Task[%lu] Q[%lu] QSize = %lu region=%d\n", i, j, tskEntry->dQ.queue[j].crntSize,tskEntry->region);
163 #else
164          RTLIN_DUMP_DEBUG("Task[%u] Q[%u] QSize = %u region=%d\n", i, j, tskEntry->dQ.queue[j].crntSize,tskEntry->region);
165 #endif
166       }
167    }
168 }
169
170 #ifdef TENB_T2K3K_SPECIFIC_CHANGES
171 pthread_mutex_t dumpingLock = PTHREAD_MUTEX_INITIALIZER;
172
173 Void mtSigSegvHndlr()
174 {
175    int i;
176
177    printf("\nBacktrace for thread Id (%lu) total threads = %d\n", (unsigned long) pthread_self(), osCp.numSTsks);   
178    ysPrntBkTrace();
179    for(i = 0; i < osCp.numSTsks; i++)
180    {
181       SsSTskEntry* tskEntry = &(osCp.sTskTbl[i]);
182       if((tskEntry->dep.tId != pthread_self()) && (tskEntry->dep.tId != 0))
183       {
184           pthread_kill(tskEntry->dep.tId, SIGUSR2);
185       }
186    }
187
188    sleep(5);
189 }
190
191 Void mtSigUsr2Hndlr()
192 {
193    printf("\nBacktrace for thread Id (%lu) cause:SIGUSR2(%d)\n",(unsigned long) pthread_self(),SIGUSR2);   
194
195    pthread_mutex_lock(&dumpingLock);  
196    ysPrntBkTrace();
197    pthread_mutex_unlock(&dumpingLock);  
198
199    sleep(5);
200    
201    exit(0);
202 }
203
204 #endif
205
206 \f
207 /*
208 *
209 *       Fun:   System Services initialization function
210 *
211 *       Desc:  This is the general initialization function for
212 *              all System Services implementations. It initializes
213 *              all the common global data structures and calls the
214 *              implementation-specific initialization and start
215 *              functions.
216 *
217 *       Ret:   Void
218 *
219 *       Notes: 
220 *
221 *       File:  ss_gen.c
222 *
223 */
224 S16 SInit(void)
225 {
226    S16 ret;
227    REG1 S16 i;
228    REG2 S16 j;
229    REG3 S16 k;
230    SsTTskEntry *tTsk;
231    SsSTskEntry *sTsk;
232    SsTmrEntry *tmr;
233    SsRegionEntry *reg;
234    /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
235    Txt prntBufLoc[1000];
236 #ifdef SS_DRVR_SUPPORT
237    SsDrvrTskEntry *drvrTsk;
238 #endif
239 /* ss002.301 : Modications */
240
241    osCp.configFilePath = "/mnt/tmp/configFile";
242
243    /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
244  
245    /* ss019.103 - Modified for correct initialization of OS control point */
246    /* start initializing OS control point */
247 /* ss029.103: modification: multiple procId related changes */ 
248 #ifndef SS_MULTIPLE_PROCS
249 /* ss004.301: Cavium changes */
250 #ifdef SS_SEUM_CAVIUM
251                   osCp.procId = cvmx_get_core_num();
252 #else
253                   osCp.procId = SS_PROC_ID;
254 #endif /* SS_SEUM_CAVIUM */
255 #else /* SS_MULTIPLE_PROCS */
256    for (i = 0; i < SS_MAX_PROCS; i++)
257       osCp.procLst.procId[i] = PROCNC;
258
259    osCp.procLst.free = SS_MAX_PROCS;
260 #endif /* SS_MULTIPLE_PROCS */
261
262 #ifdef SS_THR_REG_MAP
263    memset(osCp.threadMemoryRegionMap, SS_INVALID_THREAD_REG_MAP, 
264             (sizeof(Region) * SS_MAX_THREAD_REGION_MAP));
265    ssRegMainThread();
266 #endif
267
268    /* implementation specific general initialization */
269    ret = ssdInitGen();
270    if (ret != ROK)
271         {
272    /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
273           sprintf(prntBufLoc,"\n SInit(): ssdInitGen failed to initialize\
274                                                                 implementation specific general information \n");
275       SDisplay(1,prntBufLoc);
276       return RFAILED;
277         }
278  
279 #ifdef SSI_STATIC_MEM_LEAK_DETECTION
280    InitializeForStaticMemLeak();
281 #endif
282    /* initialize memory information */
283    osCp.numRegions = 0;
284
285    for (i = 0;  i < SS_MAX_REGS;  i++)
286    {
287       reg = &osCp.regionTbl[i];
288
289       reg->used = FALSE;
290
291       reg->start = NULLP;
292       reg->size = 0;
293       reg->regCb = NULLP;
294       reg->flags = 0;
295       reg->alloc = NULLP;
296       reg->free = NULLP;
297       reg->ctl = NULLP;
298       /* ss007.301 initializing the per region mBufRefLock */
299       SInitLock(&reg->mBufRefLock, SS_LOCK_MUTEX);
300
301       /* zero the pool information */
302       reg->numPools = 0;
303       for (j = 0;  j < SS_MAX_POOLS_PER_REG;  j++)
304          reg->poolTbl[j].type = SS_POOL_UND;
305
306       /* find this region ID in the region configuration structure */
307       for (j = 0;  j < cfgNumRegs;  j++)
308          if (cfgRegInfo[j].region == i)
309             break;
310
311       /* this region is not configured */
312       if (j == cfgNumRegs)
313          continue;
314
315       /* Load the configuration information into the region table.
316        *  Note, the region still has to be registered, for it to
317        *  be usable.
318        */
319       for (k = 0;  k < cfgRegInfo[j].numPools;  k++)
320       {
321          reg->poolTbl[k].type = cfgRegInfo[j].pools[k].type;
322          if (reg->poolTbl[k].type == SS_POOL_DYNAMIC)
323             reg->poolTbl[k].u.dpool.size = cfgRegInfo[j].pools[k].size;
324       }
325    }
326
327    /* Initialization of dynamic regions */
328    for (i = 0;  i < SS_MAX_REGS;  i++)
329    {
330       reg = &osCp.dynRegionTbl[i];
331
332       reg->used = FALSE;
333
334       reg->start = NULLP;
335       reg->size = 0;
336       reg->regCb = NULLP;
337       reg->flags = 0;
338       reg->alloc = NULLP;
339       reg->free = NULLP;
340       reg->ctl = NULLP;
341       /* ss007.301 initializing the per region mBufRefLock */
342       SInitLock(&reg->mBufRefLock, SS_LOCK_MUTEX);
343
344       /* zero the pool information */
345       reg->numPools = 0;
346       for (j = 0;  j < SS_MAX_POOLS_PER_REG;  j++)
347          reg->poolTbl[j].type = SS_POOL_UND;
348
349       /* find this region ID in the region configuration structure */
350       for (j = 0;  j < cfgNumRegs;  j++)
351          if (cfgRegInfo[j].region == i)
352             break;
353
354       /* this region is not configured */
355       if (j == cfgNumRegs)
356          continue;
357
358       /* Load the configuration information into the region table.
359        *  Note, the region still has to be registered, for it to
360        *  be usable.
361        */
362       for (k = 0;  k < cfgRegInfo[j].numPools;  k++)
363       {
364          reg->poolTbl[k].type = cfgRegInfo[j].pools[k].type;
365          if (reg->poolTbl[k].type == SS_POOL_DYNAMIC)
366             reg->poolTbl[k].u.dpool.size = cfgRegInfo[j].pools[k].size;
367       }
368    }
369
370    ret = ssInitSema(&osCp.regionTblSem, SS_MAX_STSKS);
371    if (ret != ROK)
372         {
373     /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
374           sprintf(prntBufLoc,"\n SInit(): Could not initialize the region Table Semaphore \n");
375       SDisplay(1,prntBufLoc);
376           goto cleanup0;
377         }
378
379    /* implementation specific memory initialization */
380    ret = ssdInitMem();
381    if (ret != ROK)
382         {
383     /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
384           sprintf(prntBufLoc,"\n SInit(): Memory initialization failed \n");
385       SDisplay(1,prntBufLoc);
386           goto cleanup1;
387         }
388
389
390    /* initialize TAPA and system task information */
391 /* ss029.103: modification: multiple procId related changes */ 
392 #ifndef SS_MULTIPLE_PROCS
393    for (i = 0;  i < SS_MAX_ENT;  i++)
394       for (j = 0;  j < SS_MAX_INST;  j++)
395          osCp.tTskIds[i][j] = SS_TSKNC;
396 #else /* SS_MULTIPLE_PROCS */
397    for (i = 0;  i < SS_MAX_PROCS;  i++)
398       for (j = 0;  j < SS_MAX_ENT;  j++)
399          for (k = 0;  k < SS_MAX_INST;  k++)
400             osCp.tTskIds[i][j][k] = SS_TSKNC;
401 #endif /* SS_MULTIPLE_PROCS */
402
403    for (i = 0;  i < SS_MAX_TTSKS;  i++)
404    {
405       tTsk = &osCp.tTskTbl[i];
406
407       tTsk->used = FALSE;
408       tTsk->ent = ENTNC;
409       tTsk->inst = INSTNC;
410       tTsk->tskType = TTUND;
411       tTsk->tskPrior = 0;
412       tTsk->initTsk = NULLP;
413       tTsk->actvTsk = NULLP;
414       tTsk->sTsk = NULLP;
415 /* ss029.103: addition: TAPA task control block added */
416 #ifdef SS_MULTIPLE_PROCS
417       tTsk->xxCb = NULLP;
418 #endif /* SS_MULTIPLE_PROCS */
419
420       tTsk->nxt = i + 1;
421    }
422
423    osCp.numTTsks = 0;
424    osCp.nxtTTskEntry = 0;
425
426    ret = ssInitSema(&osCp.tTskTblSem, SS_MAX_STSKS);
427    if (ret != ROK)
428         {
429     /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
430           sprintf(prntBufLoc,"\n SInit(): Could not initialize the tTask table Semaphore \n");
431       SDisplay(1,prntBufLoc);
432           goto cleanup2;
433         }
434
435 #ifdef SS_MULTICORE_SUPPORT
436   /* check whether number of system tasks is
437    * equal to number of (regions-1).
438    * The last region is meant for timer task
439    * which under the current feature has as entry
440    * in system task table.
441    */
442   if(SS_MAX_STSKS > SS_MAX_REGS)
443   {
444     /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
445       goto cleanup3;
446   }
447 #endif
448
449    /* initialize system task information */
450    for (i = 0;  i < SS_MAX_STSKS;  i++)
451    {
452       sTsk = &osCp.sTskTbl[i];
453
454       sTsk->used = FALSE;
455       sTsk->termPend = FALSE;
456       sTsk->tskPrior = 0;
457       for (j = 0;  j < SS_MAX_TTSKS;  j++)
458          sTsk->tTsks[j] = SS_INVALID_IDX;
459       sTsk->numTTsks = 0;
460
461       sTsk->nxt = i + 1;
462 /* ss002.301 : Modifications */
463 #ifdef SS_MULTICORE_SUPPORT
464       if(i == 0)
465       {
466          sTsk->region = (SS_MAX_REGS - 1);
467       }
468       else
469       {
470          sTsk->region = i-1;
471       }
472 #endif
473    }
474
475    osCp.numSTsks = 0;
476    osCp.nxtSTskEntry = 0;
477
478    ret = SInitLock(&osCp.sTskTblLock, SS_STSKTBL_LOCK);
479    if (ret != ROK)
480    {
481     /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
482           sprintf(prntBufLoc,"\n SInit(): Could not initialize the tTask table Semaphore \n");
483       SDisplay(1,prntBufLoc);
484       goto cleanup3;
485    }
486
487         /* ss028.103 - Addition of lock for mBuf reference count */
488         /* ss007.301 moving the mBufRefLock from common to per region */
489         /* SInitLock(&osCp.mBufRefLock, SS_LOCK_MUTEX);*/
490
491    /* implementation specific task initialization */
492    ret = ssdInitTsk();
493    if (ret != ROK)
494    {
495     /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
496           sprintf(prntBufLoc,"\n SInit(): implementation specific task initialization Failed \n");
497       SDisplay(1,prntBufLoc);
498       goto cleanup4;
499    }
500
501 #ifdef SS_DRVR_SUPPORT
502    /* initialize driver task information */
503    for (i = 0;  i < SS_MAX_DRVRTSKS;  i++)
504    {
505       drvrTsk = &osCp.drvrTskTbl[i];
506
507       drvrTsk->used = FALSE;
508
509       drvrTsk->channel = 0;
510       drvrTsk->actvTsk = NULLP;
511       drvrTsk->isTsk = NULLP;
512       drvrTsk->low = 0;
513       drvrTsk->high = 0;
514    }
515
516    osCp.numDrvrTsks = 0;
517
518    /* implementation specific driver initialization */
519    ret = ssdInitDrvr();
520    if (ret != ROK)
521         {
522     /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
523           sprintf(prntBufLoc,"\n SInit(): ssdInitDrvr failed \n");
524       SDisplay(1,prntBufLoc);
525           goto cleanup5;
526         }
527 #endif
528
529         /*ss004.301: Cavium Changes */
530 #ifdef SS_SEUM_CAVIUM
531         ret = ssInitRcvWork();
532         if (ret != ROK)
533         {
534     /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
535           goto cleanup6;
536         }
537 #endif /* SS_SEUM_CAVIUM */
538
539
540    /* initialize the demand queue lookup table */
541    osCp.dmndQLookupTbl[0] = 255;
542    osCp.dmndQLookupTbl[1] = 0;
543    osCp.dmndQLookupTbl[2] = 1;
544    osCp.dmndQLookupTbl[3] = 1;
545    for (i = 4;  i < 256;  i++)
546    {
547       if (i >= 128  &&  i <= 255)
548          osCp.dmndQLookupTbl[i] = 7;
549       if (i >= 64  &&  i <= 127)
550          osCp.dmndQLookupTbl[i] = 6;
551       if (i >= 32  &&  i <= 63)
552          osCp.dmndQLookupTbl[i] = 5;
553       if (i >= 16  &&  i <= 31)
554          osCp.dmndQLookupTbl[i] = 4;
555       if (i >= 8  &&  i <= 15)
556          osCp.dmndQLookupTbl[i] = 3;
557       if (i >= 4  &&  i <= 7)
558          osCp.dmndQLookupTbl[i] = 2;
559    }
560
561
562    /* initialize timer information */
563    for (i = 0;  i < SS_MAX_TMRS;  i++)
564    {
565       tmr = &osCp.tmrTbl[i];
566
567       tmr->used = FALSE;
568       tmr->tmrId = 0;
569       tmr->ownerEnt = ENTNC;
570       tmr->ownerInst = INSTNC;
571       tmr->interval = 0;
572       /*
573        *  ss015.301 - Modifed in initialization as timer activation 
574        *  functions enclosed in a union. Also initialized the mtFlag
575        *  to FALSE 
576        */
577       tmr->ssTmrActvFn.actvFnc.tmrActvFn = NULLP;
578 #ifndef SS_MULTIPLE_PROCS
579 #ifdef SS_MT_TMR
580       tmr->ssTmrActvFn.mtFlag = FALSE; 
581       tmr->ssTmrActvFn.actvFnc.tmrActvFnMt = NULLP;
582 #endif
583 #endif
584       tmr->nxt = i + 1;
585    }
586
587    osCp.numTmrs = 0;
588    osCp.nxtTmrEntry = 0;
589
590    ret = SInitLock(&osCp.tmrTblLock, SS_TMRTBL_LOCK);
591    if (ret != ROK)
592    {
593     /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
594        goto cleanup6;
595    }
596
597    /* implementation specific timer initialization */
598    ret = ssdInitTmr();
599    if (ret != ROK)
600    {
601        /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
602        sprintf(prntBufLoc,"\n SInit(): Could not initialize the timer \n");
603        SDisplay(1,prntBufLoc);
604        goto cleanup7;
605    }
606
607    /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
608    /* ss005.201: Initialize logging streams */
609    /* implementation specific logging initialization */
610    ret = ssdInitLog();
611    if (ret != ROK)
612    {
613        /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
614        sprintf(prntBufLoc,"\n SInit(): Could not initialize the Logging streams \n");
615        SDisplay(1,prntBufLoc);
616        goto cleanup8;
617    }
618
619 #ifdef SS_LOGGER_SUPPORT /* ss001.301: additions */
620    /* Initialize the lock, return on failure */
621    if( SInitLock(&(osCp.logger.bufLock),SS_LOCK_MUTEX) != ROK)
622    {
623        /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
624        sprintf(prntBufLoc,"\n SInit(): Could not initialize the Logger Buffer Lock  \n");
625        SDisplay(1,prntBufLoc);
626        goto cleanup9;
627    } /* if */
628    
629    /* Initialize the logger configuration flag */
630    osCp.logger.configured = FALSE;
631    /* Ss002.301 : Initialised */
632    osCp.logger.started = FALSE;
633 #endif /* SS_LOGGER_SUPPORT */
634 /* ss001.301: additions */
635
636 #ifdef SS_HISTOGRAM_SUPPORT
637    /* Here we are filling all the tapa entity Ids, which will be
638     * helpful to get the entity Id using file name. */
639    ret = SFillEntIds();
640 #endif /* SS_HISTOGRAM_SUPPORT */
641
642
643 #ifdef SS_FBSED_TSK_REG
644    /* Configure task registration based on the configuration */
645    /*ss013.301 : Fixed warnings for 32/64 bit compilation*/
646    cmCfgrTskReg((uint8_t *)"task_info.t");
647 #endif /* SS_FBSED_TSK_REG  */
648
649 /*ss011.301 : RMIOS release related changes*/
650 #ifdef SS_RMIOS
651    spInit();
652 #endif
653
654    /* call tst() function */
655    ret = tst();
656    if (ret != ROK)
657    {
658        /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
659       goto cleanup10;
660    }
661
662
663    /* call implementation-specific starter function */
664    ssdStart();
665
666
667    return ROK;
668
669
670 /* clean up code */
671 /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
672 cleanup10:
673 #ifdef SS_LOGGER_SUPPORT 
674    /* ss005.301: Deinitialize the logging at the end */
675    SDestroyLock(&(osCp.logger.bufLock));
676    /*ss013.301 : Fix for compile time warning*/
677 cleanup9:
678 #endif /* SS_LOGGER_SUPPORT */
679    ssdDeinitLog();
680 cleanup8:
681    ssdDeinitTmr();
682 cleanup7:
683    SDestroyLock(&osCp.tmrTblLock);
684
685 cleanup6:
686 #ifdef SS_DRVR_SUPPORT
687    ssdDeinitDrvr();
688 cleanup5:
689 #endif
690    ssdDeinitTsk();
691 cleanup4:
692    SDestroyLock(&osCp.sTskTblLock);
693 cleanup3:
694    if ( (ssDestroySema(&osCp.tTskTblSem)) != ROK)
695       {
696 #if (ERRCLASS & ERRCLS_DEBUG)
697          SSLOGERROR(ERRCLS_DEBUG, ESS012, ERRZERO,
698                          "Could not destroy the Semaphore");
699         /* ss005.301: Changes, clean the threads and exit */
700 #endif
701       }
702
703 cleanup2:
704    ssdDeinitMem();
705 cleanup1:
706         /* ss007.301 destroying the per region mBufRefLock */
707         for (i= 0;i<SS_MAX_REGS;i++)
708         {
709           SDestroyLock(&osCp.regionTbl[i].mBufRefLock);
710         }
711    /* ss006.13: addition */
712    if ( (ssDestroySema(&osCp.regionTblSem)) != ROK)
713    {
714 #if (ERRCLASS & ERRCLS_DEBUG)
715          SSLOGERROR(ERRCLS_DEBUG, ESS013, ERRZERO,
716                "Could not destroy the Semaphore");
717        /* ss005.301: Changes, clean the threads and exit */
718 #endif
719    }
720 cleanup0:
721    ssdDeinitGen();
722
723
724    return RFAILED;
725 }
726
727 \f
728 /* ss033.103: Added SDeInit API to free all the resources */
729 /*
730 *
731 *       Fun:   System Services de-initialization function
732 *
733 *       Desc:  This is the de-initialization function for System 
734 *              Services implementations. It releases all the common
735 *              global data structures.
736 *
737 *       Ret:   Void
738 *
739 *       Notes: 
740 *
741 *       File:  ss_gen.c
742 *
743 */
744 S16 SDeInit(void)
745 {
746   /* ss007.301 */
747   uint16_t    regCnt;
748
749
750    ssdDeinitTmr();
751    SDestroyLock(&osCp.tmrTblLock);
752
753 #ifdef SS_DRVR_SUPPORT
754    ssdDeinitDrvr();
755 #endif
756
757    ssdDeinitTsk();
758    SDestroyLock(&osCp.sTskTblLock);
759
760    if ((ssDestroySema(&osCp.tTskTblSem)) != ROK)
761    {
762 #if (ERRCLASS & ERRCLS_DEBUG)
763     SSLOGERROR(ERRCLS_DEBUG, ESS014, ERRZERO,
764                       "Could not destroy the Semaphore");
765     return RFAILED;
766
767 #endif
768    }
769
770    ssdDeinitMem();
771
772    if ((ssDestroySema(&osCp.regionTblSem)) != ROK)
773    {
774 #if (ERRCLASS & ERRCLS_DEBUG)
775       SSLOGERROR(ERRCLS_DEBUG, ESS015, ERRZERO,
776                       "Could not destroy the Semaphore");
777       return RFAILED;
778
779 #endif
780    }
781
782         ssdDeinitGen();
783         /* ss007.301 destroying the per region mBufRefLock */
784         for (regCnt = 0;  regCnt < SS_MAX_REGS;  regCnt++)
785         {
786           SDestroyLock(&osCp.regionTbl[regCnt].mBufRefLock);
787         }
788
789         /* ss005.301: Deinitialize the logging at the end */
790 #ifdef SS_LOGGER_SUPPORT 
791    SDestroyLock(&(osCp.logger.bufLock));
792 #endif /* SS_LOGGER_SUPPORT */
793    ssdDeinitLog();
794    return ROK;
795
796 }
797 /* ss001.301: additions */
798 #ifdef SS_LOGGER_SUPPORT 
799 S16 SWrtLogBuf
800 (
801 Txt *buf                        /* buffer */
802 )
803 {
804    S16 bufSz;
805    /* buffer synchronisation*/
806    bufSz = cmStrlen((uint8_t *)buf);
807    SLock(&osCp.logger.bufLock);
808    if(osCp.logger.started == FALSE)
809    {
810       (Void)SUnlock(&(osCp.logger.bufLock));
811       return ROK;
812    }
813    /*
814     * Append the buffer to the global buffer
815     * and increment the current buffer size of the global buffer
816     */
817    if(((osCp.logger.curBufSiz) + bufSz) >= osCp.logger.maxBufSiz)
818    {
819       SFlushBufToLog(osCp.logger.buffer);
820       osCp.logger.curBufSiz = 0;
821       memset(osCp.logger.buffer, '\0', osCp.logger.maxBufSiz);
822       sprintf(osCp.logger.buffer, "%s", buf);
823       osCp.logger.curBufSiz += bufSz;
824    }
825    else
826    {
827       strcat(osCp.logger.buffer,buf);
828       osCp.logger.curBufSiz += bufSz;
829    }
830    (Void)SUnlock(&(osCp.logger.bufLock));
831    return ROK;
832 }
833 #endif /* SS_LOGGER_SUPPORT  */
834 /*
835 *
836 *       Fun:   SPrint
837 *
838 *       Desc:  Print a string.
839 *
840 *              This function should be used for debugging only.
841 *
842 *       Ret:   ROK      - ok
843 *
844 *       Notes: Text buffer should be null terminated.
845 *
846 *              SDisplay will replace SPrint.
847 *
848 *              Typical usage consists of a call to sprintf to
849 *              format the string into a buffer followed by a
850 *              call to SPrint
851 *
852 *       File:  ss_gen.c
853 *
854 */
855 S16 SPrint
856 (
857 Txt *buf                        /* buffer */
858 )
859 {
860
861 /* ss001.301: additions */
862    SDisplay(0, buf);
863 #ifdef SS_LOGGER_SUPPORT 
864    SWrtLogBuf(buf);
865 #endif /* SS_LOGGER_SUPPORT  */
866
867    return ROK;
868
869 } /* end of SPrint */
870
871 \f
872 /*
873 *
874 *       Fun:   SError
875 *
876 *       Desc:  Invoked by layer when an unrecoverable
877 *              software error is detected. This function should
878 *              never return.
879 *
880 *       Ret:   None
881 *
882 *       Notes: None
883 *
884 *       File:  ss_gen.c
885 *
886 */
887 S16 SError
888 (
889 Seq seq,                    /* sequence */
890 Reason reason               /* reason */
891 )
892 {
893    S16 ret;
894    DateTime dt;
895    Txt errBuf[256];
896
897    SGetDateTime(&dt);
898    sprintf(errBuf, "\n\ndate: %02d/%02d/%04d time: %02d:%02d:%02d\n",
899           (int)dt.month,(int)dt.day,(int)dt.year + 1900,
900           (int)dt.hour,(int)dt.min,(int)dt.sec);
901    SPrint(errBuf);
902
903
904    ret = ssdError(seq, reason);
905
906
907    return (ret);
908 }
909
910 \f
911 /*
912 *
913 *       Fun:   SLogError
914 *
915 *       Desc:  Invoked by layer to log an error.
916 *
917 *       Ret:   None
918 *
919 *       Notes: None
920 *
921 *       File:  ss_gen.c
922 *
923 */
924 Void SLogError
925 (
926 Ent ent,                    /* Calling layer's entity id */
927 Inst inst,                  /* Calling layer's instance id */
928 ProcId procId,              /* Calling layer's processor id */
929 Txt *file,                  /* file name where error occured */
930 S32 line,                   /* line in file where error occured */
931 ErrCls errCls,              /* error class */
932 ErrCode errCode,            /* layer unique error code */
933 ErrVal errVal,              /* error value */
934 Txt *errDesc                /* description of error */
935 )
936 {
937    DateTime dt;
938    Txt errBuf[512];
939
940
941 /*ss014.301: SSI-4GMX related changes*/
942 #ifndef SS_4GMX_LCORE
943    SGetDateTime(&dt);
944    sprintf(errBuf, "\n\ndate: %02d/%02d/%04d time: %02d:%02d:%02d\n",
945           (int)dt.month,(int)dt.day,(int)dt.year + 1900,
946           (int)dt.hour,(int)dt.min,(int)dt.sec);
947    SDisplay(0,errBuf);
948 #endif
949
950 /* ss001.301: additions */
951 #ifdef SS_LOGGER_SUPPORT 
952    SWrtLogBuf(errBuf);
953 #endif /* SS_LOGGER_SUPPORT  */
954
955    ssdLogError(ent, inst, procId, file, line,
956                      errCls, errCode, errVal, errDesc);
957
958
959    return;
960 }
961
962 /* ss029.103: modification: 
963    SFndProcId function is not supported with multiple procIds */ 
964 #ifndef SS_MULTIPLE_PROCS
965 \f
966 /*
967 *
968 *       Fun:   SFndProcId
969 *
970 *       Desc:  This function finds the local processor ID.
971 *
972 *       Ret:   local processor id
973 *
974 *       Notes:
975 *
976 *       File:  ss_gen.c
977 *
978 */
979 ProcId SFndProcId(void)
980 {
981
982    return (osCp.procId);
983 } /* end of SFndProcId */
984
985 \f
986 /*
987 *
988 *       Fun:   SSetProcId
989 *
990 *       Desc:  This function stores the local processor ID.
991 *
992 *       Ret:   Void
993 *
994 *       Notes: 
995 *
996 *       File:  ss_gen.c
997 *
998 */
999 Void SSetProcId(ProcId procId)
1000 {
1001
1002    osCp.procId = procId;
1003
1004    return;
1005 }
1006
1007 #endif /* SS_MULTIPLE_PROCS */
1008
1009 /* ss029.103: addition: New SSI functions with multiple proc support */ 
1010 #ifdef SS_MULTIPLE_PROCS
1011 \f
1012 /*
1013 *
1014 *       Fun:   SGetProcIdIdx
1015 *
1016 *       Desc:  This function finds index of procId in the process id table 
1017 *
1018 *       Ret:   ROK/RFAILED 
1019 *
1020 *       Notes: 
1021 *
1022 *       File:  ss_gen.c
1023 *
1024 */
1025 uint16_t SGetProcIdIdx(ProcId proc)
1026 {
1027    uint16_t i;
1028    uint16_t idx;
1029
1030    idx = SS_HASH_IDX(proc);
1031
1032    for (i = idx; i < SS_MAX_PROCS; i++)
1033       if (osCp.procLst.procId[i] == proc)
1034          return i;
1035
1036    /* search upto idx */
1037    for (i = 0; i < idx; i++)
1038       if (osCp.procLst.procId[i] == proc)
1039          return i;
1040
1041    return (SS_INV_PROCID_IDX);
1042 } /* SGetProcIdIdx */
1043
1044 \f
1045 /*
1046 *
1047 *       Fun:   SInsProcId
1048 *
1049 *       Desc:  This function inserts procId in the process id table 
1050 *
1051 *       Ret:   ROK/RFAILED 
1052 *
1053 *       Notes: 
1054 *
1055 *       File:  ss_gen.c
1056 *
1057 */
1058 static S16 SInsProcId(ProcId proc)
1059 {
1060    uint16_t i;
1061    uint16_t idx;
1062
1063
1064    idx = SS_HASH_IDX(proc);
1065
1066    for (i = idx; i < SS_MAX_PROCS; i++)
1067       if (osCp.procLst.procId[i] == SS_INV_PROCID)
1068       {
1069          osCp.procLst.procId[i] = proc;
1070          osCp.procLst.free--;
1071          return ROK;
1072       }
1073
1074    /* search for free entry upto idx */
1075    for (i = 0; i < idx; i++)
1076       if (osCp.procLst.procId[i] == SS_INV_PROCID)
1077       {
1078          osCp.procLst.procId[i] = proc;
1079          osCp.procLst.free--;
1080          return ROK;
1081       }
1082
1083    return RFAILED;
1084 } /* SInsProcId */
1085
1086 \f
1087 /*
1088 *
1089 *       Fun:   SRemProcId
1090 *
1091 *       Desc:  This function inserts procId in the process id table 
1092 *
1093 *       Ret:   ROK/RFAILED 
1094 *
1095 *       Notes: 
1096 *
1097 *       File:  ss_gen.c
1098 *
1099 */
1100 static S16 SRemProcId(ProcId proc)
1101 {
1102    uint16_t i;
1103    uint16_t idx;
1104
1105
1106    idx = SS_HASH_IDX(proc);
1107
1108    for (i = idx; i < SS_MAX_PROCS; i++)
1109       if (osCp.procLst.procId[i] == proc)
1110       {
1111          osCp.procLst.procId[i] = SS_INV_PROCID;
1112          osCp.procLst.free++;
1113          return ROK;
1114       }
1115
1116    /* search upto idx */
1117    for (i = 0; i < idx; i++)
1118       if (osCp.procLst.procId[i] == proc)
1119       {
1120          osCp.procLst.procId[i] = SS_INV_PROCID;
1121          osCp.procLst.free++;
1122          return ROK;
1123       }
1124
1125    return RFAILED;
1126 } /* SRemProcId */
1127
1128 \f
1129 /*
1130 *
1131 *       Fun:   SLockOsCp
1132 *
1133 *       Desc:  This function locks OsCp 
1134 *
1135 *       Ret:   ROK/RFAILED 
1136 *
1137 *       Notes: 
1138 *
1139 *       File:  ss_gen.c
1140 *
1141 */
1142 static S16 SLockOsCp(void)
1143 {
1144    S16 ret;
1145
1146
1147    ret = SLock(&osCp.sTskTblLock);
1148    if (ret != ROK)
1149    {
1150       SSLOGERROR(ERRCLS_DEBUG, ESS016, ERRZERO,
1151                      "Could not lock system task table");
1152       return RFAILED;
1153    }
1154
1155    SS_ACQUIRE_ALL_SEMA(&osCp.tTskTblSem, ret);
1156    if (ret != ROK)
1157    {
1158
1159 #if (ERRCLASS & ERRCLS_DEBUG)
1160       SSLOGERROR(ERRCLS_DEBUG, ESS017, ERRZERO,
1161                      "Could not lock TAPA task table");
1162 #endif
1163
1164       if ( SUnlock(&osCp.sTskTblLock) != ROK)
1165       {
1166 #if (ERRCLASS & ERRCLS_DEBUG)
1167          SSLOGERROR(ERRCLS_DEBUG, ESS018, ERRZERO,
1168                       "Could not give the Semaphore");
1169          return RFAILED;
1170 #endif
1171       }
1172
1173       return RFAILED;
1174    }
1175
1176    return ROK;
1177
1178 } /* SLockOsCp */
1179
1180 \f
1181 /*
1182 *
1183 *       Fun:   SULockOsCp
1184 *
1185 *       Desc:  This function locks OsCp 
1186 *
1187 *       Ret:   ROK/RFAILED 
1188 *
1189 *       Notes: 
1190 *
1191 *       File:  ss_gen.c
1192 *
1193 */
1194 static S16 SULockOsCp(Void)
1195 {
1196
1197    /* unlock the table */
1198    SS_RELEASE_ALL_SEMA(&osCp.tTskTblSem);
1199
1200    if ( SUnlock(&osCp.sTskTblLock) != ROK)
1201    {
1202 #if (ERRCLASS & ERRCLS_DEBUG)
1203       SSLOGERROR(ERRCLS_DEBUG, ESS019, ERRZERO,
1204                       "Could not give the Semaphore");
1205       return RFAILED;
1206 #endif
1207    }
1208
1209    return ROK;
1210
1211 } /* SULockOsCp */
1212
1213
1214 \f
1215 /*
1216 *
1217 *       Fun:   SAddProcIdLst
1218 *
1219 *       Desc:  This function adds given proc ids to the list 
1220 *
1221 *       Ret:   ROK/RFAILED 
1222 *
1223 *       Notes: 
1224 *
1225 *       File:  ss_gen.c
1226 *
1227 */
1228 S16 SAddProcIdLst(uint16_t numPIds,ProcId *pIdLst)
1229 {
1230    uint16_t i;
1231    S16 ret;
1232
1233
1234 #if (ERRCLASS & ERRCLS_INT_PAR)
1235    /* range check */
1236    if (numPIds > SS_MAX_PROCS)
1237    {
1238       SSLOGERROR(ERRCLS_INT_PAR, ESS020, ERRZERO, "number of proc Ids exceeds\
1239  limit");
1240       return RFAILED;
1241    }
1242
1243    /* find if the entry exist in the table */
1244    for (i = 0; i < numPIds; i++)
1245    {
1246       if (pIdLst[i] == SS_INV_PROCID)
1247       {
1248          SSLOGERROR(ERRCLS_INT_PAR, ESS021, ERRZERO, "Invalid proc Ids");
1249          return RFAILED;
1250       }
1251    }
1252
1253 #endif
1254    
1255    if (SLockOsCp() != ROK)
1256       return RFAILED;
1257
1258 #if (ERRCLASS & ERRCLS_INT_PAR)
1259    for (i = 0; i < numPIds; i++)
1260       if (SGetProcIdIdx(pIdLst[i]) != SS_INV_PROCID_IDX)
1261       {
1262          SSLOGERROR(ERRCLS_INT_PAR, ESS022, ERRZERO, "Duplicate proc id");
1263          (Void) SULockOsCp();
1264          return RFAILED;
1265       }
1266
1267    if (numPIds > osCp.procLst.free)
1268    {
1269       SSLOGERROR(ERRCLS_INT_PAR, ESS023, ERRZERO, "Total number of proc id \
1270 exceeds");
1271       (Void) SULockOsCp();
1272       return RFAILED;
1273    }
1274 #endif 
1275
1276    /* insert the entries in the table */
1277    ret = ROK;
1278
1279    for (i = 0; i < numPIds; i++)
1280    {
1281       if (SInsProcId(pIdLst[i]) == RFAILED)
1282       {
1283 #if (ERRCLASS & ERRCLS_DEBUG)
1284          SSLOGERROR(ERRCLS_DEBUG, ESS024, ERRZERO,
1285                       "Could not insert the proc id");
1286 #endif
1287          (Void) SULockOsCp();
1288          return RFAILED;
1289       }
1290    }
1291
1292    /* unlock the table */
1293    if (SULockOsCp() != ROK)
1294       return RFAILED;
1295
1296    return (ret);
1297 } /* SAddProcIdLst */
1298
1299 \f
1300 /*
1301 *
1302 *       Fun:   SRemProcIdLst
1303 *
1304 *       Desc:  This function adds given proc ids to the list 
1305 *
1306 *       Ret:   ROK/RFAILED 
1307 *
1308 *       Notes: 
1309 *
1310 *       File:  ss_gen.c
1311 *
1312 */
1313 S16 SRemProcIdLst(uint16_t numPIds,ProcId *pIdLst)
1314 {
1315    uint16_t i;
1316
1317
1318 #if (ERRCLASS & ERRCLS_INT_PAR)
1319    /* range check */
1320    if (numPIds > SS_MAX_PROCS)
1321       return RFAILED;
1322 #endif
1323
1324    if (SLockOsCp() != ROK)
1325       return RFAILED;
1326
1327    if (numPIds > (SS_MAX_PROCS - osCp.procLst.free))
1328    {
1329       (Void) SULockOsCp();
1330       return RFAILED;
1331    }
1332
1333    /* find if the entry exist in the table */
1334    for (i = 0; i < numPIds; i++)
1335    {
1336       if (SGetProcIdIdx(pIdLst[i]) == SS_INV_PROCID_IDX)
1337       {
1338          (Void) SULockOsCp();
1339          return RFAILED;
1340       }
1341    }
1342
1343    /* insert the entries in the table */
1344    for (i = 0; i < numPIds; i++)
1345       SRemProcId(pIdLst[i]);
1346
1347    if (SULockOsCp() != ROK)
1348       return RFAILED;
1349
1350    return ROK;
1351 } /* SRemProcIdLst */
1352
1353 \f
1354 /*
1355 *
1356 *       Fun:   SGetProcIdLst
1357 *
1358 *       Desc:  This function retrieves proc Id list 
1359 *
1360 *       Ret:   ROK/RFAILED 
1361 *
1362 *       Notes: 
1363 *
1364 *       File:  ss_gen.c
1365 *
1366 */
1367 S16 SGetProcIdLst(uint16_t *numPIds,ProcId *pIdLst)
1368 {
1369    uint16_t i;
1370    uint16_t count = 0;
1371
1372
1373 #if (ERRCLASS & ERRCLS_INT_PAR)
1374    if ((numPIds == NULLP) || (pIdLst == NULLP))
1375    {
1376       SSLOGERROR(ERRCLS_INT_PAR, ESS025, ERRZERO, "Invalid numPIds/pIdLst");
1377       return RFAILED;
1378    }
1379 #endif 
1380
1381    if (SLockOsCp() != ROK)
1382       return RFAILED;
1383
1384    for (i = 0; i < SS_MAX_PROCS; i++)
1385    {
1386       if (osCp.procLst.procId[i] != PROCNC)
1387          pIdLst[count++] = osCp.procLst.procId[i];
1388    }
1389
1390    *numPIds = count;
1391
1392    if (SULockOsCp() != ROK)
1393       return RFAILED;
1394
1395    if (count == 0)
1396       return RFAILED;
1397
1398    return ROK;
1399 } /* SGetProcIdLst */
1400
1401 \f
1402 /*
1403 *
1404 *       Fun:   SGetXxCb
1405 *
1406 *       Desc:  This function retrieves protocol layer control block for given proc,
1407 *              ent and inst IDs
1408 *
1409 *       Ret:   ROK/RFAILED 
1410 *
1411 *       Notes: 
1412 *
1413 *       File:  ss_gen.c
1414 *
1415 */
1416 S16 SGetXxCb
1417 (
1418 ProcId proc,
1419 Ent ent,
1420 Inst inst,
1421 Void **xxCb
1422 )
1423 {
1424    uint16_t procIdIdx;
1425    SsIdx idx;
1426
1427
1428 #if (ERRCLASS & ERRCLS_INT_PAR)
1429    if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) ||  (inst >= SS_MAX_INST))
1430    {
1431       SSLOGERROR(ERRCLS_INT_PAR, ESS026, ERRZERO, "Invalid proc/entity/instance");
1432       return RFAILED;
1433    }
1434 #endif 
1435    
1436    /* 
1437     * ss030.103: delete: locking/unlocking removed as it causes
1438     * deadlock/blockage in some cases
1439     */
1440
1441    procIdIdx = SGetProcIdIdx(proc);
1442
1443    if (procIdIdx == SS_INV_PROCID_IDX)
1444    {
1445 #if (ERRCLASS & ERRCLS_INT_PAR)
1446       SSLOGERROR(ERRCLS_INT_PAR, ESS027, ERRZERO, "Could not get proc table idx");
1447 #endif
1448       return RFAILED;
1449    }
1450
1451    idx = osCp.tTskIds[procIdIdx][ent][inst];
1452    if (idx == SS_TSKNC)
1453    {
1454       return RFAILED;
1455    }
1456
1457    /* update the CB */
1458    *xxCb = osCp.tTskTbl[idx].xxCb;
1459    /*ss032.103 added a check for NULLP */
1460    if (*xxCb == NULLP)
1461       return RFAILED;
1462
1463    return ROK;
1464 } /* SGetXxCb */
1465
1466 #endif /* SS_MULTIPLE_PROCS */
1467
1468 /* ss001.301: additions */
1469 #ifdef SS_HISTOGRAM_SUPPORT 
1470 /*
1471 *
1472 *       Fun:   SFillEntIds
1473 *
1474 *       Desc:  It is static data base contains all entity Ids of tapa task.
1475 *              This Data base is used to find the entity id using two letter
1476 *              prifix product code.
1477 *
1478 *       Ret:   ROK/RFAILED
1479 *
1480 *       Notes:
1481 *
1482 *       File:  ss_gen.c
1483 *
1484 */
1485 S16 SFillEntIds(Void)
1486 {
1487
1488    uint8_t entInfo[26][26] = {
1489                            /* A      B      C      D      E      F      G      H      I      J      K  *
1490                               L      M      N      O      P      Q      R      S      T      U      V  *
1491                               W      X      Y      Z */
1492                            {ENTAA, ENTAB, ENTAC, ENTNC, ENTAE, ENTAF, ENTNC, ENTAH, ENTNC, ENTNC, ENTNC,
1493                   /* A */   ENTAL, ENTAM, ENTNC, ENTNC, ENTAP, ENTAQ, ENTAR, ENTAS, ENTNC, ENTAU, ENTNC,
1494                             ENTAW, ENTNC, ENTNC, ENTNC},
1495
1496                            /* A      B      C      D      E      F      G      H      I      J      K  *
1497                               L      M      N      O      P      Q      R      S      T      U      V  *
1498                               W      X      Y      Z */
1499                            {ENTNC, ENTNC, ENTNC, ENTBD, ENTNC, ENTNC, ENTNC, ENTNC, ENTBI, ENTNC, ENTNC,
1500                   /* B */   ENTNC, ENTBM, ENTNC, ENTNC, ENTNC, ENTNC, ENTBR, ENTBS, ENTNC, ENTNC, ENTBV,
1501                             ENTBW, ENTNC, ENTNC, ENTNC},
1502                            /* A      B      C      D      E      F      G      H      I      J      K  *
1503                               L      M      N      O      P      Q      R      S      T      U      V  *
1504                               W      X      Y      Z */
1505                            {ENTNC, ENTNC, ENTCC, ENTNC, ENTNC, ENTNC, ENTNC, ENTCH, ENTNC, ENTNC, ENTNC,
1506                   /* C */   ENTCL, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTCS, ENTNC, ENTCU, ENTCV,
1507                             ENTNC, ENTNC, ENTNC, ENTNC},
1508                            /* A      B      C      D      E      F      G      H      I      J      K  *
1509                               L      M      N      O      P      Q      R      S      T      U      V  *
1510                               W      X      Y      Z */
1511                            {ENTNC, ENTDB, ENTNC, ENTNC, ENTNC, ENTNC, ENTDG, ENTNC, ENTDI, ENTNC, ENTDK,
1512                   /* D */   ENTNC, ENTDM, ENTDN, ENTNC, ENTDP, ENTNC, ENTNC, ENTNC, ENTDT, ENTDU, ENTDV,
1513                             ENTNC, ENTNC, ENTNC, ENTNC},
1514                            /* A      B      C      D      E      F      G      H      I      J      K  *
1515                               L      M      N      O      P      Q      R      S      T      U      V  *
1516                               W      X      Y      Z */
1517                            {ENTNC, ENTNC, ENTNC, ENTNC, ENTEC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1518                   /* E */   ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTER, ENTES, ENTNC, ENTNC, ENTEV,
1519                             ENTNC, ENTNC, ENTNC, ENTNC},
1520                            /* A      B      C      D      E      F      G      H      I      J      K  *
1521                               L      M      N      O      P      Q      R      S      T      U      V  *
1522                               W      X      Y      Z */
1523                            {ENTFA, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1524                   /* F */   ENTNC, ENTFM, ENTFN, ENTNC, ENTFP, ENTNC, ENTFR, ENTNC, ENTNC, ENTFU, ENTNC,
1525                             ENTFW, ENTNC, ENTNC, ENTNC},
1526                            /* A      B      C      D      E      F      G      H      I      J      K  *
1527                               L      M      N      O      P      Q      R      S      T      U      V  *
1528                               W      X      Y      Z */
1529                            {ENTGA, ENTGB, ENTGC, ENTGD, ENTGE, ENTGF, ENTGG, ENTGH, ENTGI, ENTNC, ENTNC,
1530                   /* G */   ENTGL, ENTGM, ENTGN, ENTGO, ENTGP, ENTNC, ENTGR, ENTGS, ENTGT, ENTGU, ENTNC,
1531                             ENTGW, ENTGX, ENTGY, ENTGZ},
1532                            /* A      B      C      D      E      F      G      H      I      J      K  *
1533                               L      M      N      O      P      Q      R      S      T      U      V  *
1534                               W      X      Y      Z */
1535                            {ENTNC, ENTNC, ENTHC, ENTNC, ENTHE, ENTNC, ENTHG, ENTNC, ENTHI, ENTNC, ENTNC,
1536                   /* H */   ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTHR, ENTHS, ENTNC, ENTHU, ENTNC,
1537                             ENTNC, ENTNC, ENTNC, ENTNC},
1538                            /* A      B      C      D      E      F      G      H      I      J      K  *
1539                               L      M      N      O      P      Q      R      S      T      U      V  *
1540                               W      X      Y      Z */
1541                            {ENTIA, ENTIB, ENTNC, ENTID, ENTIE, ENTNC, ENTNC, ENTNC, ENTII, ENTNC, ENTNC,
1542                   /* I */   ENTNC, ENTIM, ENTIN, ENTNC, ENTNC, ENTIQ, ENTNC, ENTIS, ENTIT, ENTIU, ENTNC,
1543                             ENTIW, ENTIX, ENTNC, ENTNC},
1544                            /* A      B      C      D      E      F      G      H      I      J      K  *
1545                               L      M      N      O      P      Q      R      S      T      U      V  *
1546                               W      X      Y      Z */
1547                            {ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1548                   /* J */   ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1549                             ENTNC, ENTNC, ENTNC, ENTNC},
1550                            /* A      B      C      D      E      F      G      H      I      J      K  *
1551                               L      M      N      O      P      Q      R      S      T      U      V  *
1552                               W      X      Y      Z */
1553                            {ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1554                   /* K */   ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1555                             ENTRLC, ENTNC, ENTNC, ENTNC},
1556                            /* A      B      C      D      E      F      G      H      I      J      K  *
1557                               L      M      N      O      P      Q      R      S      T      U      V  *
1558                               W      X      Y      Z */
1559                            {ENTLA, ENTLB, ENTLC, ENTLD, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTLK,
1560                   /* L */   ENTNC, ENTLM, ENTLN, ENTNC, ENTNC, ENTNC, ENTLR, ENTNC, ENTLT, ENTLU, ENTLV,
1561                             ENTNC, ENTLX, ENTNC, ENTNC},
1562                            /* A      B      C      D      E      F      G      H      I      J      K  *
1563                               L      M      N      O      P      Q      R      S      T      U      V  *
1564                               W      X      Y      Z */
1565                            {ENTMA, ENTNC, ENTMC, ENTMD, ENTME, ENTNC, ENTMG, ENTNC, ENTNC, ENTNC, ENTMK,
1566                   /* M */   ENTML, ENTMM, ENTNC, ENTNC, ENTNC, ENTNC, ENTMR, ENTMS, ENTMT, ENTMU, ENTMV,
1567                             ENTMW, ENTMX, ENTNC, ENTMZ},
1568                            /* A      B      C      D      E      F      G      H      I      J      K  *
1569                               L      M      N      O      P      Q      R      S      T      U      V  *
1570                               W      X      Y      Z */
1571                            {ENTNC, ENTNC, ENTNC, ENTND, ENTNC, ENTNF, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1572                   /* N */   ENTNC, ENTNM, ENTNC, ENTNC, ENTNP, ENTNC, ENTNC, ENTNS, ENTNC, ENTNC, ENTNV,
1573                             ENTNW, ENTNC, ENTNC, ENTNC},
1574                            /* A      B      C      D      E      F      G      H      I      J      K  *
1575                               L      M      N      O      P      Q      R      S      T      U      V  *
1576                               W      X      Y      Z */
1577                            {ENTNC, ENTNC, ENTNC, ENTOD, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1578                   /* O */   ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1579                             ENTNC, ENTNC, ENTNC, ENTNC},
1580                            /* A      B      C      D      E      F      G      H      I      J      K  *
1581                               L      M      N      O      P      Q      R      S      T      U      V  *
1582                               W      X      Y      Z */
1583                            {ENTPA, ENTNC, ENTNC, ENTPD, ENTNC, ENTNC, ENTNC, ENTPH, ENTNC, ENTNC, ENTNC,
1584                   /* P */   ENTPL, ENTNC, ENTPN, ENTNC, ENTPN, ENTPQ, ENTPR, ENTNC, ENTNC, ENTPU, ENTPV,
1585                             ENTNC, ENTNC, ENTNC, ENTNC},
1586                            /* A      B      C      D      E      F      G      H      I      J      K  *
1587                               L      M      N      O      P      Q      R      S      T      U      V  *
1588                               W      X      Y      Z */
1589                            {ENTNC, ENTNC, ENTQC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTQI, ENTNC, ENTNC,
1590                   /* Q */   ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1591                             ENTQW, ENTNC, ENTNC, ENTNC},
1592                            /* A      B      C      D      E      F      G      H      I      J      K  *
1593                               L      M      N      O      P      Q      R      S      T      U      V  *
1594                               W      X      Y      Z */
1595                            {ENTRA, ENTNC, ENTNC, ENTRD, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1596                   /* R */   ENTRL, ENTRM, ENTRN, ENTNC, ENTRP, ENTNC, ENTRR, ENTNC, ENTRT, ENTRU, ENTNC,
1597                             ENTNC, ENTRX, ENTRY, ENTNC},
1598                            /* A      B      C      D      E      F      G      H      I      J      K  *
1599                               L      M      N      O      P      Q      R      S      T      U      V  *
1600                               W      X      Y      Z */
1601                            {ENTSA, ENTSB, ENTSC, ENTSD, ENTSE, ENTSF, ENTSG, ENTSH, ENTSI, ENTNC, ENTNC,
1602                   /* S */   ENTNC, ENTSM, ENTSN, ENTSO, ENTSP, ENTNC, ENTSR, ENTSS, ENTST, ENTSU, ENTSV,
1603                             ENTNC, ENTNC, ENTNC, ENTSZ},
1604                            /* A      B      C      D      E      F      G      H      I      J      K  *
1605                               L      M      N      O      P      Q      R      S      T      U      V  *
1606                               W      X      Y      Z */
1607                            {ENTNC, ENTNC, ENTTC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1608                   /* T */   ENTNC, ENTTM, ENTNC, ENTNC, ENTTP, ENTNC, ENTNC, ENTTS, ENTTT, ENTTU, ENTNC,
1609                             ENTNC, ENTNC, ENTNC, ENTNC},
1610                            /* A      B      C      D      E      F      G      H      I      J      K  *
1611                               L      M      N      O      P      Q      R      S      T      U      V  *
1612                               W      X      Y      Z */
1613                            {ENTNC, ENTNC, ENTNC, ENTUD, ENTNC, ENTNC, ENTNC, ENTUH, ENTNC, ENTNC, ENTNC,
1614                   /* U */   ENTUL, ENTUM, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTUS, ENTNC, ENTNC, ENTNC,
1615                             ENTNC, ENTNC, ENTNC, ENTUZ},
1616                            /* A      B      C      D      E      F      G      H      I      J      K  *
1617                               L      M      N      O      P      Q      R      S      T      U      V  *
1618                               W      X      Y      Z */
1619                            {ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTVF, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1620                   /* V */   ENTNC, ENTVM, ENTNC, ENTVO, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTVU, ENTNC,
1621                             ENTNC, ENTNC, ENTNC, ENTNC},
1622                            /* A      B      C      D      E      F      G      H      I      J      K  *
1623                               L      M      N      O      P      Q      R      S      T      U      V  *
1624                               W      X      Y      Z */
1625                            {ENTNC, ENTNC, ENTWC, ENTWD, ENTNC, ENTNC, ENTNC, ENTNC, ENTWI, ENTNC, ENTNC,
1626                   /* W */   ENTNC, ENTNC, ENTWN, ENTNC, ENTNC, ENTNC, ENTNC, ENTWS, ENTNC, ENTWU, ENTNC,
1627                             ENTNC, ENTNC, ENTNC, ENTNC},
1628                            /* A      B      C      D      E      F      G      H      I      J      K  *
1629                               L      M      N      O      P      Q      R      S      T      U      V  *
1630                               W      X      Y      Z */
1631                            {ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTXG, ENTNC, ENTXI, ENTNC, ENTNC,
1632                   /* X */   ENTNC, ENTXM, ENTXN, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTXU, ENTNC,
1633                             ENTNC, ENTXX, ENTXY, ENTNC},
1634                            /* A      B      C      D      E      F      G      H      I      J      K  *
1635                               L      M      N      O      P      Q      R      S      T      U      V  *
1636                               W      X      Y      Z */
1637                            {ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1638                   /* Y */   ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1639                             ENTNC, ENTNC, ENTNC, ENTNC},
1640                            /* A      B      C      D      E      F      G      H      I      J      K  *
1641                               L      M      N      O      P      Q      R      S      T      U      V  *
1642                               W      X      Y      Z */
1643                            {ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1644                   /* Z */   ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
1645                             ENTNC, ENTNC, ENTNC, ENTNC}
1646                         };
1647
1648    /*ss013.301 :Adding  TRC MACRO*/
1649             memcpy(osCp.entId, entInfo, sizeof(entInfo));
1650
1651    return ROK;
1652 } /* SFillEntIds */
1653
1654
1655 /*
1656 *
1657 *       Fun:   SGetEntInd 
1658 *
1659 *       Desc:  This function gives the entity Id depending in the 
1660 *              file name. This function uses the first two letter
1661 *              of file name to find the entity id. 
1662 *              
1663 *              
1664 *
1665 *       Ret:   ROK              OK
1666 *              RFAILED          Region not registered
1667 *
1668 *
1669 */
1670 S16 SGetEntInd(Ent *entId,uint8_t *fileName)
1671 {
1672
1673
1674         uint8_t   *letter = NULLP;
1675    /* ss002.301 Additions */
1676         S8   *strippedName = NULLP;
1677         uint8_t   count = 0;
1678         uint8_t   tempIdx = 0;
1679         uint8_t   firstIdx = 0;
1680         uint8_t   secondIdx = 0;
1681
1682
1683    /* ss002.301 Additions */
1684         if ((strippedName = strrchr((const char *)fileName, '/')))
1685         {
1686            fileName = (uint8_t *)strippedName + 1;
1687         }
1688
1689         if(fileName[0] =='l' && fileName[3] == '.')
1690    { 
1691            /* Usally layer manager interface files starts
1692                  * with l. so leave the first letter and take
1693                  * other two letter.
1694                  * Eg. Layer manger inteface file name for TUCL is lhi.c.
1695                  * so here we leave l and we take hi to get the entity Id. */
1696       letter = ++fileName; 
1697         } 
1698         else
1699         { 
1700            letter = fileName;
1701            /* Handle exceptional file names */
1702            switch(letter[0])
1703            {
1704               case 'g':
1705                      if (letter[1] == 'g' && letter[2] == 'u')
1706                      {
1707                         *entId = ENTGT;
1708                              return ROK;
1709                      }
1710                    default: 
1711                              break;
1712
1713            }
1714         }
1715
1716
1717    /* here first two charactes of file name should be alphabets.
1718          * if any one of the letter is non alphabet then we return ENTNC 
1719          * as an entity Id */
1720    /* Eg. In fileName l4_ptui.c, second letter is numeral. so we consider
1721          * this file belogs to entity Id ENTNC. */
1722         for(count = 0; count < 2; count++)
1723         {
1724                 /* ss002.301 - Optimizations */
1725             if(letter[count] < 'a' || letter[count] > 'z')
1726             {
1727                    *entId = ENTNC;
1728                    return ROK;
1729             }
1730             else
1731             {
1732                    tempIdx = letter[count] - 'a';
1733             }
1734                  if(count == 0)
1735                  {
1736                         firstIdx = tempIdx;
1737                  }/* End of if */
1738                  else
1739                  {
1740                         secondIdx = tempIdx;
1741                  }/* End of else */
1742         } /* End of for */
1743         /* First two letter of file name are alphabets the get the 
1744          * entity id from the static data base which is loaded in sFillEntIds() */
1745         *entId = osCp.entId[firstIdx][secondIdx];
1746         return ROK;
1747 } /* SGetEntInd */
1748
1749 #endif /* SS_HISTOGRAM_SUPPORT */
1750 #ifdef SS_LOCK_SUPPORT
1751 /* ss002.301 Readwrite lock additions */
1752 /*
1753 *
1754 *       Fun:   SLockNew 
1755 *
1756 *       Desc:  This function is used to aquire the read write lock
1757 *
1758 *       Ret:   ROK   OK
1759 *
1760 *       Notes:
1761 *
1762 *       File:  mt_ss.c
1763 *
1764 */
1765 S16 SLockNew(SLockInfo *lockId,uint8_t lockType)
1766 {
1767    S16    retVal = ROK;
1768
1769
1770   if((retVal = ssdLockNew(lockId, lockType)) != ROK) 
1771   {
1772     SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SLockNew(): Failed to aquire the lock\n");
1773     return RFAILED;
1774   }
1775    return ROK;
1776 }
1777
1778 /*
1779 *
1780 *       Fun:   SInitLockNew 
1781 *
1782 *       Desc:  This function is used to aquire the read write lock
1783 *
1784 *       Ret:   ROK   OK
1785 *
1786 *       Notes:
1787 *
1788 *       File:  mt_ss.c
1789 *
1790 */
1791 S16 SInitLockNew(SLockInfo *lockId,uint8_t  lockType)
1792 {
1793    S16    retVal = ROK;
1794
1795
1796   if((retVal = ssdInitLockNew(lockId, lockType)) != ROK) 
1797   {
1798     SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SInitLockNew(): Initialization of lock Failed\n");
1799     return RFAILED;
1800   }
1801    return ROK;
1802 }
1803
1804 /*
1805 *
1806 *       Fun:   SUnlockNew 
1807 *
1808 *       Desc:  This function is used to Unlock the read write lock 
1809 *
1810 *       Ret:   ROK   OK
1811 *
1812 *       Notes:
1813 *
1814 *       File:  mt_ss.c
1815 *
1816 */
1817 S16 SUnlockNew(SLockInfo *lockId,uint8_t lockType)
1818 {
1819    S16    retVal = ROK;
1820
1821
1822   if((retVal = ssdUnlockNew(lockId, lockType)) != ROK) 
1823   {
1824     SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SUnlockNew(): Failed to release the lock\n");
1825     return RFAILED;
1826   }
1827    return ROK;
1828 }
1829
1830 /*
1831 *
1832 *       Fun:   SDestroyLockNew 
1833 *
1834 *       Desc:  This function is used to destroy the read write lock 
1835 *
1836 *       Ret:   ROK   OK
1837 *
1838 *       Notes:
1839 *
1840 *       File:  mt_ss.c
1841 *
1842 */
1843 S16 SDestroyLockNew(SLockInfo *lockId,uint8_t lockType)
1844 {
1845    S16    retVal = ROK;
1846
1847
1848   if((retVal = ssdDestroyLockNew(lockId, lockType)) != ROK) 
1849   {
1850     SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SDestroyLockNew(): Failed to destroy the lock\n");
1851     return RFAILED;
1852   }
1853    return ROK;
1854 }
1855 #endif /* SS_LOCK_SUPPORT */
1856
1857 #ifdef SSI_STATIC_MEM_LEAK_DETECTION
1858 /* Static memory leak detection changes */
1859 static uint32_t StaticMemLeakAge;
1860 static uint32_t StaticMemLeakIntCount = 1;
1861
1862 void PrintStaticMemAllocInfo(StaticMemAllocInfo* memAllocInfo, FILE *opFile)
1863 {
1864    int i;
1865
1866    fprintf(opFile, "Current Time = %ld\n",StaticMemLeakAge);
1867
1868    for(i = 1; i < MAX_MEM_ALLOCATIONS; i++)
1869    {
1870       if(memAllocInfo->allocations[i].ptr)
1871       {
1872          fprintf(opFile, "p = %p f = %s l = %ld s = %ld a = %ld\n",
1873                           memAllocInfo->allocations[i].ptr, 
1874                           memAllocInfo->allocations[i].file, 
1875                           memAllocInfo->allocations[i].lineNo, 
1876                           memAllocInfo->allocations[i].size, 
1877                           memAllocInfo->allocations[i].age);
1878       }
1879    }
1880
1881    fclose(opFile);
1882 }
1883
1884 void InitializeStaticMemAllocInfo(StaticMemAllocInfo* memAllocInfo)
1885 {
1886    uint32_t i;
1887    /* index 0 is not used; nextIdx as 0 means end of list */
1888    memAllocInfo->nextFreeIdx = 1;
1889
1890    for(i = 1; i < MAX_MEM_ALLOCATIONS; i++)
1891    {
1892       memAllocInfo->allocations[i].listInfo.nextIdx = i + 1;
1893       memAllocInfo->allocations[i].ptr = 0;
1894    }
1895
1896    /* override the last one to point to 0 meaning end of list */
1897    memAllocInfo->allocations[MAX_MEM_ALLOCATIONS - 1].listInfo.nextIdx = 0;
1898 }
1899
1900 uint32_t GetNextFreeIdx(StaticMemAllocInfo * memAllocInfo)
1901 {
1902    uint32_t toBeReturned = memAllocInfo->nextFreeIdx;
1903
1904    uint32_t newNextFreeIdx = memAllocInfo->allocations[memAllocInfo->nextFreeIdx].listInfo.nextIdx;
1905
1906    if(newNextFreeIdx == 0 || newNextFreeIdx >= MAX_MEM_ALLOCATIONS)
1907    {
1908       printf("\nSomething wrong in GetNextFreeIdx newNextIdx = %ld\n",newNextFreeIdx);
1909    }
1910
1911    memAllocInfo->nextFreeIdx = newNextFreeIdx;
1912    
1913    return toBeReturned;
1914 }
1915
1916 #define CRASH_ENB {int *p = 0; *p = 100;}
1917 void FreeIdx(uint8_t* ptr, uint32_t idx, StaticMemAllocInfo* memAllocInfo,uint32_t size, char* file, uint32_t line)
1918 {
1919    if(idx == 0 || idx >= MAX_MEM_ALLOCATIONS)
1920    {
1921       printf("Something wrong in FreeIdx... idx = %ld called from %s:%ld\n",idx,file,line);
1922       CRASH_ENB
1923    }
1924    /*printf("FreeIdx... idx = %d nexFree = %d\n",idx, memAllocInfo->nextFreeIdx);*/
1925    memAllocInfo->allocations[idx].listInfo.nextIdx = memAllocInfo->nextFreeIdx;
1926    if((ptr != memAllocInfo->allocations[idx].ptr) ||
1927       (size != memAllocInfo->allocations[idx].size))
1928    {
1929 #ifdef XEON_SPECIFIC_CHANGES
1930 CRASH_ENB
1931 #endif   
1932       
1933       printf("\nFreeing wrong ptr stored = %p trying to free %p freeing size (%ld)"
1934             "allocated size(%ld) from %s:%ld\n",
1935               memAllocInfo->allocations[idx].ptr, 
1936               ptr,
1937               size,
1938               memAllocInfo->allocations[idx].size,
1939               file,
1940               line);
1941       printf("\nAllocation was done from %s:%ld\n",memAllocInfo->allocations[idx].file, memAllocInfo->allocations[idx].lineNo);
1942       printf("\n***********************************************************\n");
1943       CRASH_ENB
1944    }
1945
1946    memAllocInfo->allocations[idx].ptr = 0;
1947
1948    memAllocInfo->nextFreeIdx = idx;
1949 }
1950
1951
1952 void LogForStaticMemLeak(StaticMemAllocInfo* memAllocInfo, char* file, uint32_t line, uint32_t size, void* ptr, uint32_t idx)
1953 {
1954
1955    memAllocInfo->allocations[idx].file = file;
1956    memAllocInfo->allocations[idx].lineNo = line;
1957    memAllocInfo->allocations[idx].size = size;
1958    memAllocInfo->allocations[idx].ptr = ptr;
1959    memAllocInfo->allocations[idx].age = StaticMemLeakAge;
1960
1961    if(StaticMemLeakIntCount++ % 256 == 0)
1962    {
1963       StaticMemLeakAge++;
1964    }
1965 }
1966
1967 void InitializeForStaticMemLeak()
1968 {
1969    int i;
1970
1971    StaticMemLeakFileArr[0] = fopen("region0.log","w");
1972    StaticMemLeakFileArr[1] = fopen("region1.log","w");
1973    StaticMemLeakFileArr[2] = fopen("region2.log","w");
1974    StaticMemLeakFileArr[3] = fopen("region3.log","w");
1975
1976    if(StaticMemLeakFileArr[0] == NULL ||
1977          StaticMemLeakFileArr[1] == NULL ||
1978          StaticMemLeakFileArr[2] == NULL ||
1979          StaticMemLeakFileArr[3] == NULL)
1980    {
1981       int *p = 0;
1982       printf("\nCould not open files for Static Mem Leak detection logging :( crashing...\n");
1983       *p = 100;
1984    }
1985
1986    for(i = 0; i < 4; i++)
1987    {
1988       InitializeStaticMemAllocInfo(&SMemLeakInfo[i]);
1989    }
1990 }
1991
1992 void DumpStaticMemLeakFiles()
1993 {
1994    int i;
1995
1996    for(i = 0; i < 4; i++)
1997    {
1998       PrintStaticMemAllocInfo(&SMemLeakInfo[i], StaticMemLeakFileArr[i]);
1999    }
2000 }
2001 /* Static memory leak detection changes */
2002 #endif
2003
2004 /*
2005  *
2006  *       Fun:   ssRegMainThread
2007  *
2008  *       Desc:  This function is used to add the memory region
2009  *              mapping for the main thread.
2010  *
2011  *       Ret:   VOID (Always successful)
2012  *
2013  *       Notes:
2014  *
2015  *       File: mt_ss.c
2016  *
2017  */
2018 S16 SReInitTmr(void)
2019 {
2020    uint8_t ret = ROK;
2021    Txt prntBuf[PRNTSZE];
2022
2023    sprintf(prntBuf, "\n SReInitTmr(): ReStarting the Tmr\n");
2024    SDisplay(1,prntBuf);
2025    ret = ssdReInitTmr();
2026    if (ret != ROK)
2027    {
2028        /*ss012.301 : Fix log related issue to suite MT and NS implementations*/
2029     SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SReInitTmr(): Failed to Restart the Tmr\n");
2030     return RFAILED;
2031    }
2032    return ROK;
2033 }
2034
2035 /*
2036  *
2037  *       Fun:   SGetConfigPath 
2038  *
2039  *       Desc:  This function is used to Get config files path
2040  *
2041  *       Ret:   S8* config file Path
2042  *
2043  *       Notes:
2044  *
2045  *       File: ss_gen.c
2046  *
2047  */
2048 S8* SGetConfigPath(Void)
2049 {
2050    return osCp.configFilePath;
2051 }
2052
2053 /**********************************************************************
2054          End of file
2055  **********************************************************************/