[Task-ID: ODUHIGH-485] Memory Leak Detector Tool
[o-du/l2.git] / src / 5gnrrlc / rlc_stats.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
19 /**********************************************************************
20  
21     Name:  
22  
23     Type:   C include file
24  
25     Desc:   
26  
27     File:  rlc_stats.c
28  
29 **********************************************************************/
30
31 /* header (.h) include files */
32 #include "common_def.h"
33 #include "lkw.h"           /* LKW defines */
34 #include "ckw.h"           /* CKW defines */
35 #include "kwu.h"           /* KWU defines */
36 #include "rgu.h"           /* RGU defines */
37 #include "rlc_err.h"        /* RLC error options */
38 #include "rlc_env.h"        /* RLC environment options */
39
40 /* extern (.x) include files */
41 #include "lkw.x"           /* LKW */
42 #include "ckw.x"           /* CKW */
43 #include "kwu.x"           /* KWU */
44 #include "rgu.x"           /* RGU */
45
46 #ifdef TENB_STATS
47 #include "l2_tenb_stats.x"    /* Total EnodeB Stats declarations */
48 #endif
49
50 #include "rlc_utils.h"            /* RLC defines */
51 #include "rlc_ul.h"
52
53 #ifdef TENB_STATS
54 TSL2CellStatsCb* l2CellStats[L2_STATS_MAX_CELLS];
55 TSL2UeStatsCb*   l2UeStats[L2_STATS_MAX_UES];
56 CmLListCp        freeL2UeStatsLst; /*!< Free Pool of UE stats Blocks */
57 CmLListCp        inUseL2UeStatsLst;/*!< In Use Pool of UE stats Blocks */
58
59 /*
60 *
61 *       Fun:   TSL2AllocStatsMem
62 *
63 *       Desc:  Pre-Allocate Memory for L2 stats BLOCKs 
64 *
65 *       Ret:   
66 *
67 *       Notes: None
68 *
69 *
70 */
71 Void TSL2AllocStatsMem(Inst inst)
72 {
73    uint32_t cnt=0;
74    RlcCb *gCb;
75
76    gCb = RLC_GET_RLCCB(inst);
77    cmLListInit(&inUseL2UeStatsLst);     
78    cmLListInit(&freeL2UeStatsLst);      
79    for (cnt=0; cnt < L2_STATS_MAX_CELLS; cnt++)
80    {
81       if(NULL == l2CellStats[cnt])
82       {
83          RLC_ALLOC(gCb, l2CellStats[cnt], (Size)sizeof (TSL2CellStatsCb));
84          if(l2CellStats[cnt] == NULL)
85          {
86             DU_LOG("\nERROR  -->  RLC : STATS Unexpected MEM Alloc Failure\n");
87          }
88       }
89       memset(l2CellStats[cnt], 0x00, sizeof(TSL2CellStatsCb));
90    }
91
92    for (cnt=0; cnt < L2_STATS_MAX_UES; cnt++)
93    {
94       TSL2UeStatsCb *statsCb = l2UeStats[cnt];
95       if(NULL == statsCb)
96       {
97          RLC_ALLOC(gCb, statsCb, (Size)sizeof (TSL2UeStatsCb));
98          if(NULL == statsCb)        
99          {
100             DU_LOG("\nERROR  -->   RLC : STATS Unexpected MEM Alloc Failure at %d\n", (int)cnt);
101          }
102       }
103       memset(statsCb, 0x00, sizeof(TSL2UeStatsCb));
104       statsCb->lnk.node = (PTR)statsCb;
105       cmLListAdd2Tail(&freeL2UeStatsLst, &statsCb->lnk);
106       l2UeStats[cnt] = statsCb;
107    }
108
109    return;
110 }
111
112 /*
113  *
114  *       Fun:   TSL2AllocUeStatsBlk
115  *
116  *       Desc:  Assign Stats Block for this UE[RNTI] 
117  *
118  *       Ret:   
119  *
120  *       Notes: None
121  *
122  *
123  */
124 TSL2UeStatsCb* TSL2AllocUeStatsBlk (uint16_t rnti)
125 {
126    CmLList          *tmp = NULLP;
127    TSL2UeStatsCb  *statsCb = NULLP;
128
129    tmp = freeL2UeStatsLst.first;
130    if (tmp == NULLP)
131    {
132       DU_LOG("\nERROR  -->  RLC :  STATS Unexpected Mem BLK unavailable for UE %d\n", rnti);
133    }
134    cmLListDelFrm(&freeL2UeStatsLst, tmp);
135    statsCb = (TSL2UeStatsCb *)(tmp->node);
136    cmLListAdd2Tail(&inUseL2UeStatsLst, tmp);
137
138    statsCb->stats.rnti = (uint32_t)rnti;
139    statsCb->inUse = TRUE;
140
141    return (statsCb);
142 }
143
144 /*
145  *
146  *       Fun:   TSL2DeallocUeStatsBlk
147  *
148  *       Desc:  Deassign Stats Block for this UE[RNTI] 
149  *
150  *       Ret:   
151  *
152  *       Notes: None
153  *
154  *
155  */
156 Void TSL2DeallocUeStatsBlk(uint16_t rnti,TSL2UeStatsCb *statsCb)
157 {
158    statsCb->inUse = FALSE;
159    cmLListDelFrm(&inUseL2UeStatsLst, &statsCb->lnk);
160    freeL2UeStatsLst.crnt = freeL2UeStatsLst.first;
161    cmLListInsAfterCrnt(&freeL2UeStatsLst, &statsCb->lnk);
162
163    return;
164 }
165
166 /*
167  *
168  *       Fun:   TSL2AllocCellStatsBlk
169  *
170  *       Desc:  Assign Stats Block for this CELL[CELLID] 
171  *
172  *       Ret:   
173  *
174  *       Notes: None
175  *
176  *
177  */
178 TSL2CellStatsCb* TSL2AllocCellStatsBlk(uint32_t cellId)
179 {
180    if (cellId != 1)
181    {
182       DU_LOG("\nERROR  -->  RLC : STATS Unexpected CellID = %d\n", (int)cellId);
183    }
184
185    return (l2CellStats[cellId-1]);
186 }
187
188 /*
189  *
190  *       Fun:   TSL2DeallocCellStatsBlk
191  *
192  *       Desc:  Deassign Stats Block for this CELL[CELLID] 
193  *
194  *       Ret:   
195  *
196  *       Notes: None
197  *
198  *
199  */
200 Void TSL2DeallocCellStatsBlk(uint32_t cellId)
201 {
202
203    return;
204 }
205
206 /*
207  *
208  *       Fun:   TSL2SendStatsToApp
209  *
210  *       Desc:  Collates and Sends STATS to Application 
211  *              Send UE STATS first. 10 UEs are grouped in one message.
212  *              Followed by CELL Stats. All CELLS are grouped in one msg.
213  *              At Reception of CELL stats APP assumes STATS reception cycle is complete.
214  *
215  *       Ret:   
216  *
217  *       Notes: None
218  *
219  *
220  */
221 Void TSL2SendStatsToApp(Pst    *pst, SuId   suId)
222 {
223    uint32_t idx;
224
225    for (idx = 0; idx < L2_STATS_MAX_UES; idx++)
226    {
227       TSL2UeStatsCb *statsCb = l2UeStats[idx];
228       uint32_t rnti;
229       if (statsCb->inUse != TRUE)
230       {
231          continue;
232       }
233       if (pst->selector == 0)
234       {
235          /* Loose Coupling */
236          TSInfPkSndL2UeStats(pst, suId, &statsCb->stats);
237       }
238       else
239       {
240 #ifdef PX
241          /* Tight Coupling */
242          TSInfHdlL2UeStatsInd(pst, suId, &statsCb->stats);
243 #endif
244       }
245       rnti = statsCb->stats.rnti;
246       memset(&statsCb->stats.nonPersistent, 0x00, sizeof(statsCb->stats.nonPersistent));
247       /* memset(&statsCb->stats, 0x00, sizeof(TSInfL2UeStats)); */
248       statsCb->stats.rnti = rnti;
249    }
250
251    /* Allocate mBuf for CELLSTATS */
252    for (idx = 0; idx < L2_STATS_MAX_CELLS; idx++)
253    {
254       TSL2CellStatsCb *statsCellCb = l2CellStats[idx];
255       uint32_t cellId;
256       if (pst->selector == 0)
257       {
258          /* Loose Coupling */
259          TSInfPkSndL2CellStats(pst, suId, l2CellStats[idx]);
260       }
261       else
262       {
263 #ifdef PX
264          /* Tight Coupling */
265          TSInfHdlL2CellStatsInd(pst, suId, l2CellStats[idx]);
266 #endif
267       }
268       cellId = statsCellCb->cellId;
269       memset(l2CellStats[idx], 0x00, sizeof(TSInfL2CellStats));
270       statsCellCb->cellId = cellId;
271    }
272    return;
273 }
274 #endif /* TENB_STATS */
275 /**********************************************************************
276   End of file
277  **********************************************************************/