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