FAPI Slot Indication Changes
[o-du/l2.git] / src / cm / cm_lib.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**
20
21      Name:     common library functions
22   
23      Type:     C source file
24   
25      Desc:     Common functions that are implemented in
26                both a portable and a performance-efficient manner. These
27                functions are selected based on the operating system.
28
29      File:     cm_lib.c
30
31 *********************************************************************21*/
32 \f
33 /***********************************************************************
34  * This file provides memory and string library functions implemented in
35  * one of two ways:
36  *
37  *     1. portable: does not assume library support for any of the functions
38  *                  needed.
39  *
40  *     2. using environment specific: this uses existing library
41  *        functions and is therefore, for an environment where such
42  *        functionality is available and , a more desirable choice!
43  *
44  *  The following functions are available in this file:
45  *
46  *       1. cmMemcpy: copies specified number of octets from one memory
47  *          location to another.
48  *       2. cmMemcmp: compares specified number of octets at one memory
49  *          locaton with the same number from another.
50  *       3. cmMemset: sets specified number of octets starting at given
51  *          memory location with the given value.
52  *       4. cmStrCmp: compares two strings, until the '\0' character is
53  *          encountered.
54  *       5. cmStrncmp: compares two strings, until \0 is encountered or
55  *          until the specified length is exceeded.
56  *       6. cmStrlen: finds length of a string until the \0 character.
57  *
58  *  The following flags are used in this file:
59  *
60  *     1. DONT_USE_SYS_LIB: If defined, this will compile in the portable
61  *        versions of each function in this file. This overrides all other
62  *        flags defined in this file.
63  *
64  *  For the SOLARIS environment:
65  *
66  *     The functionality defined in this file is generally available as library
67  *     functions in the native operating systems' libraries. We have provided
68  *     the functionality using the SOLARIS libraries, in this file.
69  *
70  *     If you want to take advantage of these library functions, all you need
71  *     to do is the following:
72  *
73  *     1. Do not turn on the DONT_USE_SYS_LIB flag.
74  *     2. Turn on the SUNOS51 flag.
75  *
76  *     This, in turn, turns on the following flags
77  *
78  *        1. MEMCPY_AVAIL  : maps cmMemcpy to C library function memcpy
79  *        2. MEMCMP_AVAIL  : maps cmMemcmp to C library function memcmp
80  *        3. MEMSET_AVAIL  : maps cmMemset to C library function memset
81  *        4. STRCMP_AVAIL  : maps cmStrcmp to Strings library function strcmp
82  *        5. STRNCMP_AVAIL : maps cmStrncmp to Strings library function strncmp
83  *        5. STRLEN_AVAIL  : maps cmStrlen to Strings library function strlen
84  *
85  *  For an environment different from SOLARIS:
86  *        
87  *    You will need to modify this file to do more or less the same stuff
88  *    as has been done for Solaris. i.e.
89  *
90  *     1. create a section inside the #ifndef DONT_USE_SYS_LIB section
91  *        similar to the #ifdef SUNOS51 section that:
92  *             1. includes system header files.
93  *             2. defines MEMCPY_AVAIL etc. as needed.
94  *     2. modify code inside functions to make use of the system library
95  *        primitive.
96  *     3. communicate your changes to Trillium so they can be incorporated
97  *        in the next release of this file
98  *
99  *  To add a new library primitive to this file:
100  *     1. it should be implemented in both a portable and environment specific
101  *        manner.
102  *     2. the portable implementation will not be the default
103  *     3. the portable version and the environment specif versions must be
104  *        enclosed in #ifdef XXXXXX_AVAIL
105  *                     <environment specific implementation>
106  *                    #else
107  *                     <portable implementation>
108  *                    #endif
109  *     4. It must be communicated to Trillium so it will be included in the
110  *        next release of the file.
111  *     5. Trillium engineering must have all changes approved by engineering
112  *        management.
113  *     6. Trillium reserves the right to not incorporate any changes submitted
114  *        by customers, if not approved by Trillium engineering management.
115  *     7. Trillium reserves the right to modify code submitted by customers to
116  *        enhance this file.
117  ************************************************************************/
118 \f
119 /*cm_lib_c_001.main_13 - Moved env files inclusion to the top*/
120 #include "envopt.h"        /* environment options */
121 #include "envind.h"        /* environment options */
122 #include "envdep.h"        /* environment options */
123
124 #ifndef DONT_USE_SYS_LIB
125
126 #include <stdio.h>
127 #include <ctype.h>
128 #include <stdlib.h>
129 #include <string.h>
130 #define MEMCPY_AVAIL   1
131 #define MEMCMP_AVAIL   1
132 #define MEMSET_AVAIL   1
133 #define STRCMP_AVAIL   1
134 #define STRNCMP_AVAIL  1
135 #define STRLEN_AVAIL   1
136
137 #else  /* DONT_USE_SYS_LIB */
138 #define MEMCPY_AVAIL   0
139 #define MEMCMP_AVAIL   0
140 #define MEMSET_AVAIL   0
141 #define STRCMP_AVAIL   0
142 #define STRNCMP_AVAIL  0
143 #define STRLEN_AVAIL   0
144 #endif /* not DONT_USE_SYS_LIB */
145
146
147  
148 #include "gen.h"           /* general layer */
149 #include "ssi.h"           /* system services */
150
151 /* header/extern include files (.x) */
152  
153 #include "gen.x"           /* general layer */
154 #include "ssi.x"           /* system services */
155 #include "cm_lib.x"        /* prototypes of primitives in this file */
156
157 #if (ERRCLASS & ERRCLS_DEBUG)
158
159 #define ECMLIBBASE     0
160 #define ECMLIB001      ECMLIBBASE + 1
161 #define ECMLIB002      ECMLIBBASE + 2
162 #define ECMLIB003      ECMLIBBASE + 3
163 #define ECMLIB004      ECMLIBBASE + 4
164 #define ECMLIB005      ECMLIBBASE + 5
165 #define ECMLIB006      ECMLIBBASE + 6
166 #define ECMLIB007      ECMLIBBASE + 7
167
168 #define CMLIBERR(_eCode, _eVal, _eDesc) \
169     SLogError ((Ent) 0, (Inst)0, (ProcId)0, __FILE__, __LINE__, \
170                (ErrCls)ERRCLS_DEBUG, (ErrCode)_eCode, (ErrVal) _eVal, \
171                (Txt *) _eDesc)
172 #else
173 #define CMLIBERR(_eCode, _eVal, _eDesc)
174 #endif
175
176 #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
177 EXTERN Data *startPtr128;
178 EXTERN Size regMemSize;
179 #endif
180 \f
181 /*
182 *
183 *       Fun:   cmMemcpy
184 *
185 *       Desc:  common primitive to copy a contiguous string of bytes
186 *              optimized for when memcpy is available. It uses memcpy
187 *              when available. Otherwise, copies in a 'for' loop.
188 *
189 *              sets "len" memory locations starting from "tgt" to the values
190 *              of corresponding memory locations starting from "src".
191 *
192 *       Ret:   pointer to target string
193 *
194 *       Notes: None
195 *
196 *       File:  cm_lib.c
197 *
198 */
199 #ifdef ANSI
200 PUBLIC U8 *cmMemcpy
201 (
202 U8           *tgt,
203 CONSTANT U8  *src,
204 PTR          len
205 )
206 #else
207 PUBLIC U8 *cmMemcpy(tgt, src, len)
208 U8           *tgt;
209 CONSTANT U8  *src;
210 PTR          len;
211 #endif
212 {
213    /*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
214    TRC2(cmMemcpy)
215
216 #ifdef MS_MBUF_CORRUPTION /* checking for valid memory address */
217 if ((tgt > startPtr128) && (tgt < (startPtr128+regMemSize)))
218 {
219    if ((*((U32 *)(tgt + 4)) == 0xDEADDEAD) || (*((U32 *)(tgt + 24)) == 0xDEADDEAD) ||
220       (*((U32 *)(tgt + 44)) == 0xDEADDEAD) || (*((U32 *)(tgt + 80)) == 0xDEADDEAD))
221    {
222       Data *crashPtr=NULLP;
223       *crashPtr = 9;
224    }
225 }
226 if ((src > startPtr128) && (src < (startPtr128+regMemSize)))
227 {
228    if ((*((U32 *)(src + 4)) == 0xDEADDEAD) || (*((U32 *)(src + 24)) == 0xDEADDEAD) ||
229       (*((U32 *)(src + 44)) == 0xDEADDEAD) || (*((U32 *)(src + 80)) == 0xDEADDEAD))
230    {
231       Data *crashPtr=NULLP;
232       *crashPtr = 9;
233    }
234 }
235 #endif 
236 #if (MEMCPY_AVAIL) /* memcpy is available */
237    RETVALUE((U8 *) memcpy((Void *)tgt, (CONSTANT Void *)src, (size_t)len));
238 #else
239    while (len--)
240       *tgt++ = *src++;
241
242    RETVALUE(tgt);
243 #endif /* MEMCPY_AVAIL */
244
245 } /* end of cmMemcpy */
246
247 \f
248 /*
249 *
250 *       Fun:   cmMemcmp
251 *
252 *       Desc:  common primitive to compare a contiguous string of bytes
253 *              optimized for when memcmp is available. It uses memcmp
254 *              when available. Otherwise, compares in a 'for' loop.
255 *
256 *       Ret:    < 0 => s1 < s2
257 *               > 0 => s1 > s2
258 *               = 0 => s1 = s2
259 *
260 *       Notes: None
261 *
262 *       File:  cm_lib.c
263 *
264 */
265 #ifdef ANSI
266 PUBLIC S16 cmMemcmp
267 (
268 CONSTANT U8     *s1,
269 CONSTANT U8     *s2,
270 PTR             len
271 )
272 #else
273 PUBLIC S16 cmMemcmp (s1, s2, len)
274 CONSTANT U8     *s1;
275 CONSTANT U8     *s2;
276 PTR             len;
277 #endif
278 {
279    /*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
280    TRC2(cmMemcmp)
281 #if MEMCMP_AVAIL /* memcmp is available */
282    RETVALUE((S16) memcmp((CONSTANT Void *)s1, (CONSTANT Void *)s2, (size_t)len));
283 #else  /* MEMCMP_AVAIL: memcmp is not available */
284    while (len--)
285    {
286       if (*s1 ^ *s2)
287          RETVALUE((S16) (*s1 - *s2));
288       s1++;
289       s2++;
290    }
291    RETVALUE(0);
292 #endif /* MEMCMP_AVAIL */
293 } /* end of cmMemcmp */
294
295 \f
296 /*
297 *
298 *       Fun:   cmMemset
299 *
300 *       Desc:  common primitive to set a contiguous string of bytes
301 *              with a specified value optimized for when memset is available.
302 *              It uses memset when available. Otherwise, uses a 'for' loop.
303 *
304 *              sets "len" memory locations starting from "str" to the value
305 *              "val".
306
307 *       Ret:   pointer to string
308 *
309 *       Notes: None
310 *
311 *       File:  cm_lib.c
312 *
313 */
314 #ifdef ANSI
315 PUBLIC U8 *cmMemset
316 (
317 U8           *str,
318 U8           val,
319 PTR          len
320 )
321 #else
322 PUBLIC U8 *cmMemset(str, val, len)
323 U8           *str;
324 U8           val;
325 PTR          len;
326 #endif
327 {
328    /*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
329    TRC2(cmMemset)
330 #if MS_MBUF_CORRUPTION /* checking for valid memory address */
331 if ((str > startPtr128) && (str < (startPtr128+regMemSize)))
332 {
333    if ((*((U32 *)(str + 4)) == 0xDEADDEAD) || (*((U32 *)(str + 24)) == 0xDEADDEAD) ||
334       (*((U32 *)(str + 44)) == 0xDEADDEAD) || (*((U32 *)(str + 80)) == 0xDEADDEAD))
335    {
336       Data *crashPtr=NULLP;
337       *crashPtr = 9;
338    }
339 }
340 #endif
341 #if (MEMSET_AVAIL) /* memset is available */
342    if (val==0)
343    {  
344       bzero((void *)str,(size_t)len);
345    }
346    else
347    {
348       memset((void *)str,val,(size_t) len);
349    }
350 #else  /* MEMSET_AVAIL: memset is not available */
351    while (len --)
352       *str++ = val;
353
354 #endif /* MEMSET_AVAIL */
355    RETVALUE(str);
356 } /* end of cmMemset */
357
358 \f
359 /*
360 *
361 *       Fun:   cmStrcmp
362 *
363 *       Desc:  common primitive to compare a contiguous string of characters
364 *              terminated by the '\0' character.
365 *
366 *              when strcmp is available, it uses that. otherwise, it
367 *              compares the strings using a for loop.
368 *
369 *              The following is the "strcmp" description from the SunOS 5.4
370 *              man-page. cmStrcmp follows this.
371 *
372 *             strcmp() compares two strings byte-by-byte, according to the
373 *             ordering  of  your  machine's  character  set.  The function
374 *             returns an integer greater than, equal to, or less  than  0,
375 *             if the string pointed to by s1 is greater than, equal to, or
376 *             less than the string pointed to by s2 respectively. The sign
377 *             of  a non-zero return value is determined by the sign of the
378 *             difference between the values of the  first  pair  of  bytes
379 *             that  differ in the strings being compared.
380 *
381 *             Bytes following a null byte are not compared.
382 *
383 *
384 *       Ret:    < 0 => s1 < s2
385 *               > 0 => s1 > s2
386 *               = 0 => s1 = s2
387 *
388 *       Notes: None
389 *
390 *       File:  cm_lib.c
391 *
392 */
393 #ifdef ANSI
394 PUBLIC S16 cmStrcmp
395 (
396 CONSTANT U8 *s1,
397 CONSTANT U8 *s2
398 )
399 #else
400 PUBLIC S16 cmStrcmp (s1, s2)
401 CONSTANT U8 *s1;
402 CONSTANT U8 *s2;
403 #endif
404 {
405    /*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
406    TRC2(cmStrcmp)
407 #if (STRCMP_AVAIL)
408    RETVALUE(strcmp((CONSTANT S8 *)s1, (CONSTANT S8 *)s2));
409 #else   /* STRCMP_AVAIL */
410   
411    while (*s1 && *s2)
412    {
413       if (*s1 ^ *s2)
414          RETVALUE(*s1 - *s2);
415       s1++;
416       s2++;
417    }
418    RETVALUE(0);
419 #endif      /* strcmp is not available */
420
421 } /* end of cmStrcmp */
422
423
424 \f
425 /*
426 *
427 *       Fun:   cmStrncmp
428 *
429 *       Desc:  common primitive to compare a contiguous string of characters
430 *              terminated by the '\0' character.
431 *              
432 *              when strncmp is available, it uses that. otherwise, it
433 *              compares the strings using a for loop.
434 *              
435 *              The following is the "strncmp" description from the SunOS 5.4
436 *              man-page. cmStrncmp follows this.
437 *
438 *              strcmp() compares two strings byte-by-byte, according to the
439 *              ordering  of  your  machine's  character  set.  The function
440 *              returns an integer greater than, equal to, or less  than  0,
441 *              if the string pointed to by s1 is greater than, equal to, or
442 *              less than the string pointed to by s2 respectively. The sign
443 *              of  a non-zero return value is determined by the sign of the
444 *              difference between the values of the  first  pair  of  bytes
445 *              that  differ in the strings being compared.  strncmp() makes
446 *              the same comparison but looks  at  a  maximum  of  n  bytes.
447 *              Bytes following a null byte are not compared.
448 *
449 *       Ret:    < 0 => s1 < s2
450 *               > 0 => s1 > s2
451 *               = 0 => s1 = s2
452 *
453 *       Notes: None
454 *
455 *       File:  cm_lib.c
456 *
457 */
458 #ifdef ANSI
459 PUBLIC S16 cmStrncmp
460 (
461 CONSTANT U8  *s1,
462 CONSTANT U8  *s2,
463 MsgLen       len /* cm_lib_c_001.main_12: Changing from S16 to MsgLen.*/
464 )
465 #else
466 PUBLIC S16 cmStrncmp (s1, s2, len)
467 CONSTANT U8  *s1;
468 CONSTANT U8  *s2;
469 MsgLen       len;
470 #endif
471 {
472    /*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
473    TRC2(cmStrncmp)
474 #if (STRNCMP_AVAIL)
475    RETVALUE(strncmp((CONSTANT S8 *)s1, (CONSTANT S8 *)s2, (size_t) len));
476 #else   /* STRNCMP_AVAIL */
477   
478    while (*s1 && *s2 && len--)
479    {
480       if (*s1 ^ *s2)
481          RETVALUE(*s1 - *s2);
482       s1++;
483       s2++;
484    }
485    RETVALUE(0);
486 #endif   /* strncmp is not available */
487 } /* end of cmStrncmp */
488
489 \f
490 /*
491 *
492 *       Fun:   cmStrlen
493 *
494 *       Desc:  common primitive to compute the length of a NULL terminated
495 *              string.
496 *              
497 *              when strlen is available, it uses that. otherwise, it
498 *              inspects the string using a for loop.
499 *              
500 *              The following is the "strlen" description from the SunOS 5.4
501 *              man-page. cmStrlen follows this.
502 *
503 *              strlen() returns the number of bytes in s, not including the
504 *              terminating null character.
505 *
506 *       Ret:   length of string
507 *
508 *       Notes: None
509 *
510 *       File:  cm_lib.c
511 *
512 */
513 #ifdef ANSI
514 PUBLIC MsgLen cmStrlen
515 (
516 CONSTANT U8 *s
517 )
518 #else
519 /* cm_lib_c_001.main_12: Changing from S16 to MsgLen.*/
520 PUBLIC MsgLen cmStrlen (s)
521 CONSTANT U8 *s;
522 #endif
523 {
524 #if (STRLEN_AVAIL)
525    /*cm_lib_c_001.main_15 : Fix for warning due to mixed declation*/
526    TRC2(cmStrlen)
527    RETVALUE((MsgLen)strlen((CONSTANT S8 *)s));
528 #else   /* STRLEN_AVAIL */
529    MsgLen i;
530   
531    /*cm_lib_c_001.main_15 : Fix for warning due to mixed declation*/
532    TRC2(cmStrlen)
533
534    for (i = 0; *s; i++, s++);
535    RETVALUE(i);
536 #endif   /* strlen is not available */
537 } /* end of cmStrlen */
538
539 /**********************************************************************
540          End of file
541 **********************************************************************/