src/mt/ss_mem.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 -- Memory management interface
  22
  23      Type:     C source file
  24
  25      Desc:     Implementation of the memory management interface.
  26
  27      File:     ss_mem.c
  28
  29 *********************************************************************21*/
  30
  31 \f
  32 /* header include files (.h) */
  33
  34 #include "envopt.h"        /* environment options */
  35 #include "envdep.h"        /* environment dependent */
  36 #include "envind.h"        /* environment independent */
  37
  38 #include "gen.h"           /* general layer */
  39 #include "ssi.h"           /* system services */
  40
  41 #include "ss_err.h"        /* errors */
  42 #include "ss_dep.h"        /* implementation-specific */
  43 #include "ss_queue.h"      /* queues */
  44 #include "ss_msg.h"        /* messaging */
  45 #include "ss_mem.h"        /* memory management interface */
  46 /*ss011.301 : RMI SSI specific includes*/
  47 #ifdef SS_RMIOS
  48 #include "uc_gen.h"        /* general */
  49 #else
  50 #include "ss_gen.h"        /* general */
  51 #endif
  52
  53
  54 #include "cm_mem.h"        /* common memory manager */
  55 #include "cm_llist.h"
  56 #include "cm_hash.h"
  57
  58 /* header/extern include files (.x) */
  59
  60 #include "gen.x"           /* general layer */
  61 #include "ssi.x"           /* system services */
  62
  63 #include "ss_dep.x"        /* implementation-specific */
  64 #include "ss_queue.x"      /* queues */
  65 /*ss011.301 : RMI SSI specific includes*/
  66 #ifdef SS_RMIOS
  67 #include "uc_task.x"       /* tasking */
  68 #include "uc_timer.x"      /* timers */
  69 #else
  70 #include "ss_task.x"       /* tasking */
  71 #include "ss_timer.x"      /* timers */
  72 #endif
  73 #include "ss_strm.x"       /* STREAMS */
  74 #include "ss_msg.x"        /* messaging */
  75 #include "ss_mem.x"        /* memory management interface */
  76 #include "ss_drvr.x"       /* driver tasks */
  77 /*ss011.301 : RMI SSI specific includes*/
  78 #ifdef SS_LOCKLESS_MEMORY
  79 #include "cm_llist.x"
  80 #include "cm_hash.x"
  81 #include "cm_mem_wl.x"        /* common memory manager */
  82 #else
  83 #include "cm_mem.x"        /* common memory manager */
  84 #endif /* SS_LOCKLESS_MEMORY */
  85 #ifdef SS_RMIOS
  86 #include "uc_gen.x"        /* general */
  87 #else
  88 #include "ss_gen.x"        /* general */
  89 #endif
  90 #include "cm_llist.x"
  91 #include "cm_hash.x"
  92
  93
  94 \f
  95 /*
  96 *     Interface functions
  97 */
  98
  99
 100 /*
 101 *
 102 *       Fun:   SRegDynRegion
 103 *
 104 *       Desc:  Registers a memory region.
 105 *
 106 *       Ret:   ROK      - ok
 107 *              RFAILED  - failed, general (optional)
 108 *
 109 *       Notes:
 110 *
 111 *       File:  ss_mem.c
 112 *
 113 */
 114 S16 SRegDynRegion
 115 (
 116 Region region,                  /* region ID */
 117 SRegInfo *regInfo               /* information about the region */
 118 )
 119 {
 120    S16 ret;
 121
 122 #if (ERRCLASS & ERRCLS_INT_PAR)
 123    /* validate region ID */
 124    if (region >= SS_MAX_REGS)
 125    {
 126       SSLOGERROR(ERRCLS_INT_PAR, ESS028, region, "Invalid region");
 127       return RFAILED;
 128    }
 129
 130    /* validate region info pointer */
 131    if (regInfo == NULLP)
 132    {
 133       SSLOGERROR(ERRCLS_INT_PAR, ESS029, ERRZERO, "Null pointer");
 134       return RFAILED;
 135    }
 136 #endif
 137
 138
 139    /* lock the region table */
 140    SS_ACQUIRE_ALL_SEMA(&osCp.regionTblSem, ret);
 141    if (ret != ROK)
 142    {
 143
 144 #if (ERRCLASS & ERRCLS_DEBUG)
 145       SSLOGERROR(ERRCLS_DEBUG, ESS030, (ErrVal) ret,
 146                   "Could not lock region table");
 147 #endif
 148
 149       return RFAILED;
 150    }
 151
 152
 153 #if (ERRCLASS & ERRCLS_INT_PAR)
 154    /* verify that this region is not registered */
 155    if (osCp.dynRegionTbl[region].used == TRUE)
 156    {
 157       SS_RELEASE_ALL_SEMA(&osCp.regionTblSem);
 158
 159       SSLOGERROR(ERRCLS_INT_PAR, ESS031, ERRZERO, "Region ID used");
 160       return RFAILED;
 161    }
 162 #endif
 163
 164
 165    /* fill in the region information */
 166    osCp.dynRegionTbl[region].used = TRUE;
 167    osCp.dynRegionTbl[region].regCb = regInfo->regCb;
 168    osCp.dynRegionTbl[region].flags = regInfo->flags;
 169    osCp.dynRegionTbl[region].start = regInfo->start;
 170    osCp.dynRegionTbl[region].size = regInfo->size;
 171    osCp.dynRegionTbl[region].alloc = regInfo->alloc;
 172    osCp.dynRegionTbl[region].free = regInfo->free;
 173    osCp.dynRegionTbl[region].ctl = regInfo->ctl;
 174
 175    osCp.numDynRegions++;
 176
 177
 178    /* unlock the region table */
 179    SS_RELEASE_ALL_SEMA(&osCp.regionTblSem);
 180
 181
 182    return ROK;
 183 }
 184
 185
 186
 187 \f
 188 /*
 189 *
 190 *       Fun:   SRegRegion
 191 *
 192 *       Desc:  Registers a memory region.
 193 *
 194 *       Ret:   ROK      - ok
 195 *              RFAILED  - failed, general (optional)
 196 *
 197 *       Notes:
 198 *
 199 *       File:  ss_mem.c
 200 *
 201 */
 202 S16 SRegRegion
 203 (
 204 Region region,                  /* region ID */
 205 SRegInfo *regInfo               /* information about the region */
 206 )
 207 {
 208    S16 ret;
 209
 210 #if (ERRCLASS & ERRCLS_INT_PAR)
 211    /* validate region ID */
 212    if (region >= SS_MAX_REGS)
 213    {
 214       SSLOGERROR(ERRCLS_INT_PAR, ESS028, region, "Invalid region");
 215       return RFAILED;
 216    }
 217
 218    /* validate region info pointer */
 219    if (regInfo == NULLP)
 220    {
 221       SSLOGERROR(ERRCLS_INT_PAR, ESS029, ERRZERO, "Null pointer");
 222       return RFAILED;
 223    }
 224 #endif
 225
 226
 227    /* lock the region table */
 228    SS_ACQUIRE_ALL_SEMA(&osCp.regionTblSem, ret);
 229    if (ret != ROK)
 230    {
 231
 232 #if (ERRCLASS & ERRCLS_DEBUG)
 233       SSLOGERROR(ERRCLS_DEBUG, ESS030, (ErrVal) ret,
 234                   "Could not lock region table");
 235 #endif
 236
 237       return RFAILED;
 238    }
 239
 240
 241 #if (ERRCLASS & ERRCLS_INT_PAR)
 242    /* verify that this region is not registered */
 243    if (osCp.regionTbl[region].used == TRUE)
 244    {
 245       SS_RELEASE_ALL_SEMA(&osCp.regionTblSem);
 246
 247       SSLOGERROR(ERRCLS_INT_PAR, ESS031, ERRZERO, "Region ID used");
 248       return RFAILED;
 249    }
 250 #endif
 251
 252
 253    /* fill in the region information */
 254    osCp.regionTbl[region].used = TRUE;
 255    osCp.regionTbl[region].regCb = regInfo->regCb;
 256    osCp.regionTbl[region].flags = regInfo->flags;
 257    osCp.regionTbl[region].start = regInfo->start;
 258    osCp.regionTbl[region].size = regInfo->size;
 259    osCp.regionTbl[region].alloc = regInfo->alloc;
 260    osCp.regionTbl[region].free = regInfo->free;
 261    osCp.regionTbl[region].ctl = regInfo->ctl;
 262
 263    osCp.numRegions++;
 264
 265
 266    /* unlock the region table */
 267    SS_RELEASE_ALL_SEMA(&osCp.regionTblSem);
 268
 269
 270    return ROK;
 271 }
 272
 273 \f
 274 /*
 275 *
 276 *       Fun:   SDeregRegion
 277 *
 278 *       Desc:  Deregisters a memory region.
 279 *
 280 *       Ret:   ROK      - ok
 281 *              RFAILED  - failed, general (optional)
 282 *
 283 *       Notes:
 284 *
 285 *       File:  ss_mem.c
 286 *
 287 */
 288 S16 SDeregRegion
 289 (
 290 Region region                   /* region ID */
 291 )
 292 {
 293    S16 ret;
 294
 295 #if (ERRCLASS & ERRCLS_INT_PAR)
 296    /* validate region ID */
 297    if (region >= SS_MAX_REGS)
 298    {
 299       SSLOGERROR(ERRCLS_INT_PAR, ESS032, region, "Invalid region");
 300       return RFAILED;
 301    }
 302 #endif
 303
 304
 305    /* lock the region table */
 306    SS_ACQUIRE_ALL_SEMA(&osCp.regionTblSem, ret);
 307    if (ret != ROK)
 308    {
 309
 310 #if (ERRCLASS & ERRCLS_DEBUG)
 311       SSLOGERROR(ERRCLS_DEBUG, ESS033, (ErrVal) ret,
 312                   "Could not lock region table");
 313 #endif
 314
 315       return RFAILED;
 316    }
 317
 318
 319 #if (ERRCLASS & ERRCLS_INT_PAR)
 320    /* check if this region is registered */
 321    if (osCp.regionTbl[region].used == FALSE)
 322    {
 323       SS_RELEASE_ALL_SEMA(&osCp.regionTblSem);
 324       SSLOGERROR(ERRCLS_INT_PAR, ESS034, region, "Region not registered");
 325       return RFAILED;
 326    }
 327 #endif
 328
 329
 330    /* empty the information about the region */
 331    osCp.regionTbl[region].used = FALSE;
 332    osCp.regionTbl[region].start = NULLP;
 333    osCp.regionTbl[region].size = 0;
 334    osCp.regionTbl[region].regCb = NULLP;
 335    osCp.regionTbl[region].flags = 0;
 336    osCp.regionTbl[region].alloc = NULLP;
 337    osCp.regionTbl[region].free = NULLP;
 338    osCp.regionTbl[region].ctl = NULLP;
 339
 340    osCp.numRegions--;
 341
 342
 343    /* unlock the region table */
 344    SS_RELEASE_ALL_SEMA(&osCp.regionTblSem);
 345
 346
 347    return ROK;
 348 }
 349
 350 \f
 351 /*
 352 *
 353 *       Fun:   SAlloc
 354 *
 355 *       Desc:  Allocates a block of memory of at least the specified
 356 *              size.
 357 *
 358 *       Ret:   ROK      - ok
 359 *              RFAILED  - failed, general (optional)
 360 *
 361 *       Notes:
 362 *
 363 *       File:  ss_mem.c
 364 *
 365 */
 366 /*ss003.301-gaurded under flag SS_FAP*/
 367 #ifndef SS_FAP
 368 /* ss001.301: Additions */
 369 #ifdef SS_HISTOGRAM_SUPPORT
 370 S16 SAlloc
 371 (
 372 Region region,                  /* region ID */
 373 Size *size,                     /* size of block required/allocated */
 374 uint32_t flags,                      /* allocation flags */
 375 Data **ptr,                      /* filled with pointer to block */
 376 uint32_t   line,
 377 uint8_t    *fileName,
 378 uint8_t    entId
 379 )
 380 #else
 381 #ifdef T2K_MEM_LEAK_DBG
 382 S16 SAllocNew
 383 (
 384 Region region,                  /* region ID */
 385 Size *size,                     /* size of block required/allocated */
 386 uint32_t flags,                      /* allocation flags */
 387 Data **ptr,                      /* filled with pointer to block */
 388 char* file,
 389 uint32_t line
 390 )
 391 #else
 392 S16 SAlloc
 393 (
 394 Region region,                  /* region ID */
 395 Size *size,                     /* size of block required/allocated */
 396 uint32_t flags,                      /* allocation flags */
 397 Data **ptr                      /* filled with pointer to block */
 398 )
 399 #endif
 400 #endif
 401 {
 402    S16 ret;
 403 /* ss001.301: Additions */
 404 #ifdef SS_HISTOGRAM_SUPPORT
 405    Bool hstReg = FALSE;
 406 #endif /* SS_HISTOGRAM_SUPPORT */
 407
 408
 409
 410
 411 #if (ERRCLASS & ERRCLS_INT_PAR)
 412    /* validate region ID */
 413    if (region >= SS_MAX_REGS)
 414    {
 415       SSLOGERROR(ERRCLS_INT_PAR, ESS035, region, "Invalid region");
 416       return RFAILED;
 417    }
 418 #endif
 419 #ifndef XEON_SPECIFIC_CHANGES
 420    /* Get the region which is assgined with this thread. The region was
 421     * stored in the osCp and is taken with respect to thread ID. This macro
 422     * is used only when SS_LOCKLESS_MEMORY flag is used and it overwrites
 423     * the region passed.
 424     */
 425    region = SS_GET_THREAD_MEM_REGION();
 426 #endif
 427 /* ss037.103 Removed the semaphore acquisition for performance enhancement */
 428 #ifndef SS_PERF
 429    /* acquire one semaphore, to protect against deregistration */
 430    SS_ACQUIRE_SEMA(&osCp.regionTblSem, ret);
 431    if (ret != ROK)
 432    {
 433
 434 #if (ERRCLASS & ERRCLS_DEBUG)
 435       SSLOGERROR(ERRCLS_DEBUG, ESS036, (ErrVal) ret,
 436                   "Could not lock region table");
 437 #endif
 438
 439       return RFAILED;
 440    }
 441
 442 #endif
 443 #if (ERRCLASS & ERRCLS_INT_PAR)
 444    /* verify that this region is present */
 445    if (osCp.regionTbl[region].used == FALSE)
 446    {
 447 /* ss037.103 Removed the semaphore operation for performance enhancement */
 448 #ifndef SS_PERF
 449 /* ss006.13: addition */
 450       if( SS_RELEASE_SEMA(&osCp.regionTblSem) != ROK)
 451       {
 452 #if (ERRCLASS & ERRCLS_DEBUG)
 453       SSLOGERROR(ERRCLS_DEBUG, ESS037, ERRZERO,
 454                   "Could not release the semaphore");
 455       return RFAILED;
 456 #endif
 457       }
 458 #endif
 459       SSLOGERROR(ERRCLS_INT_PAR, ESS038, region, "Region not registered");
 460       return RFAILED;
 461    }
 462 #endif
 463 /* ss001.301: Additions */
 464 #ifdef SS_HISTOGRAM_SUPPORT
 465    SGetHstGrmInfo(&entId, &hstReg);
 466    /* call the memory manager, to allocate this memory */
 467    /* ss036.103 - addition for passing memType as dynamic */
 468 #ifdef SSI_DEBUG_LEVEL1
 469    ret = (osCp.regionTbl[region].alloc)
 470                (osCp.regionTbl[region].regCb, size, flags, ptr,
 471                 SS_DYNAMIC_MEM_FLAG, line, fileName, entId, hstReg);
 472 #else
 473    ret = (osCp.regionTbl[region].alloc)
 474                (osCp.regionTbl[region].regCb, size, flags, ptr, line,
 475                 fileName, entId, hstReg);
 476 #endif /* SSI_DEBUG_LEVEL1 */
 477
 478 #else
 479
 480    /* call the memory manager, to allocate this memory */
 481 /* ss036.103 - addition for passing memType as dynamic */
 482 #ifdef SSI_DEBUG_LEVEL1
 483    ret = (osCp.regionTbl[region].alloc)
 484                (osCp.regionTbl[region].regCb, size, flags, ptr, SS_DYNAMIC_MEM_FLAG);
 485 #else
 486 #ifdef SS_LOCKLESS_MEMORY
 487 #ifdef T2K_MEM_LEAK_DBG
 488    ret = (osCp.dynRegionTbl[region].alloc)
 489                (osCp.dynRegionTbl[region].regCb, size, flags, ptr,file,line);
 490 #else
 491    ret = (osCp.dynRegionTbl[region].alloc)
 492                (osCp.dynRegionTbl[region].regCb, size, flags, ptr);
 493 #endif
 494 #else
 495 #ifdef T2K_MEM_LEAK_DBG
 496    ret = (osCp.regionTbl[region].alloc)
 497                (osCp.regionTbl[region].regCb, size, flags, ptr,file,line);
 498 #else
 499    ret = (osCp.regionTbl[region].alloc)
 500                (osCp.regionTbl[region].regCb, size, flags, ptr);
 501 #endif
 502 #endif /* SS_LOCKLESS_MEMORY */
 503 #endif /* SSI_DEBUG_LEVEL1 */
 504
 505 #endif /* SS_HISTOGRAM_SUPPORT */
 506
 507 /* ss037.103 Removed the semaphore operation for performance enhancement */
 508
 509 #ifndef SS_PERF
 510    /* release the semaphore we took */
 511 /* ss006.13: addition */
 512    if( SS_RELEASE_SEMA(&osCp.regionTblSem) != ROK)
 513    {
 514 #if (ERRCLASS & ERRCLS_DEBUG)
 515      SSLOGERROR(ERRCLS_DEBUG, ESS039, ERRZERO,
 516                   "Could not release the semaphore");
 517      return RFAILED;
 518 #endif
 519    }
 520 #endif
 521 /* ss036.103 - Addition to handle the memory trampling return value
 522 * This in turn can call SRegMemErrHdlr
 523 */
 524 #ifdef SSI_DEBUG_LEVEL1
 525     if (ret == RTRAMPLINGNOK)
 526     {
 527         SRegMemErrHdlr( region,  *ptr,  ret);
 528     }
 529 #endif /* SSI_DEBUG_LEVEL1 */
 530
 531    return (ret);
 532 }
 533
 534 \f
 535 /*
 536 *
 537 *       Fun:   SFree
 538 *
 539 *       Desc:  Frees a block of memory previously allocated by SAlloc().
 540 *
 541 *       Ret:   ROK      - ok
 542 *              RFAILED  - failed, general (optional)
 543 *
 544 *       Notes:
 545 *
 546 *       File:  ss_mem.c
 547 *
 548 */
 549 /* ss001.301: Additions */
 550 #ifdef SS_HISTOGRAM_SUPPORT
 551 S16 SFree
 552 (
 553 Region region,                  /* region ID */
 554 Data *ptr,                      /* pointer to the allocated block */
 555 Size size,                      /* size of block */
 556 uint32_t  line,
 557 uint8_t   *fileName,
 558 uint8_t   entId
 559 )
 560 #else
 561 #ifdef T2K_MEM_LEAK_DBG
 562 S16 SFreeNew
 563 (
 564 Region region,                  /* region ID */
 565 Data *ptr,                      /* pointer to the allocated block */
 566 Size size,                       /* size of block */
 567 char* file,
 568 uint32_t line
 569 )
 570 #else
 571 S16 SFree
 572 (
 573 Region region,                  /* region ID */
 574 Data *ptr,                      /* pointer to the allocated block */
 575 Size size                       /* size of block */
 576 )
 577 #endif
 578 #endif
 579 {
 580    S16 ret;
 581
 582 /* ss001.301: Additions */
 583 #ifdef SS_HISTOGRAM_SUPPORT
 584    Bool hstReg = FALSE;
 585 #endif /* SS_HISTOGRAM_SUPPORT */
 586
 587
 588
 589    /* Get the region which is assgined with this thread. The region was
 590     * stored in the osCp and is taken with respect to thread ID. This macro
 591     * is used only when SS_LOCKLESS_MEMORY flag is used and it overwrites
 592     * the region passed.
 593     */
 594 #ifdef XEON_SPECIFIC_CHANGES
 595    region = 0;
 596 #else
 597    region = SS_GET_THREAD_MEM_REGION();
 598 #endif
 599
 600 #if (ERRCLASS & ERRCLS_INT_PAR)
 601    /* validate region ID */
 602    if (region >= SS_MAX_REGS)
 603    {
 604       SSLOGERROR(ERRCLS_INT_PAR, ESS040, region, "Invalid region");
 605       return RFAILED;
 606    }
 607
 608 /* ss021.103 - Addition to validate size and ptr */
 609    if (size <= NULLD)
 610    {
 611       SSLOGERROR(ERRCLS_INT_PAR, ESS041, region, "Invalid size");
 612       return RFAILED;
 613    }
 614
 615    /* validate ptr */
 616    if (ptr == (Data *)NULLP)
 617    {
 618       SSLOGERROR(ERRCLS_INT_PAR, ESS042, region, "Invalid ptr");
 619       return RFAILED;
 620    }
 621
 622 #endif
 623 /* ss037.103 Removed the semaphore operation for performance enhancement */
 624
 625 #ifndef SS_PERF
 626    /* acquire one semaphore, to protect against deregistration */
 627    SS_ACQUIRE_SEMA(&osCp.regionTblSem, ret);
 628    if (ret != ROK)
 629    {
 630
 631 #if (ERRCLASS & ERRCLS_DEBUG)
 632       SSLOGERROR(ERRCLS_DEBUG, ESS043, (ErrVal) ret,
 633                   "Could not lock region table");
 634 #endif
 635
 636       return RFAILED;
 637    }
 638 #endif
 639 #if (ERRCLASS & ERRCLS_INT_PAR)
 640    /* verify that this region is around */
 641    if (osCp.regionTbl[region].used == FALSE)
 642    {
 643 #ifndef SS_PERF
 644 /* ss006.13: addition */
 645       if( SS_RELEASE_SEMA(&osCp.regionTblSem) != ROK)
 646       {
 647 #if (ERRCLASS & ERRCLS_DEBUG)
 648          SSLOGERROR(ERRCLS_DEBUG, ESS044, ERRZERO,
 649                   "Could not release the semaphore");
 650          return RFAILED;
 651 #endif
 652        }
 653 #endif
 654       SSLOGERROR(ERRCLS_INT_PAR, ESS045, region, "Region not registered");
 655       return RFAILED;
 656    }
 657 #endif
 658
 659 /* ss001.301: Additions */
 660 #ifdef SS_HISTOGRAM_SUPPORT
 661    SGetHstGrmInfo(&entId, &hstReg);
 662
 663    /* call the memory manager to free this memory */
 664    ret = (osCp.regionTbl[region].free)
 665            (osCp.regionTbl[region].regCb, ptr, size, line, fileName,
 666             entId, hstReg);
 667
 668 #else
 669
 670    /* call the memory manager to free this memory */
 671 #ifdef SS_LOCKLESS_MEMORY
 672 #ifdef T2K_MEM_LEAK_DBG
 673    ret = (osCp.dynRegionTbl[region].free)(osCp.dynRegionTbl[region].regCb, ptr, size,file,line);
 674 #else
 675    ret = (osCp.dynRegionTbl[region].free)(osCp.dynRegionTbl[region].regCb, ptr, size);
 676 #endif
 677 #else
 678 #ifdef T2K_MEM_LEAK_DBG
 679    ret = (osCp.regionTbl[region].free)(osCp.regionTbl[region].regCb, ptr, size,file,line);
 680 #else
 681    ret = (osCp.regionTbl[region].free)(osCp.regionTbl[region].regCb, ptr, size);
 682 #endif
 683 #endif /* SS_LOCKLESS_MEMORY */
 684
 685 #endif /* SS_HISTOGRAM_SUPPORT */
 686
 687 /* ss037.103 Removed the semaphore operation for performance enhancement */
 688
 689 #ifndef SS_PERF
 690    /* release the semaphore we took */
 691 /* ss006.13: addition */
 692    if( SS_RELEASE_SEMA(&osCp.regionTblSem) != ROK)
 693    {
 694 #if (ERRCLASS & ERRCLS_DEBUG)
 695       SSLOGERROR(ERRCLS_DEBUG, ESS046, ERRZERO,
 696                   "Could not release the semaphore");
 697       return RFAILED;
 698 #endif
 699     }
 700 #endif
 701 /* ss036.103 - changes to handle double free and trmapling return values
 702 * This in turn may invoke SRegMemErrHdlr
 703 */
 704 #ifdef SSI_DEBUG_LEVEL1
 705     /* handle the double free error here by calling the OS specific error handling function */
 706     if ((ret == RDBLFREE) || (ret == RTRAMPLINGNOK))
 707     {
 708         SRegMemErrHdlr( region,  ptr,  ret);
 709     }
 710 #endif /* SSI_DEBUG_LEVEL1 */
 711
 712    return (ret);
 713 }
 714 #endif /* SS_FAP */
 715
 716 #ifndef SS_FAP
 717 /* ss001.301: Additions */
 718 #ifdef SS_HISTOGRAM_SUPPORT
 719
 720 /*
 721 *
 722 *       Fun:  SHstGrmInfoShow
 723 *
 724 *       Desc:  This function displays the memory usage information
 725 *              per Tapa task, which are registerd during initialization.
 726 *
 727 *
 728 *       Ret:
 729 *
 730 *
 731 *       Notes: A Sample Output from the function
 732 *       Memory Histogram for the Tapa task = (Entity Id)117
 733 *       ------Region Id = 0-------
 734 *       -----------Bucket Id = 0-----------
 735 *
 736 *      File Name|   Line  | Bucket Alloc | Bytes Allocated | Bytes Wasted | Buckets Freed|Bytes Freed|
 737 *      lhi.c    |    413  |            4 |             512 |          224 |            0 |         0 |
 738 *      hi_acc1.c|    333  |            0 |               0 |            0 |            2 |       256 |
 739 *      hi_acc1.c|    209  |           13 |            1664 |          728 |            0 |         0 |
 740 *
 741 *       File:  mt_ss.c
 742 *
 743 */
 744 S16 SHstGrmInfoShow
 745 (
 746 Ent      *entId
 747 )
 748 {
 749     /*ss012.301 : Increased Buffer size to fix segmentation fault*/
 750     Txt                                         prntBuf[511];  /* Buffer to print on the console */
 751         uint16_t                                        ret = ROK;     /* return value */
 752         Ent                                     tapaTsk[SS_MAX_TTSKS]; /* List of tapa task */
 753         uint32_t                                        tskCnt = 0;   /* Tapa task Count */
 754         uint32_t                                        regCnt = 0;   /* Region count */
 755         uint32_t                                        bktCnt = 0;   /* Bucket count in each region */
 756         CmHstGrmHashListCp      *hashListCp = NULLP; /* Hash List ponter of bucket */
 757         uint32_t                  binCnt = 0;
 758         uint32_t                  entCnt = 0;
 759         CmMemEntries        *entry = NULLP;
 760         uint32_t                  blkSize = 0;
 761
 762
 763    memset(tapaTsk, ENTNC, sizeof(tapaTsk));
 764
 765    if(entId == NULLP)
 766         {
 767             /* If user is not asking for specific entity id then,
 768                   * Take Tapa task entity id from the osCp structure and
 769                   * print the histogram for all tapa task */
 770         ret = SGetTapaTskEntIds(tapaTsk);
 771         }/* End of if */
 772         else
 773         {
 774            /* If user asked for specific tapa task then print histogram
 775                  * for those tapa task */
 776                 for(tskCnt = 0; entId[tskCnt]; tskCnt++)
 777                 {
 778                         tapaTsk[tskCnt] = entId[tskCnt];
 779                 }/* end of for */
 780         }
 781    for (tskCnt = 0; tapaTsk[tskCnt] != ENTNC; tskCnt++)
 782         {
 783         sprintf(prntBuf, "\n\nMemory Histogram for the Tapa task = (Entity Id)%d\n", tapaTsk[tskCnt]);
 784         SPrint(prntBuf);
 785                 for (regCnt = 0; regCnt < osCp.numRegions; regCnt++)
 786                 {
 787
 788                         CmMmRegCb* regCb = (CmMmRegCb*)osCp.regionTbl[regCnt].regCb;
 789
 790                 sprintf(prntBuf, "------Region Id = %d-------\n", regCb->region);
 791                 SPrint(prntBuf);
 792          for (bktCnt = 0; bktCnt < regCb->numBkts; bktCnt++)
 793                         {
 794                                                  /* ss002.301 - Compilation fixes */
 795             /*ss013.301 Fix for compilation warnings  32/64 bit */
 796 #ifdef ALIGN_64BIT
 797                         sprintf(prntBuf, "-----------Bucket Id = %u-----------\n\n", bktCnt);
 798 #else
 799                         sprintf(prntBuf, "-----------Bucket Id = %lu-----------\n\n", bktCnt);
 800 #endif
 801                         SPrint(prntBuf);
 802                         sprintf(prntBuf, "File Name         |   Line  | Bucket Alloc | Bytes Allocated | Bytes Wasted | Buckets Freed|Bytes Freed|\n");
 803                         SPrint(prntBuf);
 804                            hashListCp = &(regCb->bktTbl[bktCnt].hstGrmHashListCp);
 805                            blkSize = regCb->bktTbl[bktCnt].size;
 806                            for(binCnt = 0; binCnt < CMM_HIST_MAX_MEM_BIN; binCnt++)
 807                                 {
 808                                         for (entCnt = 0; entCnt < hashListCp->hashList[binCnt].numOfEntries; entCnt++)
 809                                         {
 810                                             entry = &(hashListCp->hashList[binCnt].entries[entCnt]);
 811                                                  if(entry->entId == tapaTsk[tskCnt])
 812                                                  {
 813                                                  /* ss002.301 - Compilation fixes */
 814                          /*ss013.301 Fix for compilation warnings  32/64 bit */
 815 #ifdef ALIGN_64BIT
 816                                                         sprintf(prntBuf,
 817                                                            "%-18s|%7u  |%13u |%16u |%13u |%13u |%10u |\n",
 818                         entry->fileName, entry->line, entry->bucketAllocReq,
 819                                                                 (blkSize*entry->bucketAllocReq), entry->wastedBytes,
 820                                                                 entry->bucketFreeReq, (blkSize*entry->bucketFreeReq));
 821 #else
 822                                                         sprintf(prntBuf,
 823                                                            "%-18s|%7lu  |%13lu |%16lu |%13lu |%13lu |%10lu |\n",
 824                         entry->fileName, entry->line, entry->bucketAllocReq,
 825                                                                 (blkSize*entry->bucketAllocReq), entry->wastedBytes,
 826                                                                 entry->bucketFreeReq, (blkSize*entry->bucketFreeReq));
 827 #endif
 828                      SPrint(prntBuf);
 829                                                  }/* End of If */
 830                                         }/* end of for. Entry count */
 831                                 } /* End of for. Hash bin count */
 832                          }
 833
 834                         sprintf(prntBuf, "\n\n----------- Heap blocks -----------\n\n");
 835                         SPrint(prntBuf);
 836                         sprintf(prntBuf, "File Name         |   Line  | Heap Allocs  | Bytes Allocated | Bytes Wasted |  Heap Frees  |Bytes Freed|\n");
 837                         SPrint(prntBuf);
 838                            hashListCp = &(regCb->heapCb.heapHstGrmHashListCp);
 839                            for(binCnt = 0; binCnt < CMM_HIST_MAX_MEM_BIN; binCnt++)
 840                                 {
 841                                         for (entCnt = 0; entCnt < hashListCp->hashList[binCnt].numOfEntries; entCnt++)
 842                                         {
 843                                             entry = &(hashListCp->hashList[binCnt].entries[entCnt]);
 844                                                  if(entry->entId == tapaTsk[tskCnt])
 845                                                  {
 846                                                  /* ss002.301 - Compilation fixes */
 847                          /*ss013.301 Fix for compilation warnings  32/64 bit */
 848 #ifdef ALIGN_64BIT
 849                                                         sprintf(prntBuf,
 850                                                             "%-18s|%7u  |%13u |%16u |%13u |%13u |%10u |\n",
 851                      entry->fileName, entry->line, entry->bucketAllocReq,
 852                                                         entry->allocBytes, entry->wastedBytes,
 853                                                         entry->bucketFreeReq, entry->freedBytes);
 854 #else
 855                                                         sprintf(prntBuf,
 856                                                             "%-18s|%7lu  |%13lu |%16lu |%13lu |%13lu |%10lu |\n",
 857                      entry->fileName, entry->line, entry->bucketAllocReq,
 858                                                         entry->allocBytes, entry->wastedBytes,
 859                                                         entry->bucketFreeReq, entry->freedBytes);
 860 #endif
 861                      SPrint(prntBuf);
 862                                                  }/* End of If */
 863                                         }/* end of for. Entry count */
 864                                 } /* End of for. Hash bin count */
 865                  }/* End of for. Region Count */
 866         } /* End of for (Tapa task)*/
 867
 868
 869    /* Print the memory information used at common, sample and ssi files.
 870          we considerd common Sample file as invalid entity id. */
 871         sprintf(prntBuf, "\n\nMemory Histogram for the Tapa task = (Entity Id = ENTNC)%d\n", ENTNC);
 872         SPrint(prntBuf);
 873         for (regCnt = 0; regCnt < osCp.numRegions; regCnt++)
 874         {
 875                 CmMmRegCb* regCb = (CmMmRegCb*)osCp.regionTbl[regCnt].regCb;
 876
 877                 sprintf(prntBuf, "------Region Id = %d-------\n", regCb->region);
 878                 SPrint(prntBuf);
 879       for (bktCnt = 0; bktCnt < regCb->numBkts; bktCnt++)
 880                 {
 881                                                  /* ss002.301 - Compilation fixes */
 882             /*ss013.301 Fix for compilation warnings  32/64 bit */
 883 #ifdef ALIGN_64BIT
 884                         sprintf(prntBuf, "-----------Bucket Id = %u-----------\n\n", bktCnt);
 885 #else
 886                         sprintf(prntBuf, "-----------Bucket Id = %lu-----------\n\n", bktCnt);
 887 #endif
 888                         SPrint(prntBuf);
 889                         sprintf(prntBuf, "File Name         |   Line  | Bucket Alloc | Bytes Allocated | Bytes Wasted | Buckets Freed|Bytes Freed|\n");
 890                         SPrint(prntBuf);
 891                    hashListCp = &(regCb->bktTbl[bktCnt].hstGrmHashListCp);
 892                    blkSize = regCb->bktTbl[bktCnt].size;
 893                    for(binCnt = 0; binCnt < CMM_HIST_MAX_MEM_BIN; binCnt++)
 894                         {
 895                                 for (entCnt = 0; entCnt < hashListCp->hashList[binCnt].numOfEntries; entCnt++)
 896                                 {
 897                                     entry = &(hashListCp->hashList[binCnt].entries[entCnt]);
 898                                          if(entry->entId == tapaTsk[tskCnt])
 899                                          {
 900                                                  /* ss002.301 - Compilation fixes */
 901             /*ss013.301 Fix for compilation warnings  32/64 bit */
 902 #ifdef ALIGN_64BIT
 903                                                 sprintf(prntBuf, "%-18s|%7u  |%13u |%16u |%13u |%13u |%10u |\n",
 904                   entry->fileName, entry->line, entry->bucketAllocReq, (blkSize*entry->bucketAllocReq),
 905                                                 entry->wastedBytes, entry->bucketFreeReq, (blkSize*entry->bucketFreeReq));
 906 #else
 907                                                 sprintf(prntBuf, "%-18s|%7lu  |%13lu |%16lu |%13lu |%13lu |%10lu |\n",
 908                   entry->fileName, entry->line, entry->bucketAllocReq, (blkSize*entry->bucketAllocReq),
 909                                                 entry->wastedBytes, entry->bucketFreeReq, (blkSize*entry->bucketFreeReq));
 910 #endif
 911                   SPrint(prntBuf);
 912                                          }/* End of If */
 913                                 }/* end of for. Entry count */
 914                         } /* End of for. Hash bin count */
 915
 916                  }/* End of for. Bucket Count */
 917
 918                 sprintf(prntBuf, "\n\n----------- Heap blocks -----------\n\n");
 919                 SPrint(prntBuf);
 920                 sprintf(prntBuf, "File Name         |   Line  | Heap Allocs  | Bytes Allocated | Bytes Wasted |  Heap Frees  |Bytes Freed|\n");
 921                 SPrint(prntBuf);
 922                         hashListCp = &(regCb->heapCb.heapHstGrmHashListCp);
 923                         for(binCnt = 0; binCnt < CMM_HIST_MAX_MEM_BIN; binCnt++)
 924                         {
 925                                         for (entCnt = 0; entCnt < hashListCp->hashList[binCnt].numOfEntries; entCnt++)
 926                                         {
 927                                             entry = &(hashListCp->hashList[binCnt].entries[entCnt]);
 928                                                  if(entry->entId == tapaTsk[tskCnt])
 929                                                  {
 930                                                  /* ss002.301 - Compilation fixes */
 931                          /*ss013.301 Fix for compilation warnings  32/64 bit */
 932 #ifdef ALIGN_64BIT
 933                                                         sprintf(prntBuf,
 934                                                             "%-18s|%7u  |%13u |%16u |%13u |%13u |%10u |\n",
 935                      entry->fileName, entry->line, entry->bucketAllocReq,
 936                                                         entry->allocBytes, entry->wastedBytes,
 937                                                         entry->bucketFreeReq, entry->freedBytes);
 938 #else
 939                                                         sprintf(prntBuf,
 940                                                             "%-18s|%7lu  |%13lu |%16lu |%13lu |%13lu |%10lu |\n",
 941                      entry->fileName, entry->line, entry->bucketAllocReq,
 942                                                         entry->allocBytes, entry->wastedBytes,
 943                                                         entry->bucketFreeReq, entry->freedBytes);
 944 #endif
 945                      SPrint(prntBuf);
 946                                                  }/* End of If */
 947                                         }/* end of for. Entry count */
 948                         } /* End of for. Hash bin count */
 949
 950          }/* End of for. Region Count */
 951
 952    return ROK;
 953 }
 954
 955 #endif /* SS_HISTOGRAM_SUPPORT */
 956 #endif /* SS_FAP */
 957
 958 /**********************************************************************
 959          End of file
 960  **********************************************************************/