src/rlog/rl_rlog.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:     Radisys Logging Framework
  22      Type:     C source file
  23      Desc:     This file contains logging framework implementation.
  24      File:     rl_rlog.c
  25
  26 *********************************************************************21*/
  27 /**********************************************************************
  28  @ description: This is source file which has implementaion of logging
  29  framework.
  30 ************************************************************************/
  31
  32 #include "envopt.h"
  33 #include "envdep.h"
  34 #include "rl_interface.h"
  35
  36 #include <stdio.h>
  37 #include <unistd.h>
  38 #include <sys/socket.h>
  39 #include <sys/types.h>
  40 #include <sys/stat.h>
  41 #include <sys/resource.h>
  42 #include <fcntl.h>
  43 #include <sys/time.h>
  44 #include <time.h>
  45 #include <stdarg.h>
  46 #include <string.h>
  47 #include <netinet/in.h>
  48 #include <execinfo.h>
  49 #include <dlfcn.h>
  50 #include <dirent.h>
  51 #include <pthread.h>
  52 #include "rl_rlog.h"
  53 #include "rl_platform.h"
  54 #include "gen.h"
  55 #include "ssi.h"
  56 #include "ss_msg.h"
  57 #include "ss_task.h"
  58
  59 #include "gen.x"
  60 #include "ssi.x"
  61
  62 #include "ss_queue.h"
  63 #include "ss_queue.x"
  64 #include "ss_task.x"
  65 #include "ss_msg.x"
  66 #include "cm_inet.h"
  67 #include "cm_inet.x"
  68
  69 #include "rl_interface.h"
  70 #include "rl_soc.h"
  71 char g_fileName[MAX_FILENAME_LEN];
  72 char g_logDir[MAX_FILENAME_LEN];
  73 char g_fileList[RLOG_MAX_FILES][MAX_FILENAME_LEN];
  74 #ifdef RLOG_USE_CIRCULAR_BUFFER
  75 static THREAD_DATA *g_pSingCirBuff = NULL;
  76 static U16 g_prevLogOffset=0;
  77 #endif
  78 #ifndef RLOG_ENABLE_TEXT_LOGGING
  79 static volatile U32 g_rlogPositionIndex=0;
  80 U32 gIpType = CM_IPV4ADDR_TYPE;
  81 #endif
  82
  83 ///////////////////////////////////////////////////////////////////////////////////////////////////
  84 //                              Default variable initilization
  85 ///////////////////////////////////////////////////////////////////////////////////////////////////
  86
  87 /* global file pointer */
  88 FILE* g_fp = NULL;
  89
  90 /* L2 Logging */
  91 #ifndef RLOG_ENABLE_TEXT_LOGGING
  92
  93 Data  *g_l2rlogBuf = NULLP;
  94 Data  *g_l2LogBufStartPtr = NULLP;
  95 Data  *g_l2LogBufBasePtr = NULLP;
  96 Data  *g_logBufRcvdFromL2 = NULLP;
  97 Data  *g_l2LogBaseBuff = NULLP;
  98 U32    g_logBufLenRcvdFromL2 = 0;
  99 U32    g_l2LogBufLen = 0;
 100 U32    startL2Logging = 0;
 101 U32    g_l2logBuffPos = 0;
 102 /* end */
 103 #endif /* Binary Logging */
 104
 105 /* number of times log function is called */
 106 int  g_nWrites = 0;
 107
 108 /* Socke descriptor if remote client is connected */
 109 int g_nCliSocket = 0;
 110
 111 /* Default log level Error */
 112 #ifdef DISABLE_RLOG
 113 int g_logLevel = 1;
 114 #else
 115 int g_logLevel = L_MAX_LOG_LEVEL;
 116 #endif
 117 /* MAX Log Files 1 */
 118 U8 g_nMaxLogFiles = 1;
 119
 120 /* Max File Size limit for each log file */
 121 U32 g_uiMaxFileSizeLimit = MAX_FILE_SIZE;
 122
 123 /* Default circular buffer size 100Kb*/
 124 U32 g_cirMaxBufferSize = RLOG_MAX_CIRBUF_SIZE;
 125
 126 /* Default mask for each module is disabled */
 127 U32 g_modMask = 0;
 128
 129 /* Remote Logging port */
 130 static U32 g_nLogPort = RLOG_REMOTE_LOGGING_PORT;
 131
 132 /* Current File Number index */
 133 int  g_nCurrFileIdx = 0;
 134
 135 /* Remote logging flag */
 136 static U8 g_bRemoteLoggingDisabled=1;
 137
 138 /* Global file descriptor for L2 & L3 */
 139 static int g_fd;
 140
 141 /* L2 Buffer */
 142 char g_l2Buf[RLOG_MAX_CIRBUF_SIZE];
 143
 144 #ifdef RLOG_USE_CIRCULAR_BUFFER
 145 /* List of thread data pointers */
 146 THREAD_DATA* g_pCirList[RLOG_MAX_THREADS];
 147
 148 /* Number of threads registered */
 149 static int g_nThreadsRegistered;
 150
 151 /* Mutex to protect circular buffers */
 152 pthread_mutex_t g_logmutex, g_condmutex;
 153 pthread_cond_t g_cond;
 154
 155 U8 g_writeCirBuf = 0;
 156
 157 static int thread_signalled;
 158 #endif
 159
 160 /* TTI Count */
 161 static U32 numTtiTicks;
 162 /* Console input handling parameters */
 163 static int g_kIdx, g_action, g_storeKeys;
 164 static char g_keyBuf[32];
 165
 166 /* Standard C library, timezone */
 167 extern char *tzname[2];
 168 ///////////////////////////////////////////////////////////////////////////////
 169 //                  FUNCTION DECLARATIONS                                          //
 170 ///////////////////////////////////////////////////////////////////////////////
 171 #if defined(RLOG_ENABLE_TEXT_LOGGING)
 172 static struct tm* getTime(int* microseconds);
 173 static void getLogTimeStr(char* ts);
 174 #else
 175 #endif
 176 void initGlbDataAtL2(void);
 177 void createNewLogFile(void);
 178 void createL2LogFile(void);
 179 void* rLogServer(void* arg);
 180 void closeConnection(int sockfd);
 181 void storeTimeDelimeter(FILE* fp);
 182 void rlCatchSegViolation(int sig);
 183 void flushData(int sig);
 184 void* cirBufReaderThread(void* arg);
 185 void readCircularBuffers(void);
 186 void userAction(void);
 187 void handleSigIO(int sig);
 188 void rlPrintConfiguration(void);
 189 THREAD_DATA* rlRegisterThread(const char* taskName);
 190 extern void (*rlSigHandler)(int);
 191 /* L2 Logging */
 192 void rlInitL2Log(void);
 193 U32 g_rlogWriteCount = 0;
 194 U32 g_maxRlogCount   = 50;
 195 U32 g_logsDropCnt    = 0;
 196 RLLogCntLmt g_rlLogCntLimit = RL_LOG_COUNT_LIMIT_STOP;
 197
 198 #ifndef RLOG_ENABLE_TEXT_LOGGING
 199 void readL2LogBuff(void);
 200 S16 rlValidateL2LogBuf(void);
 201 void  rlSetL2LogBuf(U8 *l2LogBuf,U32 l2logLen);
 202 void rlResetL2LogBuf(void);
 203 #endif
 204
 205
 206 #ifndef RLOG_ENABLE_TEXT_LOGGING
 207 EndianType getCPU_Endian(Void);
 208 void storeFileHeader(FILE* fp);
 209 void saveLogDataFromCpul(const void* buf, U16 len);
 210 void saveLogData(const void* buf, U16 len, U32 g_rlogWritePosIndex);
 211 void sendToPostProcessor(const void* buf, U16 len);
 212 void getLogTimeStr(char* ts);
 213 #endif
 214 ///////////////////////////////////////////////////////////////////////////////////////////////////
 215 // @param[in] modMask - bit mask for any particular module.
 216 // Sets or clears bit for the particular module. If mask value is zero all bits are cleared.
 217 ///////////////////////////////////////////////////////////////////////////////////////////////////
 218 void rlSetModuleMask(U32 modMask)
 219 {
 220         g_modMask =  (modMask == 0 ) ? 0 : (g_modMask ^ modMask);
 221 }
 222
 223 ///////////////////////////////////////////////////////////////////////////////////////////////////
 224 // @param[in] - maxFileSize - Maximum file size in MB.
 225 // @brief This function sets the limit to log file size.
 226 ///////////////////////////////////////////////////////////////////////////////////////////////////
 227 void rlSetLogFileSizeLimit(U32 maxFileSize)
 228 {
 229         g_uiMaxFileSizeLimit = (maxFileSize == 0) ? MAX_FILE_SIZE : maxFileSize*1048576;
 230 }
 231
 232 ///////////////////////////////////////////////////////////////////////////////////////////////////
 233 //
 234 //
 235 ///////////////////////////////////////////////////////////////////////////////////////////////////
 236 void rlSetNumOfLogFiles(U8 nMaxFiles)
 237 {
 238         if( nMaxFiles > RLOG_MAX_FILES || nMaxFiles == 0 ) {
 239                 g_nMaxLogFiles = RLOG_MAX_FILES;
 240                 return;
 241         }
 242
 243         g_nMaxLogFiles = nMaxFiles;
 244 }
 245
 246 ///////////////////////////////////////////////////////////////////////////////////////////////////
 247 //
 248 // @brief 1-> enable remote logging, 0-> disable remote logging
 249 ///////////////////////////////////////////////////////////////////////////////////////////////////
 250 void rlSetRemoteLoggingFlag(S32 flag)
 251 {
 252         g_bRemoteLoggingDisabled = !flag;
 253 }
 254
 255 ///////////////////////////////////////////////////////////////////////////////////////////////////
 256 // @param[in] port - Server port
 257 // @brief Use this API to configure port for remote logging application.
 258 ///////////////////////////////////////////////////////////////////////////////////////////////////
 259 void rlSetLogPort(U32 port)
 260 {
 261         g_nLogPort = port;
 262 }
 263
 264 ///////////////////////////////////////////////////////////////////////////////////////////////////
 265 // @param[in] enable_core - 1 Enables core file generation 0 - disable
 266 // This enables or disables core file generation
 267 ///////////////////////////////////////////////////////////////////////////////////////////////////
 268 void rlEnableDisableCore(S32 enable_core)
 269 {
 270         struct rlimit core_limits;
 271         core_limits.rlim_cur = core_limits.rlim_max = enable_core ? RLIM_INFINITY : 0;
 272         setrlimit(RLIMIT_CORE, &core_limits);
 273 }
 274
 275 ///////////////////////////////////////////////////////////////////////////////////////////////////
 276 //
 277 //
 278 ///////////////////////////////////////////////////////////////////////////////////////////////////
 279 void rlSetLogPath(const char* logDir)
 280 {
 281         strncpy(g_logDir, logDir, MAX_FILENAME_LEN);
 282 }
 283
 284 ///////////////////////////////////////////////////////////////////////////////////////////////////
 285 //
 286 //
 287 ///////////////////////////////////////////////////////////////////////////////////////////////////
 288 void rlSetLogFile(const char* fileName)
 289 {
 290         strncpy(g_fileName, fileName, MAX_FILENAME_LEN);
 291 }
 292
 293 ///////////////////////////////////////////////////////////////////////////////////////////////////
 294 //
 295 //
 296 ///////////////////////////////////////////////////////////////////////////////////////////////////
 297 void rlSetLogLevel(R_LOG_LEVEL logLevel)
 298 {
 299         g_logLevel = logLevel + 1;
 300 }
 301
 302 ///////////////////////////////////////////////////////////////////////////////////////////////////
 303 // @param[in] bufSize - Circulaer buffer size in multiples of 1Kb or 1024 bytes.
 304 // This function is called to set circular buffer size for each thread.
 305 ///////////////////////////////////////////////////////////////////////////////////////////////////
 306 void rlSetCircularBufferSize(U32 bufSize)
 307 {
 308         g_cirMaxBufferSize = bufSize*1024;
 309    g_cirMaxBufferSize = (g_cirMaxBufferSize/50) * 50;
 310 }
 311
 312 ///////////////////////////////////////////////////////////////////////////////////////////////////
 313 //
 314 //
 315 ///////////////////////////////////////////////////////////////////////////////////////////////////
 316 void rlPrintConfiguration(void)
 317 {
 318         fprintf(stderr, "Log File:\t\t[%s]\n", g_fileName);
 319         fprintf(stderr, "Log level:\t\t[%s]\n", g_logStr[g_logLevel-1]);
 320 #ifndef ALIGN_64BIT
 321         fprintf(stderr, "Module Mask:\t\t[%ld]\n", g_modMask);
 322         fprintf(stderr, "File Size Limit:\t[%ld]\n", g_uiMaxFileSizeLimit);
 323 #else
 324         fprintf(stderr, "Module Mask:\t\t[%d]\n", g_modMask);
 325         fprintf(stderr, "File Size Limit:\t[%d]\n", g_uiMaxFileSizeLimit);
 326 #endif
 327         fprintf(stderr, "Maximum Log Files:\t[%d]\n", g_nMaxLogFiles);
 328         fprintf(stderr, "Time Zone:\t\t[%s]\n", tzname[0]);
 329
 330 #ifdef RLOG_ENABLE_TEXT_LOGGING
 331         fprintf(stderr, "Binary Logging:\t\t[Disabled]\n");
 332         fprintf(stderr, "Remote Logging:\t\t[Disabled]\n");
 333         fprintf(stderr, "Console Logging:\t[%s]\n", (g_fp==stderr) ? "Enabled" : "Disabled" );
 334 #else
 335         fprintf(stderr, "Console Logging:\t[Disabled]\n");
 336         fprintf(stderr, "Binary Logging:\t\t[Enabled]\n");
 337         fprintf(stderr, "Remote Logging:\t\t[%s]\n", g_bRemoteLoggingDisabled ? "Disabled" : "Enabled");
 338 #ifndef ALIGN_64BIT
 339         fprintf(stderr, "Remote Logging Port:\t[%ld]\n", g_nLogPort);
 340 #else
 341         fprintf(stderr, "Remote Logging Port:\t[%d]\n", g_nLogPort);
 342 #endif
 343 #ifdef RLOG_USE_CIRCULAR_BUFFER
 344         fprintf(stderr, "Circular Buffer:\t[Enabled]\n");
 345 #ifndef ALIGN_64BIT
 346         fprintf(stderr, "Circular BufferSize:\t[Actual:%ld][Derived:%ld]\n",
 347                         g_cirMaxBufferSize/1024, g_cirMaxBufferSize);
 348 #else
 349         fprintf(stderr, "Circular BufferSize:\t[Actual:%d][Derived:%d]\n",
 350                         g_cirMaxBufferSize/1024, g_cirMaxBufferSize);
 351 #endif
 352 #else
 353         fprintf(stderr, "Circular Buffer:\t[Disabled]\n");
 354 #endif  /* RLOG_USE_CIRCULAR_BUFFER */
 355 #endif /* RLOG_ENABLE_TEXT_LOGGING */
 356
 357 }
 358
 359 #ifdef RLOG_USE_CIRCULAR_BUFFER
 360
 361 #ifdef RLOG_USE_TTI_LOGGING
 362 #define CHECK_FILE_SIZE if( ++g_nWrites == 200 ) \
 363 { \
 364         g_nWrites = 0; \
 365         logLev1(L_TIME_REFERENCE, L_ALWAYS, (U32)time(NULL));\
 366 }
 367 #else
 368 #define CHECK_FILE_SIZE
 369 #endif /* RLOG_USE_TTI_LOGGING */
 370
 371 #else /* RLOG_USE_CIRCULAR_BUFFER */
 372
 373 #ifdef RLOG_USE_TTI_LOGGING
 374 #define CHECK_FILE_SIZE if( ++g_nWrites == 200 ) \
 375 { \
 376         if( g_fp && ftell(g_fp) > g_uiMaxFileSizeLimit ) { \
 377                 createNewLogFile(); \
 378         }\
 379         g_nWrites = 0; \
 380         logLev1(L_TIME_REFERENCE, L_ALWAYS, (U32)time(NULL));\
 381 }
 382 #else
 383 #define CHECK_FILE_SIZE if( ++g_nWrites == 200 ) \
 384 { \
 385         if( g_fp && ( (U32)(ftell(g_fp)) > g_uiMaxFileSizeLimit) ) { \
 386                 createNewLogFile(); \
 387         }\
 388         g_nWrites = 0; \
 389 }
 390 #endif /* RLOG_USE_TTI_LOGGING */
 391 #endif /*  RLOG_USE_CIRCULAR_BUFFER */
 392
 393
 394 #ifdef RLOG_USE_CIRCULAR_BUFFER
 395
 396 #define CHECK_CIRFILE_SIZE if( g_fp && ftell(g_fp) > g_uiMaxFileSizeLimit ) \
 397         createNewLogFile();
 398
 399 ///////////////////////////////////////////////////////////////////////////////////////////////////
 400 // @param[in] tasName - Name of registering thread / task
 401 // This function registers the thread for writing logs. It creates thread specific buffers.
 402 ///////////////////////////////////////////////////////////////////////////////////////////////////
 403 THREAD_DATA* rlRegisterThread(const char* taskName)
 404 {
 405         THREAD_DATA* pThrData = (THREAD_DATA*) rlCalloc(sizeof(THREAD_DATA));
 406
 407         if( pThrData == NULL ) {
 408                 fprintf(stderr, "Failed to allocate memory for thread %s\n", taskName);
 409                 _exit(0);
 410         }
 411
 412         pthread_mutex_lock(&g_logmutex);
 413
 414         /* Allocate circular buffer */
 415         pThrData->logBuff = (U8*) rlAlloc(g_cirMaxBufferSize);
 416
 417         if( pThrData->logBuff == NULL ) {
 418 #ifndef ALIGN_64BIT
 419                 fprintf(stderr, "Failed to allocate memory [%ld] for thread %s\n",g_cirMaxBufferSize, taskName);
 420 #else
 421                 fprintf(stderr, "Failed to allocate memory [%d] for thread %s\n",g_cirMaxBufferSize, taskName);
 422 #endif
 423                 _exit(0);
 424         }
 425
 426         /* store task name */
 427         strcpy(pThrData->szTaskName, taskName);
 428
 429         //rlSetThreadSpecificData(pThrData);
 430
 431         pThrData->listIndex = g_nThreadsRegistered++;
 432
 433         /* Store this pointerin global list, to access it later */
 434         g_pCirList[pThrData->listIndex]  = pThrData;
 435
 436         pthread_mutex_unlock(&g_logmutex);
 437
 438 #ifdef RLOG_DEBUG_MODE
 439 #ifndef ALIGN_64BIT
 440         fprintf(stderr, "rlRegisterThread: allocated CIRCULAR BUFFER of size [%ld]\n", g_cirMaxBufferSize);
 441 #else
 442         fprintf(stderr, "rlRegisterThread: allocated CIRCULAR BUFFER of size [%d]\n", g_cirMaxBufferSize);
 443 #endif
 444         fprintf(stderr, "rlRegisterThread: Total registered threads [%d]\n", g_nThreadsRegistered);
 445 #endif
 446
 447         return pThrData;
 448 }
 449
 450 ///////////////////////////////////////////////////////////////////////////////////////////////////
 451 // @param[in] arg - Thread argument
 452 //      This thread wakes up periodically and transfer logs from thread specific buffer into file system.
 453 // If buffer is going to be full, this thread is signalled asynchrounously to read buffered logs.
 454 ///////////////////////////////////////////////////////////////////////////////////////////////////
 455 void* cirBufReaderThread(void* arg)
 456 {
 457         struct timespec timeout;
 458         int retCode;
 459
 460 #ifdef RLOG_DEBUG_MODE
 461         fprintf(stderr, "Circular Buffer Reader thread started\n");
 462 #endif
 463
 464         while(1)
 465         {
 466                 /*this thread is not active and waiting to timeout */
 467                 thread_signalled = 0;
 468
 469                 /* set the thread timeout */
 470                 timeout.tv_sec = time(NULL) + RLOG_CIRBUF_READ_INTERVAL;
 471                 timeout.tv_nsec = 0;
 472
 473                 /* wait for 120 seconds time interval to read buffer */
 474                 retCode = pthread_cond_timedwait(&g_cond, &g_condmutex, &timeout);
 475
 476                 /* this means, this thread is already active, no need to give any other signal to wake up */
 477                 thread_signalled = 1;
 478
 479 #ifdef RLOG_DEBUG_MODE
 480                 //if(retCode == 0) fprintf(stderr, "cirBufReaderThread: I am signalled to read data\n");
 481 #endif
 482
 483                 /* If someone has given signal or there is timeout */
 484                 if( retCode == 0 || retCode  == ETIMEDOUT ){
 485                         readCircularBuffers();
 486                         continue;
 487                 }
 488
 489                 readCircularBuffers();
 490
 491 #ifdef RLOG_DEBUG_MODE
 492                 fprintf(stderr, "System is exiting ??");
 493                 perror("cirBufReaderThread");
 494 #endif
 495                 break;
 496         }
 497
 498         return NULL;
 499 }
 500
 501 ///////////////////////////////////////////////////////////////////////////////////////////////////
 502 //
 503 //
 504 ///////////////////////////////////////////////////////////////////////////////////////////////////
 505 void readCircularBuffers()
 506 {
 507    U32 i, writerPos;
 508
 509    /* Check if process is L2. If L2 then return from here */
 510    if (SFndProcId() == TENB_L2_PROC_ID)
 511    {
 512       return;
 513    }
 514
 515    g_writeCirBuf = 1;
 516    /* Before reading circular buffers, store delimiter */
 517    //storeTimeDelimeter(g_fp);
 518
 519    /* lock the mutex */
 520    pthread_mutex_lock(&g_logmutex);
 521
 522    for(i=0; i < g_nThreadsRegistered; i++)
 523    {
 524       THREAD_DATA* pThrData = g_pCirList[i];
 525
 526       if( pThrData == NULL )
 527          continue;
 528
 529       writerPos = pThrData->logBufLen;
 530
 531 #ifdef RLOG_DEBUG_MODE
 532       //fprintf(stderr, "Thread [%ld] WritePos:[%ld] ReadPos:[%ld]\n", i+1, writerPos, pThrData->logReadPos);
 533 #endif
 534
 535       if( pThrData->logReadPos < writerPos  )
 536       {
 537          /* Calculate the delta data to be read from buffer */
 538          int dataLen = writerPos - pThrData->logReadPos;
 539
 540          /* Write the data into file */
 541          if( fwrite(pThrData->logBuff+pThrData->logReadPos,1, dataLen, g_fp) == -1 )
 542          {
 543 #ifdef RLOG_DEBUG_MODE
 544             fprintf(stderr, "Failed to write data len %d\n", dataLen);
 545 #endif
 546             createNewLogFile();
 547             continue;
 548          }
 549          /* reset log read position to last known position */
 550          pThrData->logReadPos = writerPos;
 551       }
 552       else if ( pThrData->logReadPos > writerPos )
 553       {
 554          /* Calculate the remaining data left in the buffer */
 555          int dataLen = g_cirMaxBufferSize -  pThrData->logReadPos;
 556
 557          /* Write from last know position till end */
 558          if( fwrite(pThrData->logBuff+pThrData->logReadPos, 1, dataLen, g_fp) == -1 )
 559          {
 560 #ifdef RLOG_DEBUG_MODE
 561             fprintf(stderr, "Failed to write data len %d\n", dataLen);
 562 #endif
 563             createNewLogFile();
 564             continue;
 565          }
 566
 567          /* Write from 0 to len position */
 568          if( fwrite(pThrData->logBuff, 1, writerPos, g_fp) == -1 )
 569          {
 570 #ifdef RLOG_DEBUG_MODE
 571             fprintf(stderr, "Failed to write data len %d\n", dataLen);
 572 #endif
 573             createNewLogFile();
 574             continue;
 575          }
 576
 577          /* reset log read position to last known position */
 578          pThrData->logReadPos = writerPos;
 579       }
 580    }
 581
 582    /* unlock the mutex */
 583    pthread_mutex_unlock(&g_logmutex);
 584
 585    /* after reading circular buffers also store delimiter */
 586    //storeTimeDelimeter(g_fp);
 587
 588    CHECK_CIRFILE_SIZE
 589
 590       g_writeCirBuf = 0;
 591 }
 592
 593 #endif
 594
 595 #ifndef RLOG_ENABLE_TEXT_LOGGING
 596 ///////////////////////////////////////////////////////////////////////////////////////////////////
 597 //
 598 //
 599 ///////////////////////////////////////////////////////////////////////////////////////////////////
 600 EndianType getCPU_Endian(Void)
 601 {
 602     unsigned short x;
 603     unsigned char c;
 604
 605     x = 0x0001;;
 606     c = *(unsigned char *)(&x);
 607
 608         return ( c == 0x01 ) ? little_endian : big_endian;
 609 }
 610
 611 ///////////////////////////////////////////////////////////////////////////////////////////////////
 612 //
 613 //
 614 ///////////////////////////////////////////////////////////////////////////////////////////////////
 615 void storeFileHeader(FILE* fp)
 616 {
 617         FILE_HEADER fileHdr;
 618
 619         memset(&fileHdr, 0, sizeof(FILE_HEADER));
 620
 621         fileHdr.endianType = getCPU_Endian();
 622         fileHdr.dummy32 = 2818049;
 623         fileHdr.END_MARKER = 0xFFFF;
 624         strncpy(fileHdr.szTimeZone, tzname[0], RLOG_TIME_ZONE_LEN);
 625
 626    fileHdr.time_sec = time(NULL);
 627         if( fwrite((const void*)&fileHdr, 1, sizeof(FILE_HEADER), fp) ==  -1 )
 628         {
 629 #ifdef RLOG_DEBUG_MODE
 630                 fprintf(stderr, "Failed to write file header\n");
 631 #endif
 632                 createNewLogFile();
 633         }
 634 }
 635 #endif
 636
 637 ///////////////////////////////////////////////////////////////////////////////////////////////////
 638 // @param[in] fileName - Log File Name
 639 // @brief This function creates a log file. If log file name is stdout & text  logging is enabled,
 640 // file  pointer is  initialized to  standard output. This  function also  creates thread on which
 641 // remote application can connect & receive binary logs. If circular buffer is enabled, it creates
 642 // thread key, which is used to store & retrieve thread specific buffers and data.
 643 ///////////////////////////////////////////////////////////////////////////////////////////////////
 644 void rlInitLog(U8 type)
 645 {
 646 #ifdef SS_RBUF
 647         /* Initilize the signal handler */
 648         rlSigHandler = &rlCatchSegViolation;
 649 #else
 650         signal(SIGSEGV, rlCatchSegViolation);
 651         signal(SIGBUS, rlCatchSegViolation);
 652         signal(SIGINT, flushData);
 653 #endif
 654 /* set rate limit count for L3 Logs */
 655    g_maxRlogCount = RLOG_LIMIT_L3_COUNT;
 656
 657 #ifdef RLOG_DEBUG_MODE
 658         rlPrintConfiguration();
 659 #endif /* RLOG_DEBUG_MODE */
 660
 661 #if RLOG_ALLOW_CONSOLE_LOGS
 662         if( !strcmp(g_fileName, "stdout")) {
 663                 g_fp = stderr;
 664                 return;
 665         }
 666 #endif
 667
 668 #ifndef RLOG_ENABLE_TEXT_LOGGING
 669         {
 670       printf("\n IP Type before reader thread spawn [%d]\n",type);
 671         /* Allocate circular buffer */
 672       gIpType = type;
 673                 pthread_t tid;
 674                 if( pthread_create(&tid, NULL, &rLogServer, NULL) != 0 ) {
 675                         fprintf(stderr, "Failed to initialize log server thread\n");
 676                         _exit(0);
 677                 }
 678         }
 679
 680         rlInitPlatformSpecific();
 681
 682 #ifdef RLOG_USE_CIRCULAR_BUFFER
 683         {
 684                 pthread_t tid;
 685                 pthread_mutex_init(&g_logmutex, NULL);
 686                 if( pthread_create(&tid, NULL, &cirBufReaderThread, NULL) != 0 ) {
 687                         fprintf(stderr, "Failed to initialize log server thread\n");
 688                         _exit(0);
 689                 }
 690 /* Initialize single circular buffer for all threads */
 691    g_pSingCirBuff = rlRegisterThread("DUMMY");
 692 }
 693
 694 #endif
 695 #endif
 696
 697         createNewLogFile();
 698 }
 699
 700
 701 //////////////////////////////////////////////////////////////////////////
 702 //  @Function    : rlInitL2Log
 703 //  @Discription : This will be trigigered from cl init function to
 704 //                 allocate buffer from shared memory and to intialize
 705 //                 the buffer
 706 //  @in          : void
 707 //  @out         : void
 708 //////////////////////////////////////////////////////////////////////////
 709 void rlInitL2Log(void)
 710 {
 711
 712 /* set rate limit count for L3 Logs */
 713    g_maxRlogCount = RLOG_LIMIT_L2_COUNT;
 714
 715 #ifndef RLOG_ENABLE_TEXT_LOGGING
 716 /* Initialise memory to write logs in L2. This is soc specific
 717    function present in soc file. */
 718    rlInitL2SocSpecific();
 719
 720 #else
 721
 722 /* This is used to initialize global variable at L2 */
 723    initGlbDataAtL2();
 724    createL2LogFile();
 725
 726 #endif /* Binary Logging */
 727 }
 728
 729
 730 #ifndef RLOG_ENABLE_TEXT_LOGGING
 731 ///////////////////////////////////////////////////////////////////////////////////////////////////
 732 // @param[in] arg - Input thread argument - IP Address type.
 733 // @brief This is log server thread which listens on configred port. This allows user to connect to
 734 // log server and view log data live.
 735 ///////////////////////////////////////////////////////////////////////////////////////////////////
 736 void*   rLogServer(void* arg)
 737 {
 738   CmInetCmnSockAddr serv_addr;
 739   CmInetCmnSockAddr cli_addr;
 740   int sockfd;
 741   int newsockfd;
 742   int clilen = 0;
 743   int domain = AF_INET;
 744   memset((void*)&serv_addr, 0, sizeof(serv_addr));
 745
 746
 747   if(gIpType == CM_IPV4ADDR_TYPE)
 748   {
 749 #ifndef ALIGN_64BIT
 750      printf("Initializing RLOG for IPV4- %ld\n",gIpType);
 751 #else
 752      printf("Initializing RLOG for IPV4- %d\n",gIpType);
 753 #endif
 754      clilen = serv_addr.len = sizeof(struct sockaddr_in);
 755      domain = AF_INET;
 756      serv_addr.type = CM_IPV4ADDR_TYPE;
 757      serv_addr.u.addr.sin_family = AF_INET;
 758      serv_addr.u.addr.sin_addr.s_addr = INADDR_ANY;
 759      serv_addr.u.addr.sin_port = htons(g_nLogPort);
 760   }
 761   else
 762   {
 763 #ifndef ALIGN_64BIT
 764      printf("Initializing RLOG for IPV6 - %ld\n",gIpType);
 765 #else
 766      printf("Initializing RLOG for IPV6 - %d\n",gIpType);
 767 #endif
 768 #ifdef IPV6_SUPPORTED
 769      if(gIpType == CM_IPV6ADDR_TYPE)
 770      {
 771         clilen =  serv_addr.len = sizeof(struct sockaddr_in6);
 772         domain = AF_INET6;
 773         serv_addr.type = CM_IPV6ADDR_TYPE;
 774         serv_addr.u.addr6.sin6_family = AF_INET6;
 775         serv_addr.u.addr6.sin6_addr = in6addr_any;
 776         serv_addr.u.addr6.sin6_port = htons(g_nLogPort);
 777      }
 778 #endif
 779   }
 780         if( (sockfd = socket(domain, SOCK_STREAM, 0)) < 0 ) {
 781                 fprintf(stderr, "RLOG: Failed to create socket\n");
 782                 _exit(0);
 783         }
 784
 785         if( bind(sockfd, (struct sockaddr*)&(serv_addr.u),serv_addr.len) < 0 ) {
 786                 fprintf(stderr, "RLOG: Error in Binding\n");
 787                 perror("RLOG");
 788                 _exit(0);
 789         }
 790
 791         listen(sockfd, 5);
 792
 793         while(1)
 794         {
 795                 newsockfd = accept(sockfd, (struct sockaddr*)&(cli_addr.u), (socklen_t *) &clilen);
 796                 if( newsockfd < 0 ) {
 797                         fprintf(stderr, "RLOG: Error on accept\n");
 798                         perror("RLOG");
 799                         return 0;
 800                 }
 801
 802                 /* If remote logging is disabled or there is already 1 client connected */
 803                 if( g_bRemoteLoggingDisabled || g_nCliSocket ) {
 804                         /* close the new connection and proceed */
 805                         closeConnection(newsockfd);
 806                         continue;
 807                 }
 808
 809                 g_nCliSocket = newsockfd;
 810         }
 811
 812         return 0;
 813 }
 814
 815 ///////////////////////////////////////////////////////////////////////////////////////////////////
 816 //
 817 //
 818 ///////////////////////////////////////////////////////////////////////////////////////////////////
 819 void closeConnection(int sockfd)
 820 {
 821         shutdown(sockfd, SHUT_RDWR);
 822         close(sockfd);
 823 }
 824
 825 #endif
 826
 827 ///////////////////////////////////////////////////////////////////////////////////////////////////
 828 //
 829 //
 830 ///////////////////////////////////////////////////////////////////////////////////////////////////
 831 void  handleSigIO(int sig)
 832 {
 833         char ch;
 834
 835         if( read(0, &ch, 1) <= 0 )
 836                 return;
 837
 838         rlHandleConInput(ch);
 839 }
 840
 841 ///////////////////////////////////////////////////////////////////////////////////////////////////
 842 //
 843 //
 844 ///////////////////////////////////////////////////////////////////////////////////////////////////
 845 int rlHandleConInput(char ch)
 846 {
 847         if( ch == RLOG_CTRL_L ) {
 848                 g_storeKeys = 1;
 849                 g_action = RLOG_SET_LOGLEVEL;
 850                 fprintf(stderr, "\nEnter new log level:");
 851                 return 1;
 852         }
 853
 854         if( ch == RLOG_CTRL_Y ) {
 855                 g_storeKeys = 1;
 856                 g_action = RLOG_SET_MODMASK;
 857                 fprintf(stderr, "\nEnter module number:");
 858                 return 1;
 859         }
 860
 861         if( ch == RLOG_ENTER_KEY && g_action ) {
 862                 g_keyBuf[g_kIdx] = '\0';
 863                 userAction();
 864                 return 1;
 865         }
 866
 867         if( g_storeKeys ) {
 868                 g_keyBuf[g_kIdx] = ch;
 869                 g_kIdx +=1;
 870         }
 871
 872         return 0;
 873 }
 874
 875 ///////////////////////////////////////////////////////////////////////////////////////////////////
 876 //
 877 //
 878 ///////////////////////////////////////////////////////////////////////////////////////////////////
 879 void userAction()
 880 {
 881         unsigned int val = atol(g_keyBuf);
 882
 883         switch( g_action )
 884         {
 885                 case RLOG_SET_LOGLEVEL:
 886                         {
 887                                 if( val >= L_MAX_LOG_LEVEL )
 888                                         fprintf(stderr, "Invalid log level\n");
 889                                 else
 890                                 {
 891                                         if( val > L_FATAL )
 892                                         {
 893                                                 rlSetLogLevel((R_LOG_LEVEL)val);
 894                                                 fprintf(stderr, "New Log level is %s\n", g_logStr[val]);
 895                                         }
 896                                         else
 897                                                 fprintf(stderr, "Log level below L_ERROR is not allowed\n");
 898                                 }
 899                         }
 900                         break;
 901
 902                 case RLOG_SET_MODMASK:
 903                         {
 904                                 rlSetModuleMask(val);
 905                                 fprintf(stderr, "Toggled log mask %d\n", val);
 906                         }
 907                         break;
 908         }
 909
 910         g_action = 0;
 911         g_kIdx= 0;
 912         g_storeKeys = 0;
 913 }
 914
 915 ///////////////////////////////////////////////////////////////////////////////////////////////////
 916 //
 917 //
 918 ///////////////////////////////////////////////////////////////////////////////////////////////////
 919 void rlCatchSegViolation(int sig)
 920 {
 921         int i, nStrLen, nDepth;
 922
 923         void    *stackTraceBuf[RLOG_MAX_STACK_DEPTH];
 924         const char* sFileNames[RLOG_MAX_STACK_DEPTH];
 925         const char* sFunctions[RLOG_MAX_STACK_DEPTH];
 926
 927         char **strings; char buf[RLOG_MAX_STACK_DEPTH*128]={0};
 928 #ifdef T2K_MEM_LEAK_DBG
 929    DumpT2kMemLeakInfoToFile();
 930 #endif
 931 #ifdef SSI_STATIC_MEM_LEAK_DETECTION
 932    DumpStaticMemLeakFiles();
 933 #endif
 934
 935         nDepth = backtrace(stackTraceBuf, RLOG_MAX_STACK_DEPTH);
 936
 937
 938         strings = (char**) backtrace_symbols(stackTraceBuf, nDepth);
 939
 940         for(i = 0, nStrLen=0; i < nDepth; i++)
 941         {
 942                 sFunctions[i] = (strings[i]);
 943                 sFileNames[i] = "unknown file";
 944
 945 #ifndef RLOG_ENABLE_TEXT_LOGGING
 946            logLevS(L_SIGSEGV, L_FATAL, strings[i]);
 947 #endif
 948       printf("BT[%d] : len [%ld]: %s\n",i, (PTR)strlen(sFunctions[i]),strings[i]);
 949                 sprintf(buf+nStrLen, "   in Function %s (from %s)\n", sFunctions[i], sFileNames[i]);
 950                 nStrLen += strlen(sFunctions[i]) + strlen(sFileNames[i]) + 15;
 951         }
 952
 953 #ifdef RLOG_ENABLE_TEXT_LOGGING
 954         logLevS(g_logStr[L_FATAL], "RLOG", "NULL", 0, FMTSTR RLOG_SEGFAULT_STR, buf);
 955         fflush(g_fp);
 956 #else
 957         logLevS(L_SIGSEGV, L_FATAL, buf);
 958 #endif
 959
 960         flushData(SIGSEGV);
 961 }
 962
 963 ///////////////////////////////////////////////////////////////////////////////////////////////////
 964 //
 965 //
 966 ///////////////////////////////////////////////////////////////////////////////////////////////////
 967 void flushData(int sig)
 968 {
 969 #ifdef RLOG_USE_CIRCULAR_BUFFER
 970         readCircularBuffers();
 971 #endif
 972    g_rlogWriteCount = 0;
 973
 974         fclose(g_fp);
 975
 976         if(SIGSEGV == sig)
 977         {
 978            signal(sig, SIG_DFL);
 979            kill(getpid(), sig);
 980         }
 981         else
 982         {
 983            exit(0);
 984         }
 985
 986         return;
 987 }
 988
 989 ///////////////////////////////////////////////////////////////////////////////////////////////////
 990 //
 991 //
 992 ///////////////////////////////////////////////////////////////////////////////////////////////////
 993
 994 #ifdef RLOG_ENABLE_TEXT_LOGGING
 995
 996 #define TIME_PARAMS tm->tm_mday, tm->tm_mon+1, tm->tm_year+1900,tm->tm_hour, tm->tm_min,tm->tm_sec,microseconds
 997
 998 ///////////////////////////////////////////////////////////////////////////////////////////////////
 999 //
1000 //
1001 ///////////////////////////////////////////////////////////////////////////////////////////////////
1002 void logLevS(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, PSTR str, ...)
1003 {
1004         int microseconds=0;
1005
1006         struct tm* tm = getTime(&microseconds);
1007    if (tm) fprintf(g_fp, fmtStr, TIME_PARAMS, modName, file, lineno, strLogLevel, str);
1008
1009         CHECK_FILE_SIZE
1010 }
1011
1012 ///////////////////////////////////////////////////////////////////////////////////////////////////
1013 //
1014 //
1015 ///////////////////////////////////////////////////////////////////////////////////////////////////
1016 void logLevH(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, PSTR hexdump, int hexlen, ...)
1017 {
1018         int microseconds=0;
1019         char szHex[MAX_LOG_BUF_SIZE*3];
1020
1021         struct tm* tm = getTime(&microseconds);
1022         hextostr(szHex, hexdump, hexlen);
1023         if (tm) fprintf(g_fp, fmtStr, TIME_PARAMS, modName, file, lineno, strLogLevel, szHex);
1024
1025         CHECK_FILE_SIZE
1026 }
1027
1028 ///////////////////////////////////////////////////////////////////////////////////////////////////
1029 //
1030 //
1031 ///////////////////////////////////////////////////////////////////////////////////////////////////
1032 void logLevE(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, R_SPL_ARG splType,
1033                 U32 splVal, U32 arg1, U32 arg2, U32 arg3, U32 arg4, ...)
1034 {
1035         int microseconds=0;
1036
1037         struct tm* tm = getTime(&microseconds);
1038         if (tm) fprintf(g_fp, fmtStr, TIME_PARAMS, modName, file, lineno, strLogLevel, g_splStr[splType], splVal,
1039                         arg1, arg2, arg3, arg4);
1040
1041         CHECK_FILE_SIZE
1042 }
1043 ///////////////////////////////////////////////////////////////////////////////////////////////////
1044 //
1045 //
1046 ///////////////////////////////////////////////////////////////////////////////////////////////////
1047 void logLev0(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, ...)
1048 {
1049         int microseconds=0;
1050
1051         struct tm* tm = getTime(&microseconds);
1052         if (tm) fprintf(g_fp, fmtStr, TIME_PARAMS, modName, file, lineno, strLogLevel);
1053
1054         CHECK_FILE_SIZE
1055 }
1056
1057 ///////////////////////////////////////////////////////////////////////////////////////////////////
1058 //
1059 //
1060 ///////////////////////////////////////////////////////////////////////////////////////////////////
1061 void logLev1(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, U32 arg1, ...)
1062 {
1063         int microseconds=0;
1064
1065         struct tm* tm = getTime(&microseconds);
1066         if (tm) fprintf(g_fp, fmtStr, TIME_PARAMS, modName, file, lineno, strLogLevel, arg1);
1067
1068         CHECK_FILE_SIZE
1069 }
1070
1071 ///////////////////////////////////////////////////////////////////////////////////////////////////
1072 //
1073 //
1074 ///////////////////////////////////////////////////////////////////////////////////////////////////
1075 void logLev2(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, U32 arg1, U32 arg2, ...)
1076 {
1077         int microseconds=0;
1078
1079         struct tm* tm = getTime(&microseconds);
1080         if (tm) fprintf(g_fp, fmtStr, TIME_PARAMS, modName, file, lineno, strLogLevel, arg1, arg2);
1081
1082         CHECK_FILE_SIZE
1083 }
1084
1085 ///////////////////////////////////////////////////////////////////////////////////////////////////
1086 //
1087 //
1088 ///////////////////////////////////////////////////////////////////////////////////////////////////
1089 void logLev3(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr,
1090                 U32 arg1, U32 arg2, U32 arg3, ...)
1091 {
1092         int microseconds=0;
1093
1094         struct tm* tm = getTime(&microseconds);
1095         if (tm) fprintf(g_fp, fmtStr, TIME_PARAMS, modName, file, lineno, strLogLevel, arg1, arg2, arg3);
1096
1097         CHECK_FILE_SIZE
1098 }
1099
1100 ///////////////////////////////////////////////////////////////////////////////////////////////////
1101 //
1102 //
1103 ///////////////////////////////////////////////////////////////////////////////////////////////////
1104 void logLev4(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr,
1105                 U32 arg1, U32 arg2, U32 arg3, U32 arg4, ...)
1106 {
1107         int microseconds=0;
1108
1109         struct tm* tm = getTime(&microseconds);
1110         if (tm) fprintf(g_fp, fmtStr, TIME_PARAMS, modName, file, lineno, strLogLevel, arg1, arg2, arg3, arg4);
1111
1112         CHECK_FILE_SIZE
1113 }
1114
1115 ///////////////////////////////////////////////////////////////////////////////////////////////////
1116 //
1117 //
1118 ///////////////////////////////////////////////////////////////////////////////////////////////////
1119 void logLevN(int logLevel, const char* modName, const char* file, int lineno, const char* fmtStr, ...)
1120 {
1121         va_list argList;
1122         char szTime[RLOG_MAX_TIME_STAMP];
1123         char szLog1[MAX_LOG_LEN], szLog2[MAX_LOG_LEN];
1124
1125         getLogTimeStr(szTime);
1126         snprintf(szLog1, MAX_LOG_LEN, "[%s][%s]%s:%d\n%s:", szTime, modName, file, lineno, g_logStr[logLevel]);
1127
1128         va_start(argList,fmtStr);
1129         vsnprintf(szLog2, MAX_LOG_LEN, fmtStr, argList);
1130         va_end(argList);
1131
1132         fprintf(g_fp, "%s%s",szLog1, szLog2);
1133
1134         CHECK_FILE_SIZE
1135 }
1136 #else /* BINARY LOGGING */
1137
1138 #define RLOG_SAVE_TIME(_logTime) _logTime.ms_tti=numTtiTicks;
1139
1140 void saveLogDataFromCpul(const void* buf, U16 len)
1141 {
1142 #ifdef RLOG_USE_CIRCULAR_BUFFER
1143    THREAD_DATA* p = (THREAD_DATA*) g_pSingCirBuff;
1144
1145    if( (p->logBufLen+len) > g_cirMaxBufferSize )
1146    {
1147       S32 tempLen = g_cirMaxBufferSize - p->logBufLen;
1148       S32 remlen = len-tempLen;
1149       if ((tempLen < 0) || (remlen < 0))
1150       {
1151          RETVOID;
1152       }
1153                 if(remlen == 0)
1154                 {
1155                         g_rlogPositionIndex = 0;
1156          g_prevLogOffset = 0;
1157                 }
1158                 else
1159                 {
1160                         g_rlogPositionIndex = remlen/50;
1161                 }
1162
1163       /* we are unlikely to hit this condition, but to prevent corruption of binary logs */
1164       /* we cannot write the data, if we write, data will be corrected forever */
1165       if( remlen > p->logReadPos )
1166       {
1167          fprintf(stderr, "cannot write data.retune buffer parameters\n");
1168          return;
1169       }
1170                 if( (p->logReadPos -  remlen) < RLOG_READ_POS_THRESHOLD && !thread_signalled )
1171       {
1172                         pthread_cond_signal(&g_cond); /* this will wakeup thread */
1173                 }
1174
1175
1176       /* Copy data till end of the buffer */
1177       memcpy(p->logBuff+p->logBufLen, buf, tempLen);
1178       /* Copy remaining data from the start of buffer */
1179       memcpy(p->logBuff, ((const U8 *)buf)+tempLen, remlen);
1180       /* Store buffer length position */
1181       p->logBufLen = len-tempLen;
1182    }
1183    else
1184    {
1185       /* if reader is far behind and writer is reaching reader position, diff < 5Kb */
1186       /* its time to wakeup thread if reader has not read much of data */
1187       if( p->logReadPos > p->logBufLen && (p->logReadPos - p->logBufLen) < RLOG_READ_POS_THRESHOLD && !thread_signalled )
1188          pthread_cond_signal(&g_cond); /* this will wakeup thread */
1189
1190                 g_rlogPositionIndex += (len/50);
1191       memcpy(p->logBuff+p->logBufLen, buf, len);
1192       p->logBufLen += len;
1193    }
1194 #else
1195    /* Directly write received buffer in cpuh log file */
1196    if( fwrite((const void*)buf, 1, len, g_fp) == -1 )
1197    {
1198 #ifdef RLOG_DEBUG_MODE
1199       fprintf(stderr, "Failed to write log data in file\n");
1200       perror("LOG");
1201 #endif
1202       createNewLogFile();
1203    }
1204 #endif
1205
1206 }
1207
1208 void saveLogData(const void* buf, U16 len, U32 g_rlogWritePosIndex)
1209 {
1210
1211    ++g_rlogWriteCount ;
1212
1213    if((1 == g_writeCirBuf) ||
1214          ((g_rlLogCntLimit == RL_LOG_COUNT_LIMIT_START) &&
1215           (g_rlogWriteCount > g_maxRlogCount)) ||
1216          (len > RLOG_FIXED_LENGTH_BUFFER_SIZE))
1217    {
1218       g_rlogPositionIndex --;
1219       g_logsDropCnt++;
1220       return;
1221    }
1222
1223    /* check for if L2 is going to store logs */
1224    if (SFndProcId() == TENB_L2_PROC_ID)
1225    {
1226       if((g_l2LogBufLen + RLOG_FIXED_LENGTH_BUFFER_SIZE) < L2LOG_BUFF_BLOCK_SIZE - sizeof(g_l2LogBufLen) )
1227       {
1228          /* copying logs in shared buffer */
1229          memcpy(g_l2LogBufStartPtr, buf, len);
1230
1231          g_l2LogBufStartPtr += RLOG_FIXED_LENGTH_BUFFER_SIZE;
1232          /* increasing total log length with L2 log length */
1233          g_l2LogBufLen += RLOG_FIXED_LENGTH_BUFFER_SIZE;
1234       }
1235       return;
1236    }
1237 #ifdef RLOG_USE_CIRCULAR_BUFFER
1238    U32 logWritePointerPosition;
1239    THREAD_DATA* p = (THREAD_DATA*) g_pSingCirBuff;
1240
1241    /* if buffer is about to full, write till end and continue writing from begining */
1242    if( ((g_rlogWritePosIndex+1) * RLOG_FIXED_LENGTH_BUFFER_SIZE) > g_cirMaxBufferSize )
1243    {
1244       /* setting this flag to 1 to avoid other threads
1245          to write in same circular buffer */
1246       g_writeCirBuf = 1;
1247       /* Start globalPositionIndex again */
1248       g_rlogPositionIndex = 0;
1249
1250       /* if reader has not read initial data, minmum buffer size should be 100Kb */
1251       if( p->logReadPos < RLOG_READ_POS_THRESHOLD && !thread_signalled ) {
1252          pthread_cond_signal(&g_cond); /* this will wakeup thread */
1253       }
1254
1255       /* we are unlikely to hit this condition, but to prevent corruption of binary logs */
1256       /* we cannot write the data, if we write, data will be corrected forever */
1257       if( RLOG_FIXED_LENGTH_BUFFER_SIZE > p->logReadPos ) {
1258          fprintf(stderr, "cannot write data.retune buffer parameters\n");
1259          return;
1260       }
1261
1262       /* Copy data from the start of buffer */
1263       memcpy(p->logBuff, buf, len);
1264       /* Store buffer length position */
1265       p->logBufLen = RLOG_FIXED_LENGTH_BUFFER_SIZE;
1266       g_prevLogOffset = 0;
1267       /* setting this flag to 0 so that other threads
1268          will start writing in circular buffer */
1269       g_writeCirBuf = 0;
1270    }
1271    else
1272    {
1273       /* if reader is far behind and writer is reaching reader position, diff < 5Kb */
1274       /* its time to wakeup thread if reader has not read much of data */
1275       if( p->logReadPos > p->logBufLen && (p->logReadPos - p->logBufLen) < RLOG_READ_POS_THRESHOLD )
1276          pthread_cond_signal(&g_cond); /* this will wakeup thread */
1277
1278       logWritePointerPosition = (g_rlogWritePosIndex * RLOG_FIXED_LENGTH_BUFFER_SIZE) + g_prevLogOffset;
1279
1280       memcpy(p->logBuff+logWritePointerPosition, buf, len);
1281       p->logBufLen += RLOG_FIXED_LENGTH_BUFFER_SIZE;
1282    }
1283 #else /* !RLOG_USE_CIRCULAR_BUFFER */
1284    if( fwrite((const void*)buf, 1, RLOG_FIXED_LENGTH_BUFFER_SIZE, g_fp) == -1 )
1285    {
1286 #ifdef RLOG_DEBUG_MODE
1287       fprintf(stderr, "Failed to write log data in file\n");
1288       perror("LOG");
1289 #endif
1290       createNewLogFile();
1291    }
1292 #endif /* RLOG_USE_CIRCULAR_BUFFER */
1293
1294    CHECK_FILE_SIZE
1295
1296       /* If post processor connected send logs */
1297       if( g_nCliSocket &&  send(g_nCliSocket, buf, RLOG_FIXED_LENGTH_BUFFER_SIZE, 0 ) == -1 ) {
1298          closeConnection(g_nCliSocket);
1299          g_nCliSocket = 0;
1300       }
1301
1302 #ifdef RLOG_DEBUG_MODE_2
1303    {
1304       static int maxlen = 0;
1305       if(len > maxlen) {
1306          maxlen = len;
1307          fprintf(stderr, "MAX BUFFER SIZE is binary mode is [%d]\n", maxlen);
1308       }
1309    }
1310 #endif
1311
1312 }
1313
1314 void sendToPostProcessor(const void* buf, U16 len)
1315 {
1316    if( send(g_nCliSocket, buf, len, 0 ) == -1 ) {
1317       perror("ERROR Sending");
1318       closeConnection(g_nCliSocket);
1319       g_nCliSocket = 0;
1320    }
1321 }
1322 void logLevS( LOGID logId, R_LOG_LEVEL logLevel, const char* str, ...)
1323 {
1324    ARGDATA arg; U16 bufsize;
1325
1326
1327    RLOG_SAVE_TIME(arg.logData.logTime);
1328
1329    arg.logData.logId = logId;
1330    arg.logData.argType = LOG_ARG_STR;
1331    arg.logData.logLevel = logLevel;
1332    arg.logData.numOfArgs = 1;
1333    arg.logData.len = strlen(str);
1334
1335    memcpy(arg.buf, (const void*)str, arg.logData.len);
1336    bufsize = sizeof(LOGDATA)+arg.logData.len;
1337
1338    saveLogData((const void*)&arg, bufsize,g_rlogPositionIndex++);
1339 }
1340
1341 void logLevH( LOGID logId, R_LOG_LEVEL logLevel, PSTR hex, int hexlen, ...)
1342 {
1343    ARGDATA arg;
1344    int bufsize;
1345
1346    RLOG_SAVE_TIME(arg.logData.logTime);
1347
1348    arg.logData.logId = logId;
1349    arg.logData.argType = LOG_ARG_HEX;
1350    arg.logData.logLevel = logLevel;
1351    arg.logData.numOfArgs = 1;
1352    arg.logData.len = hexlen;
1353
1354    memcpy(arg.buf, (const void*)hex, hexlen);
1355    bufsize = sizeof(LOGDATA)+arg.logData.len;
1356
1357    saveLogData((const void*)&arg, bufsize,g_rlogPositionIndex++);
1358 }
1359 void logLevE(LOGID logId, R_LOG_LEVEL logLevel, R_SPL_ARG splType, U32 splVal, U32 arg1, U32 arg2,
1360       U32 arg3, U32 arg4, ...)
1361 {
1362    SPL_ARGDATA arg;
1363    int bufsize;
1364
1365    RLOG_SAVE_TIME(arg.logData.logTime);
1366
1367    arg.logData.logId = logId;
1368    arg.logData.argType = LOG_ARG_SPL;
1369    arg.logData.logLevel = logLevel;
1370    if( arg1 ) {
1371       arg.logData.numOfArgs = (arg2 == 0 ) ? 1 : (arg3==0 ? 2 : (arg4==0 ? 3 : 4));
1372    } else {
1373       arg.logData.numOfArgs = 0;
1374    }
1375
1376    arg.logData.len  = sizeof(u_int8_t) + sizeof(U32) + (sizeof(U32)*arg.logData.numOfArgs);
1377
1378    arg.splEnum = splType;
1379    arg.splArg = splVal;
1380    arg.arg1 = arg1;
1381    arg.arg2 = arg2;
1382    arg.arg3 = arg3;
1383    arg.arg4 = arg4;
1384
1385    bufsize = sizeof(LOGDATA)+arg.logData.len;
1386
1387    saveLogData((const void*)&arg, bufsize,g_rlogPositionIndex++);
1388 }
1389
1390 void logLev0( LOGID logId, R_LOG_LEVEL logLevel, ...)
1391 {
1392    //LOGDATA logData;
1393    ARG4DATA arg;
1394
1395    RLOG_SAVE_TIME(arg.logData.logTime);
1396
1397    arg.logData.logId = logId;
1398    arg.logData.argType = LOG_ARG_STR;
1399    arg.logData.logLevel = logLevel;
1400    arg.logData.numOfArgs = 0;
1401    arg.logData.len = 0;
1402
1403    saveLogData((const void*)&arg, sizeof(LOGDATA),g_rlogPositionIndex++);
1404 }
1405
1406 void logLev1( LOGID logId, R_LOG_LEVEL logLevel, U32 arg1, ...)
1407 {
1408    ARG4DATA arg;
1409    int bufsize;
1410
1411    RLOG_SAVE_TIME(arg.logData.logTime);
1412
1413    arg.logData.logId = logId;
1414    arg.logData.argType = LOG_ARG_INT;
1415    arg.logData.logLevel = logLevel;
1416    arg.logData.numOfArgs = 1;
1417    arg.logData.len = sizeof(U32);
1418
1419    arg.arg1 = arg1;
1420    bufsize = sizeof(LOGDATA)+arg.logData.len;
1421
1422    saveLogData((const void*)&arg, bufsize,g_rlogPositionIndex++);
1423 }
1424 void logLev2( LOGID logId, R_LOG_LEVEL logLevel, U32 arg1, U32 arg2, ...)
1425 {
1426    ARG4DATA arg;
1427    int bufsize;
1428
1429    RLOG_SAVE_TIME(arg.logData.logTime);
1430
1431    arg.logData.logId = logId;
1432    arg.logData.argType = LOG_ARG_INT;
1433    arg.logData.logLevel = logLevel;
1434    arg.logData.numOfArgs = 2;
1435    arg.logData.len =  2 * sizeof(U32);
1436
1437    arg.arg1 = arg1;
1438    arg.arg2 = arg2;
1439
1440    bufsize = sizeof(LOGDATA)+arg.logData.len;
1441
1442    saveLogData((const void*)&arg, bufsize,g_rlogPositionIndex++);
1443 }
1444 void logLev3( LOGID logId, R_LOG_LEVEL logLevel, U32 arg1, U32 arg2, U32 arg3, ...)
1445 {
1446    ARG4DATA arg;
1447    int bufsize;
1448
1449    RLOG_SAVE_TIME(arg.logData.logTime);
1450
1451    arg.logData.logId = logId;
1452    arg.logData.argType = LOG_ARG_INT;
1453    arg.logData.logLevel = logLevel;
1454    arg.logData.numOfArgs = 3;
1455    arg.logData.len = 3 * sizeof(U32);
1456
1457    arg.arg1 = arg1;
1458    arg.arg2 = arg2;
1459    arg.arg3 = arg3;
1460
1461    bufsize = sizeof(LOGDATA)+arg.logData.len;
1462
1463    saveLogData((const void*)&arg, bufsize,g_rlogPositionIndex++);
1464 }
1465 void logLev4( LOGID logId, R_LOG_LEVEL logLevel, U32 arg1, U32 arg2, U32 arg3, U32 arg4, ...)
1466 {
1467    ARG4DATA arg;
1468
1469    RLOG_SAVE_TIME(arg.logData.logTime);
1470
1471    arg.logData.logId = logId;
1472    arg.logData.argType = LOG_ARG_INT;
1473    arg.logData.logLevel = logLevel;
1474    arg.logData.numOfArgs = 4;
1475    arg.logData.len = 4 * sizeof(U32);
1476
1477    arg.arg1 = arg1;
1478    arg.arg2 = arg2;
1479    arg.arg3 = arg3;
1480    arg.arg4 = arg4;
1481
1482    saveLogData((const void*)&arg, sizeof(ARG4DATA),g_rlogPositionIndex++);
1483 }
1484
1485 #endif /* BINARY LOGGING */
1486
1487 #if defined(RLOG_ENABLE_TEXT_LOGGING)
1488 struct tm* getTime(int* microseconds)
1489 {
1490 #ifndef SS_LINUX
1491    struct timespec ptime;
1492 #else
1493    struct timeval ptime;
1494 #endif
1495
1496 #ifndef SS_LINUX
1497    clock_gettime(CLOCK_REALTIME, &ptime);
1498    *microseconds = ptime.tv_nsec / 1000;
1499 #else
1500    gettimeofday(&ptime, NULL);
1501    *microseconds = ptime.tv_usec;
1502 #endif
1503
1504    /* Obtain the time of day, and convert it to a tm struct. --*/
1505    return localtime (&ptime.tv_sec);
1506 }
1507 #elif !defined(RLOG_USE_TTI_LOGGING)
1508 static void getLogTime(LOGTIME* logTime)
1509 {
1510 #ifndef SS_LINUX
1511    struct timespec ptime;
1512 #else
1513    struct timeval ptime;
1514 #endif
1515
1516 #ifndef SS_LINUX
1517    clock_gettime(CLOCK_REALTIME, &ptime);
1518    logTime->ms_tti = ptime.tv_nsec / 1000;
1519 #else
1520    gettimeofday(&ptime, NULL);
1521    logTime->ms_tti = ptime.tv_usec/1000;
1522 #endif
1523
1524    logTime->tv_sec = ptime.tv_sec;
1525 }
1526
1527 #endif
1528
1529 void getLogTimeStr(char* ts)
1530 {
1531 #ifndef SS_LINUX
1532    struct timespec ptime;
1533 #else
1534    struct timeval ptime;
1535 #endif
1536    struct tm* tm;
1537    int microseconds;
1538
1539 #ifndef SS_LINUX
1540    clock_gettime(CLOCK_REALTIME, &ptime);
1541    microseconds = ptime.tv_nsec / 1000;
1542 #else
1543    gettimeofday(&ptime, NULL);
1544    microseconds = ptime.tv_usec/1000;
1545 #endif
1546
1547    /* Obtain the time of day, and convert it to a tm struct. --*/
1548    tm = localtime (&ptime.tv_sec);
1549
1550    if (tm) sprintf(ts,"%d_%d_%d_%d_%d_%d.%03d", tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
1551          tm->tm_hour, tm->tm_min,tm->tm_sec,microseconds);
1552 }
1553 ///////////////////////////////////////////////////////////////////////////////////////////////////
1554 //
1555 //
1556 ///////////////////////////////////////////////////////////////////////////////////////////////////
1557
1558 void rlEnaBleBufferedIO(void)
1559 {
1560    setvbuf (g_fp, NULL, _IOFBF, 1024 );
1561 }
1562
1563 void createNewLogFile()
1564 {
1565    FILE *fp, *prev_fp = g_fp;
1566    char curTime[RLOG_MAX_TIME_STAMP]; int fd;
1567    char *temptr;
1568    /* Fix for CR ccpu00143040 */
1569    DIR *dir = NULLP;
1570
1571    /* get current time, when file is created */
1572    getLogTimeStr(curTime);
1573    temptr = strchr(curTime, '.');
1574    if (temptr != NULLP)
1575    {
1576       *temptr = 0;
1577    }
1578    /* Fix for CR ccpu00143040 */
1579    dir  = opendir(g_logDir);
1580    if ( dir == NULLP )
1581    {
1582       mkdir(g_logDir, O_RDWR);
1583    }
1584    else
1585    {
1586       closedir(dir);
1587    }
1588    /* remove old file from system */
1589    if( g_fileList[g_nCurrFileIdx][0] != '\0' )
1590       unlink(g_fileList[g_nCurrFileIdx]);
1591
1592 #ifdef RLOG_ENABLE_TEXT_LOGGING
1593    /* create file name, Example-> dbglog_2013_08_11_15_30_00 */
1594    snprintf(g_fileList[g_nCurrFileIdx],MAX_FILENAME_LEN, "%s/%s_%s.txt",g_logDir, g_fileName, curTime );
1595    fp = fopen(g_fileList[g_nCurrFileIdx], "w+");
1596 #else
1597    snprintf(g_fileList[g_nCurrFileIdx],MAX_FILENAME_LEN, "%s/%s_%s.bin",g_logDir, g_fileName, curTime );
1598    fp = fopen(g_fileList[g_nCurrFileIdx], "ab+");
1599 #endif
1600
1601    if( fp == NULL ) {
1602       fprintf(stderr, "Failed to open log file %s\n", g_fileList[g_nCurrFileIdx]);
1603       return;
1604    }
1605
1606    fd = fileno(fp);
1607
1608    g_fp = fp;
1609    g_fd = fd;
1610
1611    if( fcntl(g_fd, F_SETFL, fcntl(g_fd, F_GETFL, 0) | O_NONBLOCK | O_ASYNC ) == -1 ) {
1612       fprintf(stderr, "RLOG: Cannot enable Buffer IO or make file non-blocking\n");
1613    }
1614
1615 #ifdef RLOG_ENABLE_TEXT_LOGGING
1616    setvbuf ( fp , NULL, _IOLBF, 1024 );
1617 #else
1618    setvbuf ( fp , NULL, _IONBF, 1024 );
1619 #endif
1620
1621 #ifndef RLOG_ENABLE_TEXT_LOGGING
1622    storeFileHeader(fp);
1623 #endif
1624
1625    if( prev_fp != NULL )
1626       fclose(prev_fp);
1627
1628    if( ++g_nCurrFileIdx == g_nMaxLogFiles )
1629       g_nCurrFileIdx = 0;
1630
1631 #ifndef RLOG_ENABLE_TEXT_LOGGING
1632 #ifdef RLOG_USE_TTI_LOGGING
1633    logLev1(L_TIME_REFERENCE, L_ALWAYS, (U32)time(NULL));
1634 #endif
1635 #endif
1636 }
1637
1638 void createL2LogFile()
1639 {
1640    FILE *fp, *prev_fp = g_fp;
1641    int fd;
1642    char file[MAX_FILENAME_LEN];
1643
1644    strncpy(g_logDir, "/root/", MAX_FILENAME_LEN);
1645    strncpy(g_fileName, "dbglog_l2", MAX_FILENAME_LEN);
1646    snprintf(file, sizeof(file), "%s/%s.txt", g_logDir, g_fileName);
1647
1648    fp = fopen(file, "w+");
1649    if( fp == NULL) {
1650       printf("Failed to open file %s", file);
1651       _exit(0);
1652    }
1653
1654    printf("Created L2 bin file FD=%s\n", g_fileName);
1655
1656    setvbuf (fp , NULL, _IONBF, 1024 );
1657
1658    fd = fileno(fp);
1659
1660    g_fp = fp;
1661    g_fd = fd;
1662
1663    if( fcntl(g_fd, F_SETFL, fcntl(g_fd, F_GETFL, 0) | O_NONBLOCK | O_ASYNC ) == -1 ) {
1664       fprintf(stderr, "RLOG: Cannot enable Buffer IO or make file non-blocking\n");
1665    }
1666
1667    setvbuf ( fp , NULL, _IOLBF, 1024 );
1668
1669    if( prev_fp != NULL )
1670       fclose(prev_fp);
1671
1672    if( ++g_nCurrFileIdx == g_nMaxLogFiles )
1673       g_nCurrFileIdx = 0;
1674
1675
1676 }
1677
1678 //////////////////////////////////////////////////////////////////////////
1679 //  @Function    : rlUdateRlogTti
1680 //  @Discription : This function will be called every 10 ms whenever
1681 //                 application layer update the tti count
1682 //  @in          : void
1683 //  @out         : void
1684 //////////////////////////////////////////////////////////////////////////
1685 void rlUpdateRlogTti(Void)
1686 {
1687 #ifndef RLOG_ENABLE_TEXT_LOGGING
1688 #ifdef RLOG_USE_TTI_LOGGING
1689    logLev1(L_TIME_TTI_UPDT, L_ALWAYS, (U32)time(NULL));
1690 #endif
1691 #endif
1692 }
1693
1694 /* This function processes log buffer received from L2
1695    mBuf is Received from L2 through SPstTsk. This function
1696    extracts buffer pointer and logLen and then these logs
1697    written to L3 log buffer/file.
1698    This function is called in application layer when EVTL2LOGBUF
1699    event is recieved from ssi
1700 */
1701
1702 #ifdef ANSI
1703 PUBLIC Void rlProcessLogBufFromL2
1704 (
1705  void *mBuf
1706  )
1707 #else
1708 PUBLIC Void rlProcessLogBufFromL2(mBuf)
1709    void *mBuf;
1710 #endif
1711 {
1712 #ifndef RLOG_ENABLE_TEXT_LOGGING
1713    U32 logLength;
1714    Data* logPtr;
1715    startL2Logging = 1;
1716    if(mBuf == NULL)
1717    {
1718       printf("NULL MBUF received \n");
1719       RETVOID;
1720    }
1721    /* Get Buffer pointer and length. This is SOC specific function which
1722       will extract Log-Buffer pointer and length from mBuf */
1723    rlGetL2LogBufPtr(mBuf, &logLength,&logPtr);
1724    rlSetL2LogBuf(logPtr,logLength);
1725    readL2LogBuff();
1726 #endif
1727    RETVOID;
1728 }
1729
1730 /* This function will get tick from RLC/CL and will process logs
1731    according to tick threshold. Tick threshold is SOC specific */
1732 PUBLIC Void rlProcessTicks(void)
1733 {
1734    static U32 rlogTickCount;
1735    numTtiTicks++;
1736    if(++rlogTickCount >= RLOGTICKSCNTTOPRCL2LOGS)
1737    {
1738       rlogTickCount = 0;
1739       rlResetLogRateLmt(); /* Resetting rlog write count to 0 */
1740
1741       /* Tick count reached configured ticks to send L2 logs,
1742          Send existing log buffer to Application and create
1743          new log buffer to write logs */
1744       if (SFndProcId() == TENB_L2_PROC_ID)
1745       {
1746 #ifndef RLOG_ENABLE_TEXT_LOGGING
1747          processL2LogBuff(); /* This processing of log buffer is done on L2 only
1748                                 This is SOC specific function and use to send
1749                                 log buffers to L3 and reset buffer pointer to
1750                                 write logs */
1751 #else
1752      /* Write functions specific to Text logging in cpul */
1753 #endif
1754       }
1755       else
1756       {
1757          /* L3 specific functions */
1758       }
1759    }
1760    RETVOID;
1761 }
1762
1763 #ifndef RLOG_ENABLE_TEXT_LOGGING
1764 //////////////////////////////////////////////////////////////////////////
1765 //  @Function    : readL2LogBuff
1766 //  @Description : This function first validates received Log Buffer and
1767 //                 length from L2 and then writes L2 log buffer into L3
1768 //                 circular buffer. After reading it invalidates cache and
1769 //                 also resets global Log buffer pointer and lenth variable.
1770 //  @in          : void
1771 //  @out         : void
1772 //////////////////////////////////////////////////////////////////////////
1773
1774 PUBLIC Void readL2LogBuff(void)
1775 {
1776    /* Validate global buffer pointer and length */
1777    U8 ret;
1778    ret = rlValidateL2LogBuf();
1779    if(ret != ROK)
1780    {
1781       printf(" Validation failed for log buffer/len \n");
1782       return;
1783    }
1784    g_writeCirBuf = 1;
1785    saveLogDataFromCpul(g_logBufRcvdFromL2 , g_logBufLenRcvdFromL2 );
1786    /* TODO: Write SOC Specific function to invalidate cache */
1787    rlInvalidateL2LogsInCache(g_logBufRcvdFromL2 - sizeof(g_logBufLenRcvdFromL2) , (g_logBufLenRcvdFromL2 + sizeof(g_logBufLenRcvdFromL2)));
1788    rlResetL2LogBuf();
1789    g_writeCirBuf = 0;
1790    RETVOID;
1791 }
1792
1793 //////////////////////////////////////////////////////////////////////////
1794 //  @Function    : rlStopLogCountLimit
1795 //  @Description : This function validates L2 Log buffer,length, and start
1796 //                 L2 logging flag.
1797 //  @in          : void
1798 //  @out         : void
1799 //////////////////////////////////////////////////////////////////////////
1800
1801 #ifdef ANSI
1802 PUBLIC S16 rlValidateL2LogBuf(void)
1803 #else
1804 PUBLIC S16 rlValidateL2LogBuf(void)
1805 #endif
1806 {
1807    S16 ret = ROK;
1808    if(g_logBufRcvdFromL2 == NULL)
1809    {
1810       printf("Log-Buffer received from L2 is NULL \n");
1811       ret = RFAILED;
1812    }
1813    if(g_logBufLenRcvdFromL2 == 0)
1814    {
1815       printf("Log-Buffer Length received from L2 is 0 \n");
1816       ret = RFAILED;
1817    }
1818    if(startL2Logging == 0)
1819    {
1820       printf("startL2Logging flag is still inactive \n");
1821       ret = RFAILED;
1822    }
1823
1824    return(ret);
1825 }
1826
1827 //////////////////////////////////////////////////////////////////////////
1828 //  @Function    : rlStopLogCountLimit
1829 //  @Description : This function set global log Buffer pointer & length
1830 //  @in          : l2LogBuf  -  Log Buffer to be set in global pointer
1831 //                 l2LogLen  -  Log length to be set in global lenth
1832 //  @out         : void
1833 //////////////////////////////////////////////////////////////////////////
1834
1835 #ifdef ANSI
1836 PUBLIC void rlSetL2LogBuf
1837 (
1838 U8 *l2LogBuf,
1839 U32 l2logLen
1840 )
1841 #else
1842 PUBLIC void rlSetL2LogBuf(l2LogBuf,l2logLen)
1843 U8 *l2LogBuf;
1844 U32 l2logLen;
1845 #endif
1846 {
1847    g_logBufRcvdFromL2      = l2LogBuf;
1848    g_logBufLenRcvdFromL2   = l2logLen;
1849 }
1850
1851 //////////////////////////////////////////////////////////////////////////
1852 //  @Function    : rlStopLogCountLimit
1853 //  @Description : This function flushes global log Buffer pointer & length
1854 //  @in          : void
1855 //  @out         : void
1856 //////////////////////////////////////////////////////////////////////////
1857
1858 #ifdef ANSI
1859 PUBLIC void rlResetL2LogBuf
1860 (
1861 void
1862 )
1863 #else
1864 PUBLIC void rlResetL2LogBuf(void)
1865 #endif
1866 {
1867    g_logBufRcvdFromL2      = NULL;
1868    g_logBufLenRcvdFromL2   = 0;
1869 }
1870
1871 #endif
1872
1873 //////////////////////////////////////////////////////////////////////////
1874 //  @Function    : rlStartLogCountLimit
1875 //  @Discription : This function will be called by EnbApp after Cell is UP.
1876 //                 This function start the log cnt limit. i.e Number of logs
1877 //                 getting logged into curcular will be restricted to 100 logs.
1878 //  @in          : void
1879 //  @out         : void
1880 //////////////////////////////////////////////////////////////////////////
1881
1882 void rlStartLogCountLimit(Void)
1883 {
1884    g_rlogWriteCount = 0;
1885    g_rlLogCntLimit = RL_LOG_COUNT_LIMIT_START;
1886    printf("Start Log Restriction\n");
1887 }
1888
1889 //////////////////////////////////////////////////////////////////////////
1890 //  @Function    : rlStopLogCountLimit
1891 //  @Discription : This function will be called by EnbApp after Cell Shutdown
1892 //                 is triggered. This will enable to get all logs of shutdown.
1893 //                 This function stops the log cnt limit. i.e Restricition on
1894 //                 Number of logs getting logged into curcular will be removed
1895 //  @in          : void
1896 //  @out         : void
1897 //////////////////////////////////////////////////////////////////////////
1898
1899 void rlStopLogCountLimit(Void)
1900 {
1901    printf("Stop Log Restriction\n");
1902    g_rlLogCntLimit = RL_LOG_COUNT_LIMIT_STOP;
1903 }
1904
1905 //////////////////////////////////////////////////////////////////////////
1906 //  @Function    : rlResetLogRateLmt
1907 //  @Discription : This function will be called every 10 ms whenever
1908 //                 application layer update the tti count. To reset the
1909 //                 log rate control. And Enable logging for next 10 ms
1910 //  @in          : void
1911 //  @out         : void
1912 //////////////////////////////////////////////////////////////////////////
1913
1914 void rlResetLogRateLmt(void)
1915 {
1916     g_rlogWriteCount = 0;
1917     g_logsDropCnt = 0;
1918 }
1919
1920 void initGlbDataAtL2(void)
1921 {
1922    strncpy(g_logDir, "/root/", MAX_FILENAME_LEN);
1923 }
1924
1925 /**********************************************************************
1926          End of file
1927 **********************************************************************/