clDebugApi.h

Go to the documentation of this file.

/*
 * Copyright (C) 2002-2012 OpenClovis Solutions Inc.  All Rights Reserved.
 *
 * This file is available  under  a  commercial  license  from  the
 * copyright  holder or the GNU General Public License Version 2.0.
 * 
 * The source code for  this program is not published  or otherwise 
 * divested of  its trade secrets, irrespective  of  what  has been 
 * deposited with the U.S. Copyright office.
 * 
 * This program is distributed in the  hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied  warranty  of 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 
 * General Public License for more details.
 * 
 * For more  information, see  the file  COPYING provided with this
 * material.
 */
/*******************************************************************************
* ModuleName  : debug
* File        : clDebugApi.h
*******************************************************************************/

/*******************************************************************************
* Description :
*   This This module contains common DEBUG definitions
******************************************************************************/

#ifndef _CL_DEBUG_API_H_
#define _CL_DEBUG_API_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <clCommon.h>
#include <clDebugErrors.h>
#include <clHandleApi.h>
#include <clLogApi.h>
#include <clRmdIpi.h>
#ifndef __KERNEL__
#include <stdio.h>
#include <unistd.h>
#include <time.h>
#endif

#ifdef SOLARIS_BUILD
#include <ucontext.h>
#include <stdlib.h>
#include <string.h>
int  backtrace(void **buffer, int count);
char **backtrace_symbols(void *const *array, int size);
void backtrace_symbols_fd(void *const *array, int size, int fd);
#endif /* SOLARIS_BUILD */

/******************************************************************************
 *  Constant and Macro Definitions
 *****************************************************************************/

#define CL_DEBUG_CRITICAL 3

#define CL_DEBUG_ERROR    4

#define CL_DEBUG_WARN     5

#define CL_DEBUG_INFO     7

#define CL_DEBUG_TRACE    0xc

#if !defined(CL_DEBUG_LEVEL_THRESHOLD)
#define CL_DEBUG_LEVEL_THRESHOLD CL_DEBUG_ERROR
#endif

#ifndef CL_DEBUG
#define CL_DEBUG
#endif

#ifdef CL_DEBUG
#ifndef __KERNEL__
#include <clEoApi.h>
#include <clDbg.h>

#define CL_DEBUG_SP(...) __VA_ARGS__


enum
  {
    clDebugTimeStrMaxLen = 128
  };

#define CL_DEBUG_PRINT(x,y) \
    do \
    {\
        char __str[256]; \
        if(x <= CL_DEBUG_LEVEL_THRESHOLD) \
        {\
            snprintf(__str,256,CL_DEBUG_SP y); \
            clLog((ClLogSeverityT)x, CL_LOG_AREA_UNSPECIFIED, CL_LOG_CONTEXT_UNSPECIFIED,\
                  __str);\
        }\
           if (1) \
          { \
            snprintf(__str,256,CL_DEBUG_SP y); \
            clDbgMsg((int)getpid(),__FILE__, __LINE__, __FUNCTION__,x,__str); \
          } \
    }while (0)

#define CL_DEBUG_PRINT_CONSOLE(x,y)                                     \
    do                                                                  \
    {                                                                   \
        char __str[256];                                                \
        if(x <= CL_DEBUG_LEVEL_THRESHOLD)                               \
        {                                                               \
            snprintf(__str,256,CL_DEBUG_SP y);                          \
            clLogConsole((ClLogSeverityT)x, CL_LOG_AREA_UNSPECIFIED, CL_LOG_CONTEXT_UNSPECIFIED, \
                  __str);                                               \
        }                                                               \
        if (1)                                                          \
        {                                                               \
            snprintf(__str,256,CL_DEBUG_SP y);                          \
            clDbgMsg((int)getpid(),__FILE__, __LINE__, __FUNCTION__,x,__str); \
        }                                                               \
    }while (0)

#else /* __KERNEL__ */

#define CL_DEBUG_PRINT(x,y) \
    do \
    {  \
        if(x <= CL_DEBUG_LEVEL_THRESHOLD) \
        {\
            printk("file:%s,func:%s,line:%d: ", __FILE__, __FUNCTION__, __LINE__);\
            printk y; \
        }\
    }while (0)

#define CL_DEBUG_PRINT_CONSOLE CL_DEBUG_PRINT

#endif

#else /* CL_DEBUG */
#define CL_DEBUG_PRINT(x,y)
#define CL_DEBUG_PRINT_CONSOLE(x, y)
#endif

#define CL_FUNC_ENTER()


#define CL_FUNC_EXIT()


#ifndef __KERNEL__
#include <assert.h>
#define CL_ASSERT(expr) do { if (clDbgPauseOnCodeError&&(!(expr))) clDbgCodeError(0,("Assertion failed")); else assert((expr)); } while(0)   
#endif /* __KERNEL__ */

struct clEoExecutionObj;

#define CL_DEBUG_COMP_PROMPT_LEN   15


#define CL_DEBUG_COMP_NAME_LEN   128


#define CL_DEBUG_FUNC_NAME_LEN    41

#define CL_DEBUG_FUNC_HELP_LEN    201

typedef ClRcT (*ClDebugCallbackT) (

    ClUint32T argc,

    ClCharT** argv,

    ClCharT** ret);

typedef struct ClDebugFuncEntryT
{
    ClDebugCallbackT  fpCallback;

    ClCharT           funcName[CL_DEBUG_FUNC_NAME_LEN];

    ClCharT           funcHelp[CL_DEBUG_FUNC_HELP_LEN];
} ClDebugFuncEntryT;

typedef struct ClDebugModEntryT {

    char modName[80];

    char modPrompt[20];

    ClDebugFuncEntryT *cmdList;
    char help[80];
} ClDebugModEntryT;

typedef ClPtrT ClDebugPrintHandleT;

/*****************************************************************************
 *  Debug APIs
 *****************************************************************************/

ClRcT clDebugCli(
   CL_IN ClCharT *nprompt /*this string is incorporated into the debug CLI prompt*/);


ClRcT clDebugLibInitialize(void);



ClRcT clDebugLibFinalize(void);

 ClRcT clDebugPromptSet(CL_IN  const ClCharT  *pCompPrompt);

ClRcT clDebugRegister(CL_IN  ClDebugFuncEntryT  *funcArray,
                      CL_IN  ClUint32T          funcArrayLen, 
                      CL_OUT ClHandleT          *phDebugReg);



ClRcT clDebugDeregister(CL_IN  ClHandleT  hReg);

ClRcT clDebugPrintInitialize(CL_OUT ClDebugPrintHandleT* msg /*handle for printing*/);


ClRcT clDebugPrint(CL_INOUT ClDebugPrintHandleT msg,
                   CL_IN    const char* fmtStr, 
                   ...) CL_PRINTF_FORMAT(2, 3);


ClRcT clDebugPrintFinalize(CL_IN ClDebugPrintHandleT* msg,
                           CL_OUT char** buf);


ClRcT clDebugPrintDestroy(CL_INOUT ClDebugPrintHandleT* msg);

ClRcT clDebugVersionCheck(CL_INOUT ClVersionT *pVersion);

ClRcT clDebugResponseSend(ClRmdResponseContextHandleT responseHandle,
                          ClBufferHandleT *pOutMsgHandle,
                          ClCharT *respBuffer,
                          ClRcT retCode);
ClRcT clDebugResponseDefer(ClRmdResponseContextHandleT *pResponseHandle, ClBufferHandleT *pOutMsgHandle);

#ifdef __cplusplus
}
#endif

#endif /* _CL_DEBUG_API_H_ */