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