clCommon.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  : include                                                       
 * File        : clCommon.h
 *******************************************************************************/

/*******************************************************************************
 * Description :                                                                
 *
 * This header file contains all the common data types used across ASP
 *
 *
 *****************************************************************************/

#ifndef _CL_COMMON_H_
#define _CL_COMMON_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <clArchHeaders.h>    

/******************************************************************************
 *  Clovis Data Types 
 *****************************************************************************/

#define CL_TRUE         1

#define CL_FALSE        0

#define CL_YES          1

#define CL_NO           0

#define CL_ENABLE   1

#define CL_DISABLE  0

typedef enum {
    CL_STATUS_DOWN = 0,

    CL_STATUS_UP   = 1,
} ClStatusT;



#define CL_MIN(a,b) ( (a) < (b) ? (a) : (b) )

#define CL_MAX(a,b) ( (a) > (b) ? (a) : (b) )

#define CL_ROUNDUP(VAL,BASE)   (((VAL) + (BASE) - 1)/(BASE) * (BASE))

#define CL_ROUNDDOWN(VAL,BASE)  ((VAL)/(BASE) * (BASE))

#define CL_SIZEOF_ARRAY(__ArrayName__) sizeof((__ArrayName__)) / sizeof((__ArrayName__)[0])

#define CL_IN

#define CL_INOUT

#define CL_OUT

/* Note: for the 64 bit types, align yourself using "__attribute__((__aligned__(8)))".
   We cannot align automatically as part of this typedef, since SAF does not align its 
   corresponding type. See bug 7155  */
typedef unsigned long long  ClUint64T; 
typedef signed long long    ClInt64T;  

typedef unsigned int        ClUint32T;
typedef signed int          ClInt32T;
typedef unsigned short      ClUint16T;
typedef signed short        ClInt16T;
typedef unsigned char       ClUint8T;
typedef signed char         ClInt8T;
typedef char                ClCharT; /* Use this for strings */
typedef signed int          ClFdT;   /* Use this for file descriptors */
/* 
 * Special type with word size for portability b/n 32 & 64 bit 
 * Recommended type would be intptr_t but not working for some
 * reason. Need to fix this - Mynk
 */
typedef unsigned long       ClWordT;


typedef ClUint16T           ClBoolT;

typedef ClWordT             ClPidT;

#define CL_MICRO_TO_NANO  1000ULL

#define CL_MILLI_TO_MICRO 1000ULL

#define CL_SEC_TO_MILLI   1000ULL

#define CL_MILLI_TO_NANO  (CL_MICRO_TO_NANO * CL_MILLI_TO_MICRO)

#define CL_SEC_TO_NANO    (CL_MILLI_TO_NANO * CL_SEC_TO_MILLI)

#define CL_TIME_END             0x7fffffffffffffffULL

#define CL_TIME_FOREVER         0x7fffffffffffffffULL

typedef ClInt64T            ClTimeT;
typedef ClUint64T           ClHandleT;
typedef ClUint64T           ClSizeT;
typedef ClInt64T            ClOffsetT;
typedef ClUint64T           ClInvocationT;
typedef ClUint64T           ClSelectionObjectT;
typedef ClUint64T           ClNtfIdentifierT;
typedef ClInt8T             *ClAddrT;
typedef void*               ClPtrT;

typedef ClUint32T       ClRcT;

typedef ClRcT (*ClCallbackT) (CL_IN ClPtrT invocation);

typedef union cl_u64_u /* FIXME: This is not endian-safe; shouldn't be used */
    {
    struct {
        ClUint32T high;
        ClUint32T low;
        } DWord;
    ClUint32T dWords[2];
    ClUint16T words[4];
    ClInt8T bytes[8];
    } ClUnion64T;


#define CL_MAX_NAME_LENGTH  256

typedef struct {
    ClUint16T       length;
    ClCharT         value[CL_MAX_NAME_LENGTH];
} ClNameT;

void clNameSet(ClNameT* name, const char* str);

void clNameCopy(ClNameT* nameOut, const ClNameT *nameIn);

void clNameConcat(ClNameT* nameOut, const ClNameT *prefix, const char* separator, const ClNameT *suffix);

ClCharT *clStrdup(const ClCharT *str);

ClBoolT clParseEnvBoolean(ClCharT* envvar);

ClCharT *clParseEnvStr(const ClCharT* envvar);

ClInt32T clCreatePipe(ClInt32T fds[2], ClUint32T numMsgs, ClUint32T msgSize);

ClUint32T clBinaryPower(ClUint32T size);

typedef struct {
    ClUint8T  releaseCode;
    ClUint8T  majorVersion;
    ClUint8T  minorVersion;
} ClVersionT;

typedef enum {
    CL_DISPATCH_ONE         = 1,
    CL_DISPATCH_ALL         = 2,
    CL_DISPATCH_BLOCKING    = 3,
} ClDispatchFlagsT;

/*****************************************************************************
 *  Bit related Types 
 *****************************************************************************/
#define CL_FORCED_TO_8BITS      0xff
#define CL_FORCED_TO_16BITS     0xffff
#define CL_FORCED_TO_32BITS     0xffffffff
#define CL_BITS_PER_BYTE        8
#define CL_BIT(X)               (0x1 << (X))

#if 0
typedef enum ClMetricId
{
    CL_METRIC_ALL,
    CL_METRIC_CPU,
    CL_METRIC_MEM,
    CL_METRIC_MAX,
}ClMetricIdT;

typedef struct ClMetric
{
    const ClCharT *pType;
    ClMetricIdT id;
    ClUint32T maxThreshold;
    ClUint32T currentThreshold;
    ClUint32T maxOccurences;
    ClUint32T numOccurences;
}ClMetricT;

#define CL_METRIC_STR(id) \
    ((id) == CL_METRIC_ALL) ? "all" :           \
    ((id) == CL_METRIC_CPU) ? "cpu" :           \
    ((id) == CL_METRIC_MEM) ? "mem" :           \
    "unknown"
#endif    

typedef enum {
    CL_CID_UNSPECIFIED  = 0x0,

    CL_CID_OSAL         = 0x01,
    
    CL_CID_HAL          = 0x02,
    
    CL_CID_DBAL         = 0x03,
    
    CL_CID_EO           = 0x04,
    
    CL_CID_IOC          = 0x05,
    
    CL_CID_RMD          = 0x06,
    
    CL_CID_NAMES        = 0x07,
    
    CL_CID_TIMER        = 0x08,
    
    CL_CID_SHM          = 0x09,
    
    CL_CID_DSHM         = 0x0a,
    
    CL_CID_LOG          = 0x0b,
    
    CL_CID_MSG          = 0x0c,
    
    CL_CID_DIAG         = 0x0d,
    
    CL_CID_DEBUG        = 0x0e,
    
    CL_CID_CPM          = 0x0f,
    
    CL_CID_CAP          = 0x10,
    
    CL_CID_RES          = 0x11,
    
    CL_CID_GMS          = 0x12,
    
    CL_CID_EVENTS       = 0x13,
    
    CL_CID_DLOCK        = 0x14,
    
    CL_CID_TXN          = 0x15,
    
    CL_CID_CKPT         = 0x16,
    
    CL_CID_COR          = 0x17,
    
    CL_CID_CNT          = 0x18,
    
    CL_CID_DCNT         = 0x19,
    
    CL_CID_RCNT         = 0x1a,
    
    CL_CID_ALARMS       = 0x1b,
    
    CL_CID_POLICY       = 0x1c,
    
    CL_CID_RULE         = 0x1d,
    
    CL_CID_SCRIPTING    = 0x1e,
    
    CL_CID_CM           = 0x1f,
    
    CL_CID_HPI          = 0x20,
    
    CL_CID_FAULTS       = 0x21,
    
    CL_CID_AMS          = 0x22,
    
    CL_CID_MED          = 0x23,
    
    CL_CID_BUFFER       = 0x24,
    
    CL_CID_QUEUE        = 0x25,
    
    CL_CID_CLIST        = 0x26,
    
    CL_CID_SNMP         = 0x27,
    
    CL_CID_NS           = 0x28,
    
    CL_CID_OM           = 0x29,
    
    CL_CID_POOL         = 0x2a,
    
    CL_CID_CD           = 0x2b,
    
    CL_CID_DM           = 0x2c,
    
    CL_CID_OAMP_RT      = 0x2d,
    
    CL_CID_PROV         = 0x2e,
    
    CL_CID_UM           = 0x2f,
    
    CL_CID_HANDLE       = 0x30,
    
    CL_CID_VERSION      = 0x31,
    
    CL_CID_XDR          = 0x32,
    
    CL_CID_IDL          = 0x33,
    
    CL_CID_HEAP         = 0x34,
    
    CL_CID_MEM          = 0x35,
    
    CL_CID_PARSER       = 0x36,
    
    CL_CID_BACKING_STORAGE = 0x37,

    CL_CID_JOB          = 0x38,
    CL_CID_JOBQUEUE     = 0x38,

    CL_CID_THREADPOOL   = 0x39,
    CL_CID_TASKPOOL     = 0x39,

    CL_CID_BITMAP       = 0x3a,

    
    /* Add more CID here if required */
    CL_CID_LEAKY_BUCKET = 0x3b,

    CL_CID_MSO          = 0x3c,

    CL_CID_PM          = 0x3d,

    CL_CID_NF          = 0x3e,

    CL_CID_MAX 
                                    
} ClCompIdT;

typedef struct ClWaterMark
{
    ClUint64T lowLimit;
    ClUint64T highLimit;
} ClWaterMarkT;

typedef enum
{
    CL_WM_LOW_LIMIT = 0,
    CL_WM_HIGH_LIMIT = 1,
}
ClEoWaterMarkFlagT;

typedef enum{
    CL_WM_LOW,
    CL_WM_HIGH,
    CL_WM_MED,
    CL_WM_SENDQ,
    CL_WM_RECVQ,
    CL_WM_MAX
}ClWaterMarkIdT;

#define CL_WEAK __attribute__((weak))

#define CL_EO_ACTION_CUSTOM  (1<<0)
#define CL_EO_ACTION_EVENT   (1<<1)
#define CL_EO_ACTION_LOG     (1<<2)
#define CL_EO_ACTION_NOT     (1<<3)
#define CL_EO_ACTION_MAX     (1<<31)     // ClUnt8T type bieng used for bitMap 

typedef struct ClEoActionInfo {
    ClUint32T     bitMap;      
} ClEoActionInfoT;

typedef ClPtrT* ClEoActionArgListT;

typedef struct
{
    ClUint32T  length;
    ClCharT    *pValue;
}ClStringT;

extern ClStringT *clStringDup(const ClStringT *);

/* Macro to print into the name */
#define clNamePrintf(name, ...)       \
do                                    \
{                                     \
    name.length = snprintf(name.value, CL_MAX_NAME_LENGTH - 1, __VA_ARGS__);\
    name.value[CL_MIN(name.length, CL_MAX_NAME_LENGTH - 1)] = '\0';         \
}while(0)

#ifdef __GNUC__
#define CL_DEPRECATED __attribute__((__deprecated__))
#define CL_PRINTF_FORMAT(fmtPos, argPos) __attribute__((format(printf, fmtPos, argPos)))
#else
#define CL_DEPRECATED
#define CL_PRINTF_FORMAT(fmtPos, argPos)
#endif

#ifdef __cplusplus
}
#endif

#endif /* _CL_COMMON_H_ */