---

/root/resourcemonitord/resourcemonitord/ResourceMonitorTypes.h

Go to the documentation of this file.

/*M*
BSD License

Copyright (c) 2002, Intel Corporation
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

  a.. Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.
  b.. Redistributions in binary form must reproduce the above copyright notice,
      this list of conditions and the following disclaimer in the documentation
      and/or other materials provided with the distribution.
  c.. Neither the name of Intel Corporation nor the names of its contributors
      may be used to endorse or promote products derived from this software
      without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *M*/

#ifndef     __ResourceMonitorTypes_h__
#define __ResourceMonitorTypes_h__

#include <sys/types.h>
#include <unistd.h>
#include <time.h>
#include "ResourceMonitorErrno.h"

#ifdef __cplusplus
extern "C" {
#endif
#include <uuid/uuid.h>
#define MAX_GUID_STRLEN (sizeof(uuid_t)*2+6)
#ifdef __cplusplus
#include <iostream>

class RMuid
{
public:
    uuid_t id;
public:
    RMuid() { uuid_clear(id); }
    RMuid( const char * idstr ) { uuid_parse((char *)idstr, id); }
    RMuid( const uuid_t  uu ) { uuid_copy(id, (unsigned char *)uu); }
    RMuid( const RMuid  &uu ) { uuid_copy(id, (unsigned char *)uu.id); }
    void clear() { uuid_clear(id); }
    void generate() { uuid_generate(id); }
    void generate_random() { uuid_generate_random(id); }
    void generate_time() { uuid_generate_time(id); }
    int parse( const char * idstr ) { return uuid_parse((char *)idstr, id); }
    void unparse( char *out ) { uuid_unparse(id, out); }
    bool compare( const uuid_t &uu ) { if(uuid_compare((unsigned char *)uu, id)==0) return true; else return false;}
    bool is_null() { if(uuid_is_null(id)) return true; else return false; }
    void print(ostream &out) { char buffer[MAX_GUID_STRLEN]; unparse(buffer); out << buffer; }

    RMuid & operator=(const RMuid &b)
    {
        uuid_copy(id, (unsigned char *)b.id);
        return *this;
    }
    bool operator==(const RMuid &b)
    {
        return compare(b.id);
    }
    bool operator<(const RMuid &b)
    {
        return uuid_compare(id, (unsigned char *)b.id);
    }
};

}
#endif

#ifdef NO_EVENTLOG
typedef int posix_log_severity_t;
typedef int posix_log_notify_t;
typedef int posix_log_query_t;
#include    <syslog.h>
#include    <signal.h>
#else
#include    <posix_evlog.h>
#endif

#define RESOURCE_MONITOR_VERSION_1  1   
#define RESOURCE_MONITOR_VERSION_15 105 
#define RESOURCE_MONITOR_VERSION        RESOURCE_MONITOR_VERSION_15
//#define RM_USING_WIDE_CHARS   1
#ifdef RM_USING_WIDE_CHARS
#include    <wchar.h>
typedef wchar_t rmChar;
#else
typedef char rmChar;
#endif

typedef uuid_t rmUID;
typedef u_int32_t  rmID;
typedef rmChar * rmString;
typedef void * rmHandle;
typedef time_t rmTimeStamp;
typedef time_t rmTimeInterval;
typedef long        rmMicroTimeInterval;
enum rmDescriptions
{
    rmShortDescription = 1, 
    rmLongDescription,          
    rmUnitsDescription,         
    rmDescriptionsEnd           
};

typedef struct
{
#ifdef  InSubsystemMonitor

    rmString    name;
    rmString    description;
#endif  //  InSubsystemMonitor

    rmUID           id;
    size_t          noResources;
    size_t          noStatistics;
} rmSubsystemInfo;


typedef struct
{
#ifdef  InSubsystemMonitor

    rmString    name;
    rmString    description;
#endif  //  InSubsystemMonitor

    rmUID           SubsystemId;
    rmID            id;
} rmResourceInfo;

#define rmPsuedoResourceID  0xffffffff

enum rmStatisticType
{
    rmCounter = 1,      
    rmGauge,                
    rmStatisticTypeEnd          
};

enum rmStatisticSize
{
    rmSizeU32 = 1,  
    rmSizeS32,          
    rmSizeU64,              
    rmSizeS64,          
    rmStatisticSizeEnd          
};

enum rmStatisticScale
{
    rmScaleNone = 1,    
    rmScaleByte,            
    rmScaleKilobyte,        
    rmScaleMegabyte,    
    rmScaleGigabyte,        
    rmScaleTerabyte,    
    rmScalePages,       
    rmScaleJiffies,         
    rmScaleNanosec, 
    rmScaleMicrosec,    
    rmScaleMillisec,        
    rmScaleSec,             
    rmScaleMin,             
    rmScaleHour,            
    rmScaleDay,         
    rmScaleWeek,            
    rmScaleMonth,       
    rmScaleYear,            
    rmStatisticScaleEnd         
};

typedef union
{
    int32_t         rmValueS32;
    u_int32_t       rmValueU32;
    int64_t         rmValueS64;
    u_int64_t       rmValueU64;
} rmValue;


typedef struct
{
#ifdef  InSubsystemMonitor

    rmString    name;
    rmString    description;
    rmString    units;
#endif  //  InSubsystemMonitor

    rmUID           SubsystemId;
    rmID            id;
    enum rmStatisticType    type;
    enum rmStatisticSize size;
    enum rmStatisticScale   scale;
} rmStatisticInfo;

typedef struct
{
    rmUID   SubsystemId;
    rmID    ResourceId;
    rmID    StatisticId;
} rmStatisticKey;
typedef rmStatisticKey rmStatisticId;

typedef struct
{
    rmStatisticKey Stat;
    rmValue Value;
} rmStatisticValue;

enum rmMonitorType
{
    rmThresholding = 1, 
    rmWatermarking,         
    rmLeakyBucket,              
    rmMonitorTypeEnd            
};

//
// Resource monitor control
//

enum rmMonitorLocation
{
    rmInLine = 1,               
    rmDaemon,                       
    rmInLineDaemon,     
    rmMonitorLocationEnd            
};

typedef struct
{
    rmValue         tolerance;
    u_int32_t           samples;
    rmTimeInterval  loggingRate;
} rmThresholdControl;
#define RMThresholdTolerance    typeControl.threshold.tolerance
#define RMThresholdSamples  typeControl.threshold.samples
#define RMThresholdLoggingRate  typeControl.threshold.loggingRate

typedef struct
{
    rmTimeInterval  loggingRate;
} rmLeakyBucketControl;
#define RMLeakyBucketLoggingRate    typeControl.leakyBucket.loggingRate

typedef struct
{
    enum rmMonitorType  monitorType;
    enum rmMonitorLocation location;
    rmUID                   uid;
#define clearMonitorUID(c) (uuid_clear((c).uid))
#define setMonitorUID(c,str) (uuid_parse((char *)(str), (c).uid);
    rmUID                   dataCapture;
#define clearDataCapture(c) (uuid_clear((c).dataCapture))
#define setDataCapture(c,str) (uuid_parse((char *)(str), (c).dataCapture))

    rmTimeInterval  monitoringInterval;
    rmTimeInterval      monitoringRate;
    rmMicroTimeInterval  microMonitoringRate;
    union {
        rmThresholdControl threshold;
        rmLeakyBucketControl leakyBucket;
        // for control of future monitor types
    } typeControl;
} rmMonitorControl;

//
// Resource monitor configuration:
//

enum rmStatisticTransform
{
    rmNone = 1, 
    rmChange,   
    rmPercent,      
    rmPercentChange,    
    rmStatisticTransformEnd         
};

enum rmThresholdType
{
    rmThreshold = 1,                    
    rmBiDirectionalThreshold,   
    rmThresholdTypeEnd          
};

enum rmThresholdTestCondition
{
    rmValueIsAbove = 1, 
    rmValueIsAtOrAbove, 
    rmValueIsAt,                
    rmValueIsAtOrBelow, 
    rmValueIsBelow,         
    rmValueIsNotAt,     
    rmThresholdTestConditionEnd         
};

enum rmThresholdPrecondition
{
    rmNoPrecondition = 1,   
    rmObserveGoodValue,     
    rmThresholdPreconditionEnd          
};

typedef struct
{
    enum rmThresholdType    type;
    rmValue                             thresholdValue;
    enum rmThresholdTestCondition       condition;
    enum rmThresholdPrecondition        precondition;
    posix_log_severity_t            eventSeverity;
    posix_log_severity_t            cancelEventSeverity;
} rmThresholdConfiguration;
#define RMThresholdType typeConfiguration.threshold.type
#define RMThresholdValue    typeConfiguration.threshold.thresholdValue
#define RMThresholdCondition    typeConfiguration.threshold.condition
#define RMThresholdPrecondition typeConfiguration.threshold.precondition
#define RMThresholdEventSeverity    typeConfiguration.threshold.eventSeverity
#define RMThresholdCancelEventSeverity  typeConfiguration.threshold.cancelEventSeverity

typedef struct
{
    rmValue                             bucketSize;
    rmValue                             fillValue;
    posix_log_severity_t            eventSeverity;
} rmLeakyBucketConfiguration;
#define RMbucketSize    typeConfiguration.leakyBucket.bucketSize
#define RMfillValue typeConfiguration.leakyBucket.fillValue
#define RMleakyBucketEventSeverity  typeConfiguration.leakyBucket.eventSeverity

enum rmWatermarkType
{
    rmHighWatermark = 1,
    rmLowWatermark,         
    rmDualWatermark,            
    rmWatermarkTypeEnd          
};

typedef struct
{
    enum rmWatermarkType    type;
} rmWatermarkConfiguration;
#define RMWatermarkType typeConfiguration.watermark.type

typedef struct
{
    enum rmMonitorType  monitorType;
    rmStatisticKey      statisticKey;
    enum rmStatisticTransform       statisticTransform;
    union {
        rmThresholdConfiguration    threshold;
        rmWatermarkConfiguration    watermark;
        rmLeakyBucketConfiguration  leakyBucket;
        // for configuration of future monitor types
    } typeConfiguration;
} rmMonitorConfiguration;

enum rmMonitorStatus
{
    rmAvailable = 1,    
    rmConfigured,           
    rmActive,                   
    rmStopped,              
    rmInactive,             
    rmUnavailableResource,  
    rmMonitorStatusEnd          
};

typedef struct
{
    rmTimeStamp LastEventTime;
} rmThresholdState;
#define RMThresholdLastEventTime    typeState.threshold.LastEventTime

typedef struct
{
    rmValue         highWatermark;
    rmValue         lowWatermark;
    rmTimeStamp highTime;
    rmTimeStamp lowTime;
} rmWatermarkState;
#define RMWatermarkHigh typeState.watermark.highWatermark
#define RMWatermarkLow  typeState.watermark.lowWatermark
#define RMWatermarkHighTime typeState.watermark.highTime
#define RMWatermarkLowTime  typeState.watermark.lowTime

typedef struct
{
    rmValue         bucketLevel;
    rmTimeStamp LastEventTime;
} rmLeakyBucketState;
#define RMLeakyBucketLevel  typeState.leakyBucket.bucketLevel
#define RMLeakyBucketLastEventTime  typeState.leakyBucket.LastEventTime

typedef struct
{
    enum rmMonitorType  monitorType;
    enum rmMonitorStatus    currentStatus;
    int notificationPaused;
    rmStatisticValue    lastMonitoredValue;
    rmTimeStamp startTime;
    rmTimeStamp stopTime;
    union {
        rmThresholdState        threshold;
        rmWatermarkState        watermark;
        rmLeakyBucketState  leakyBucket;
        // for status of future monitor types
    } typeState;
} rmMonitorState;

typedef struct
{
    // the unique ID generated by the resource monitoring facility when a monitor is created.
    rmUID           uid;
    uid_t           creator;
    rmHandle    handle;
} rmMonitorInfo;

#endif  //  __ResourceMonitorTypes_h__

---