#ifndef _SYS_DCI_H_
#define _SYS_DCI_H_
/* dci.h - exported interfaces and structures for the Data Capture Interface
*
* Description:
*
* ****************** NOTICE ***********************************
* The <dci.h>, <mli.h> and <uma.h> header files
* introduce UMA symbols which may conflict with other
* symbols defined in an application. Symbols with the
* following prefixes are therefore reserved to UMA:
* DCI
* dci
* UMA
* UMR
* UMS
*
* Note that the header files are provided as advisory
* reference examples.
* ****************** END OF NOTICE ****************************
*/
#include <sys/uma.h>
#define DCI_ALL 0xffffffff /* Wildcard value classes and datums */
#define DCI_ALL_INSTANCES 0x00000000 /* Wildcard value for instances */
/* The return status values for DCI API calls */
/* the summary values are bitmasks used to determine severity of result */
#define DCI_FAILURE 0x80000000
#define DCI_WARNING 0x40000000
#define DCI_INFORMATIONAL 0x20000000
#define DCI_SUCCESS 0x10000000
#define DCI_FATAL 0x08000000
/* fatal errors returned from the dci routine itself */
#define DCI_INITIALIZED (DCI_FATAL | 0x01)
#define DCI_NOTINITIALIZED (DCI_FATAL | 0x02)
#define DCI_NOTPRESENT (DCI_FATAL | 0x03)
#define DCI_SYSERROR (DCI_FATAL | 0x04)
#define DCI_INVALIDARG (DCI_FATAL | 0x05)
#define DCI_NOSPACE (DCI_FATAL | 0x06)
#define DCI_INTERRUPTED (DCI_FATAL | 0x07)
#define DCI_BADHANDLE (DCI_FATAL | 0x08)
#define DCI_ALLOCATIONFAILURE (DCI_FATAL | 0x09)
#define DCI_BADFLAGS (DCI_FATAL | 0x0a)
#define DCI_NOIMPLEMENTATION (DCI_FATAL | 0x0b)
/* errors returned as individual or summary status */
#define DCI_NOTEVENTMETRIC (DCI_FAILURE | 0x01)
#define DCI_NOCLASS (DCI_FAILURE | 0x02)
#define DCI_NOINSTANCE (DCI_FAILURE | 0x03)
#define DCI_NOMETRIC (DCI_FAILURE | 0x04)
#define DCI_NOTEXT (DCI_FAILURE | 0x06)
#define DCI_NOWILDCARD (DCI_FAILURE | 0x07)
#define DCI_CLASSEXISTS (DCI_FAILURE | 0x08)
#define DCI_INSTANCEEXISTS (DCI_FAILURE | 0x09)
#define DCI_NODATUMID (DCI_FAILURE | 0x0a)
#define DCI_METHODTYPEUNAVAILABLE (DCI_FAILURE | 0x0b)
#define DCI_NOTPOLLEDMETRIC (DCI_FAILURE | 0x0c)
#define DCI_BADCONFIRM (DCI_FAILURE | 0x0d)
#define DCI_NOTSETTABLE (DCI_FAILURE | 0x0e)
#define DCI_NOTRESERVABLE (DCI_FAILURE | 0x0f)
#define DCI_RESERVED (DCI_FAILURE | 0x10)
#define DCI_NOTRESERVED (DCI_FAILURE | 0x11)
#define DCI_NOTQUERYABLE (DCI_FAILURE | 0x12)
#define DCI_METHODOPNOTSUPPORTED (DCI_FAILURE| 0x13)
#define DCI_INVALIDMETHODOP (DCI_FAILURE | 0x14)
#define DCI_NOTENABLED (DCI_FAILURE | 0x15)
#define DCI_CLASSNOTPERSISTENT (DCI_FAILURE | 0x16)
#define DCI_INSTANCENOTPERSISTENT (DCI_FAILURE | 0x17)
#define DCI_CLASSNOTEMPTY (DCI_FAILURE | 0x18)
#define DCI_INVALIDDATA (DCI_FAILURE | 0x19)
#define DCI_DERIVEDDATA (DCI_FAILURE | 0x1a)
#define DCI_METHODERROR (DCI_FAILURE | 0x1b)
#define DCI_SUBSETUNSUPPORTED (DCI_FAILURE | 0x1c)
#define DCI_DCIMAJORUNSUPPORTED (DCI_FAILURE | 0x1d)
#define DCI_DCIMINORUNSUPPORTED (DCI_FAILURE | 0x1e)
#define DCI_INVALIDFIELD (DCI_FAILURE | 0x1f)
#define DCI_TIMEOUT (DCI_FAILURE | 0x20)
#define DCI_NOACCESS (DCI_FAILURE | 0x21)
#define DCI_EVENTSUPPORT (DCI_FAILURE | 0x22)
/* informational individual or summary status */
#define DCI_CLASSADDED (DCI_INFORMATIONAL | 0x01)
#define DCI_INSTANCEADDED (DCI_INFORMATIONAL | 0x02)
#define DCI_NOSUCHTRANSACTION (DCI_INFORMATIONAL | 0x03)
#define DCI_INVALIDDATAPRESENT (DCI_INFORMATIONAL | 0x04)
typedef UMAUint4 DCIStatus; /* returned by all DCI routines */
typedef UMAUint4 DCIHandle; /* returned by dciOpen() */
typedef UMAUint4 DCIDatumId; /* the datumId */
/* macros to access the datumId byte by byte. The address of
* the DCIDatumId is presented, and the address of the specified
* byte is produced.
*/
#define dcidatumidarg1(datumidp) ((char *)((*datumidp>>24)&0xff))
#define dcidatumidarg2(datumidp) ((char *)((*datumidp>>16)&0xff))
#define dcidatumidarg3(datumidp) ((char *)((*datumidp>>8)&0xff))
#define dcidatumidself(datumidp) ((char *)((*datumidp>>0)&0xff))
/* Reserved DCIDatumId values */
#define DCI_INVALIDDATUMID 0x000000ff
#define DCI_FINALDATA_EVENT 0x000000f8
#define DCI_INSTANCEADDED 0x000000f7
#define DCI_INSTANCEREMOVED 0x000000f6
#define DCI_DATACHANGED 0x000000f5
/*===================================================================
* DCI Versioning structure
*/
/* bitmapped flags to indicate the level of implementation support.
* These are used as part of the structure passed from dciInitialize
* to indicate the specific level of support available in an
* implementation.
*/
#define DCI_SUBSET_BASIC 0x01
#define DCI_SUBSET_MULTIPLE_PROVIDERS 0x02
#define DCI_SUBSET_ACCESS_CONTROL 0x04
#define DCI_SUBSET_EVENT_SUPPORT 0x08
#define DCI_SUBSET_SET_CAPABILITY 0x10
/* DCI version structure.
* This is passed into the dciInitialize() call as a request structure.
* As such, it specifies a request to connect to a specific DCI API
* version. A DCI version structure is also passed as an output parameter
* indicating the level of support that this particular DCI implementation
* is actually making available.
*/
typedef struct DCIVersion {
UMAUint4 DCIMajorVersion;
UMAUint4 DCIMinorVersion;
UMAUint4 DCISubsetMask;
UMAUint4 DCIVendorExtensions;
} DCIVersion;
typedef DCIVersion DCIVersion_1;
/* the major and minor version numbers of this dci.h */
#define DCI_MAJORVERSION 1
#define DCI_MINORVERSION 0
/* Compile time constants that indicate which DCI subsets are implemented
* Implementers should change the value of the appropriate constant
* if the corresponding subset is present in an implementation.
* If a subset is not implemented the constant should have value 0.
* For illustrative purposes below we show the assignments assuming only
* Basic support is implemented.
*/
#define _DCI_SUBSET_BASIC DCI_SUBSET_BASIC
#define _DCI_SUBSET_MULTIPLE_PROVIDERS 0x00 /*DCI_SUBSET_MULTIPLE_PROVIDERS*/
#define _DCI_SUBSET_ACCESS_CONTROL 0x00 /*DCI_SUBSET_ACCESS_CONTROL */
#define _DCI_SUBSET_EVENT_SUPPORT 0x00 /*DCI_SUBSET_EVENT_SUPPORT */
#define _DCI_SUBSET_SET_CAPABILITY 0x00 /*DCI_SUBSET_SET_CAPABILITY */
#define _DCI_SUBSET_MASK _DCI_SUBSET_BASIC | \
_DCI_SUBSET_MULTIPLE_PROVIDERS | \
_DCI_SUBSET_ACCESS_CONTROL | \
_DCI_SUBSET_EVENT_SUPPORT | \
_DCI_SUBSET_SET_CAPABILITY
/*=======================================================================
* DCI Namespace identifier structures
*/
/*
* The DCIClassId structure.
*
* The class identifier is a variable length array of 4 byte
* unsigned integers, where each integer is referred to as a
* "level". Use the following macros to access this structure:
* dciclassidlen - returns the number of levels specified
* dciclassidlevel - returns the address of the integer
* for that level of the class identifier.
*/
typedef struct DCIClassId {
UMAUint4 size; /* size of the fixed and variable */
/* length portions */
UMAVarLenData data; /* variable length data */
/* (the identifier) */
} DCIClassId;
/* The DCIInstanceId structure
* An instance can have multiple levels, where each level name
* is stored in a variable length data structure.
* The 'size' field represents the combined size of the
* complete structure (i.e., all level names).
* The 'inputMask' field is a bitmask and indicates which
* instance levels have entries in the variable length
* 'data' structure. If an instance level's inputMask
* bit is not set, the level is wildcarded.
* The 'outputMask' is used to reduce the size of the
* returned instance id from a dci call. It indicates
* to the provider/DCI Server which levels should be
* included in the returned instance ids.
*/
typedef struct DCIInstanceId {
UMAUint4 size; /* size of the fixed and */
/* variable length portions */
UMAUint4 inputMask; /* input mask, 32 levels */
UMAUint4 outputMask; /* output mask, 32 levels */
UMAVarLenData data; /* variable length data */
/* (the instance level */
/* identifiers) */
} DCIInstanceId;
/* Definitions for the instance header size, everything but the
* instLevels, and the maximum number of levels. The latter is
* dictated by the number of bits in the inputMask field. A
* value of 0x00000000 for inputMask is reserved for a
* completely wildcarded instance (see DCI_ALL_INSTANCES).
*/
#define DCI_MAXINSTLEVELS 32
#define DCI_MAXCLASSLEVELS 256
typedef struct DCIInstLevel {
UMADataType type; /* type of the instance */
/* level value */
UMAInstTagType itype; /* instance type */
UMAUint4 size; /* size of instance level */
/* value in bytes */
} DCIInstLevel;
/* The DCIMetricId structure
* A metric identifier consists of a Class & Instance identifier
* Both of these are variable length records with a size as their
* first field.
*/
typedef struct DCIMetricId {
UMAUint4 size; /* size of whole structure */
UMAVarLenDescr classId; /* descriptor for the */
/* variable length DCIClassId */
UMAVarLenDescr instanceId; /* descriptor for the */
/* variable length DCIInstanceId */
DCIDatumId datumId; /* the datum identifier */
UMAVarLenData data; /* data of DCIClassId */
/* and DCIInstanceId */
} DCIMetricId;
/* The DCILabel structure
* A DCI label can be used to create a human
* readable name of a metric class, instance or datum. A label
* has two parts, a part to support internationalised text and a
* default ascii label should the I18N mechanism fail. The
* former might not be the I18N text itself but a system
* dependent structure used to generate text. The ascii
* data is a null terminated character string padded to a four
* byte boundary. The i18n data is an octet string (which is
* not necessarily null-terminated).
*/
typedef struct DCILabel {
UMAUint4 size; /* size of entire structure */
UMAVarLenDescr ascii; /* descriptor for the variable */
/* length DCITextString for ascii */
UMAElementDescr i18n; /* descriptor for the variable */
/* length data for I18N */
UMAVarLenData data; /* data of DCILabel for ascii and i18n */
} DCILabel;
/* Data Attribute Structure */
typedef struct DCIDataAttr {
UMAUint4 size; /* size of whole structure */
DCIDatumId datumId; /* datum identifier for this metric */
UMADataType type; /* datum type */
UMAUnit units; /* units of this statistic */
UMAUint4 flags; /* method operations flags */
UMAUint4 offset; /* offset of this data when a */
/* whole class is returned */
UMAVarLenDescr label; /* descriptor for the variable */
/* length DCILabel */
UMAVarLenData data; /* the DCILabel */
} DCIDataAttr;
typedef struct DCIClassAttr {
UMAUint4 size; /* size of whole structure */
UMAUint4 flags; /* special class state */
UMAVarLenDescr access; /* descriptor for DCIAccess */
/* structure */
UMAVarLenDescr method; /* descriptor for optional */
/* DCIMethod structure */
UMAVarLenDescr label; /* label data */
UMAArrayDescr instLevel; /* descriptor for DCIInstLevel array */
UMAVarArrayDescr dataAttr; /* descriptor for DCIDataAttr array */
UMAVarArrayDescr eventAttr; /* descriptor for DCIEventAttr array */
UMAElementDescr extensions; /* extension data */
UMAVarLenData data; /* dataattr, eventattr, label */
/* DCIMethod,instance level, ext, */
/* and DCIAccess */
} DCIClassAttr;
/* bitmapped flags for DCIClassAttr */
#define DCI_ENABLED 0x01 /* (!enabled = disabled) */
#define DCI_NOTIMPLEMENTED 0x02 /* unimplemented class */
#define DCI_NOTAPPLICABLE 0x04 /* not applicable to the system */
#define DCI_OBSOLETE 0x08 /* class is being phased out */
#define DCI_PROVIDER_INSTANCE 0x10 /* provider */
#define DCI_PERSISTENT_CLASS 0x20 /* keep class on exit/exec */
#define DCI_POSSIBLEINVALIDDATA 0x40 /* class may contain metrics */
/* that are invalid for certain */
/* instances of the class */
typedef struct DCIEventDataAttr {
UMAUint4 size; /* size of the whole structure */
UMADataType type; /* format of data returned */
UMAUnit units; /* units of data returned */
UMAUint4 offset; /* offset of data in return area */
UMAVarLenDescr label; /* descriptor for the variable */
/* length DCILabel */
UMAVarLenData data; /* the DCILabel */
} DCIEventDataAttr;
typedef struct DCIEventAttr {
UMAUint4 size; /* size of whole structure */
DCIDatumId datumId; /* datum identifier for this metric */
UMAVarLenDescr label; /* descriptor for the variable */
/* length DCILabel */
UMAVarArrayDescr eventDataAttr; /* descriptor for the array */
/* of DCIEventDataAttrs */
UMAVarLenData data; /* the DCILabel and */
/* DCIEventDataAttr array */
} DCIEventAttr;
typedef struct DCIEvent {
UMAUint4 eventHeader; /* the event header */
UMAVarLenData data; /* data for the event */
} DCIEvent;
/* Bitmapped flags used in the first 12 bits of the event header */
/* The flags indicate which items are include in the posted event */
/* If included, items appear in the same order as their corresponding */
/* bit in the bitmap (e.g., header first, classid next ...) */
#define DCI_EVENTHDR 0x001 /*include event header */
#define DCI_EVENTHDRCLASSID 0x002 /*include a class id */
#define DCI_EVENTHDRINSTANCEID 0x004 /*include an instance id */
#define DCI_EVENTHDRTIMESTAMP 0x008 /*include a 64-bit time stamp */
#define DCI_EVENTHDRVENDORTIMESTAMP 0x010 /*include an implementation */
/*defined timestamp */
#define DCI_EVENTHDRCOMPTIMESTAMP 0x020 /*include a compressed timestamp*/
#define DCI_EVENTHDRSTREAMID 0x040 /*include an event stream id */
#define DCI_EVENTHDRDATA 0x080 /*include the event data */
/* DCIEventRetval is returned upon a dciWaitEvent() call */
typedef struct DCIEventRetval {
UMAUint4 size; /* size of the whole structure */
UMAUint4 numEvents; /* number of events reported */
UMAUint4 numLostEvents; /* number of events lost */
/* and unrecorded */
UMAVarLenDescr eventStatus; /* descriptor for array of */
/* DCIStatus values */
UMAUint4 bufferhead; /* may contain the offset */
/* for oldest event */
UMAVarLenData data; /* variable length data */
/* (DCIStatus,implstatus) */
} DCIEventRetval;
/*============================================================================
* The DCIReturn structure
* All DCI routines return the same type of structure. The
* structure consists of size and count fields followed by
* a variable sized array of DCIRetval structures. There
* is one array element for every input metric. Each array
* element contains status values, and offsets to the
* input argument and returned data.
typedef struct DCIRetval {
DCIStatus status; /* status for input argument */
UMAUint4 metricOffset; /* offset to input id value */
UMAUint4 dataOffset; /* offset to data value */
UMAUint4 dataSize; /* size of data returned in bytes */
} DCIRetval;
typedef struct DCIReturn {
UMAUint4 size; /* total bytes in DCIReturn */
UMAUint4 count; /* number of returned elements */
DCIStatus sumstatus; /* summary status */
UMATimeSpec startTime; /* Start time of operation */
UMATimeSpec endTime; /* End time of operation */
DCIRetval retval[1]; /* status, input id,i and output */
} DCIReturn;
typedef struct DCIAccess {
UMAUint4 size; /* size of the whole DCIAccess structure */
UMAVarLenData access; /* byte array containing the access */
/* information */
} DCIAccess;
/*
* DCIInstAttr -
* variable length array holding the attributes of an instance.
*/
typedef struct DCIInstAttr {
UMAUint4 size; /* size of the whole structure */
UMAUint4 flags; /* special instance state */
UMAVarLenDescr access; /* descriptor for the DCIAccess structure */
UMAElementDescr extension; /* descriptor for variable length extns */
UMAVarLenDescr label; /* descriptor for variable length DCILabel*/
UMAVarLenData data; /* data for DCIAccess, DCILabel */
/* and extensions */
} DCIInstAttr;
/* bitmapped flags for DCIInstAttr */
#define DCI_PERSISTENT_INSTANCE 0x01 /* keep instance on exit/exec */
/* structure to indicate invalid data in a class.
* This structure is returned for dciGetData requests on the
* DCI_INVALIDDATUMID metric in the class (if the class is enabled
* for invalid data, as indicated with the DCI_POSSIBLEINVALIDDATA
* flag).
* The structure consists of a size indicating total size of the
* structure, and an array of datumids. Each entry in the ids[]
* array indicates a datum that is invalid for this particular
* instance of the class.
*/
struct DCIInvalidData {
UMAUint4 size;
DCIDatumId ids[1]; /* variable length component */
}
#define dciinvaliddatacount(invdatap) ((invdatap->size)/sizeof(DCIDatumId))
#define dciinvaliddatumid(invdatap,index) (invdatap[index+1])
/* The DCIMethod structure
* This is a variable sized structure that describes the method
* metric providers use to deliver metrics. This structure is
* only used by the provider routines and is not exported to
* consumers. The method includes the method type, a variable
* sized method field which is padded to a four byte boundary,
* and an instance attribute structure.
*/
enum DCIMethodType {
DCI_WAIT = 0, /* provider will block in dciWaitRequest */
DCI_ADDRESS = 1, /* data retrieved from provider address */
DCI_CALLBACK = 2, /* a provider function call is issued */
DCI_STORE = 3 /* data is periodically stored by provider */
};
typedef enum DCIMethodType DCIMethodType;
typedef struct DCIMethod{
UMAUint4 size; /* size of this structure */
DCIMethodType type; /* how data will be retrieved */
UMAElementDescr method; /* descriptor for variable */
/* length method data */
UMAVarLenData data; /* data for method */
} DCIMethod;
/* methods operations */
#define DCI_OP_GETDATA 0x01
#define DCI_OP_SETDATA 0x02
#define DCI_OP_RESERVEDATA 0x04
#define DCI_OP_RELEASEDATA 0x08
#define DCI_OP_LISTINSTANCES 0x10
#define DCI_OP_GETINSTATTR 0x20
#define DCI_OP_CONFIGURE 0x40
typedef struct DCIInstanceData {
UMAUint4 size; /* size of the whole structure */
UMAUint4 count; /* number of elements in each array */
UMAVarLenDescr instanceIdList; /* descriptor for DCIInstanceId array */
UMAVarLenDescr instAttrList; /* descriptor for DCIInstAttr array */
UMAVarLenData data; /* DCIInstanceId and DCIInstAttr arrays*/
} DCIInstanceData;
typedef struct DCIAddressMethodData {
void *address; /* the base address of a memory region */
UMAUint4 size; /* the size of the region in bytes */
void *sync; /* opaque memory synchronisation token */
} DCIAddressMethodData;
typedef struct DCIConfig {
UMAUint4 size; /* total structure size, in bytes */
UMAUint4 flags; /* configuration request */
UMAElementDescr configdata; /* descriptor for the auxiliary */
/* config info */
UMAVarLenData data; /* auxiliary config data starts here */
} DCIConfig;
/* These flags must exist in the lower half of the word */
#define DCI_ENABLE 0x01 /* enable the metrics */
#define DCI_DISABLE 0x02 /* disable the metrics */
#define DCI_CONFIGURATION 0x04 /* configuration data is passed to provider */
#define DCI_EVENT_ENABLE 0x0008
#define DCI_EVENT_DISABLE 0x0010
#define DCI_BUFFER_EVENTS_DISCARD 0x0020
#define DCI_BUFFER_EVENTS_OVERWRITE 0x0040
#define DCI_BUFFER_EVENTS_GETSIZE 0x0080
#define DCI_BUFFER_EVENTS_SETSIZE 0x0100
#define DCI_BUFFER_EVENTS_POLICY 0x0200
#define DCI_QUERYABLE 0x10000 /* polled metric is gettable */
#define DCI_SETTABLE 0x20000 /* polled metric is settable */
#define DCI_RESERVABLE 0x40000 /* polled metric is reservable */
/* dciWaitEvent() eventflags */
#define DCI_EVENT_NOBLOCK 0x01 /* return with any pending events */
/* immediately */
#define DCI_EVENT_FILLBUFFER 0x02 /* return when the fillbuffer is */
/* almost full */
/* DCI function prototypes. The function prototypes are always enabled
* except _NO_PROTO is #define'd.
*
*/
#ifndef _NO_PROTO
/* Basic support */
DCIStatus dciInitialize(DCIVersion *request, DCIVersion *response);
DCIStatus dciRegister(DCIClassId *classId, DCIClassAttr *classAttr,
DCIReturn **bufferAddress, UMAUint4 bufferSize);
DCIStatus dciTerminate(void);
DCIStatus dciListClassId(DCIHandle handle,
DCIClassId *classIdList,UMAUint4 numIds,
DCIReturn **bufferAddress, UMAUint4 bufferSize);
DCIStatus dciListInstanceId(DCIHandle handle,
DCIMetricId *metricIdList,UMAUint4 numIds,
DCIReturn **bufferAddress, UMAUint4 bufferSize,
UMATimeVal *timeout);
DCIStatus dciOpen(DCIHandle *handle, DCIMetricId *metricIdList,
UMAUint4 numIds, DCIReturn **bufferAddress, UMAUint4 bufferSize,
UMAUint4 handleflags, UMATimeVal *timeout);
DCIStatus dciClose(DCIHandle handle);
DCIStatus dciGetClassAttributes(DCIHandle handle, DCIClassId *classIdList,
UMAUint4 numIds, DCIReturn **bufferAddress, UMAUint4 bufferSize);
DCIStatus dciGetInstAttributes(DCIHandle handle,DCIMetricId *metricIdList,
UMAUint4 numIds, DCIReturn **bufferAddress, UMAUint4 bufferSize,
UMATimeVal *timeout);
DCIStatus dciConfigure(DCIHandle handle, DCIMetricId *metricIdList,
DCIConfig *configlist, UMAUint4 numIds, DCIReturn **bufferAddress,
UMAUint4 bufferSize, UMATimeVal *timeout);
DCIStatus dciGetData(DCIHandle handle, DCIMetricId *metricIdList,
UMAUint4 numIds, DCIReturn **bufferAddress, UMAUint4 bufferSize,
void **dataAddress, UMAUint4 *datasize, UMATimeVal *timeout);
DCIStatus dciSetData(DCIHandle handle, DCIMetricId *metricIdList,
UMAUint4 numIds, UMAUint4 operation, UMAUint4 *pConfirm,
DCIReturn **bufferAddress, UMAUint4 *bufferSize,
void *dataAddress, UMAUint4 dataSize, UMATimeVal *timeout);
DCIStatus dciFree(void *ptr);
void *dciAlloc(UMAUint4 size);
void dciPerror(DCIStatus status, int theerrno, char *membuf,
int bufsize, char *fmt, ...);
DCIStatus dciAddHandleMetric(DCIHandle handle, DCIMetricId *metricIdList,
UMAUint4 numIds, DCIReturn **bufferAddress, UMAUint4 bufferSize,
UMATimeVal *timeout);
DCIStatus dciRemoveHandleMetric(DCIHandle handle, DCIMetricId *metricIdList,
UMAUint4 numIds, DCIReturn **bufferAddress,
UMAUint4 bufferSize, UMATimeVal *timeout);
/* Multiple Providers */
DCIStatus dciAddInstance(DCIClassId *classId,
DCIInstanceId *instanceId, DCIInstAttr *instAttr,
DCIMethod *method,
DCIReturn **bufferAddress, UMAUint4 bufferSize);
DCIStatus dciRemoveInstance(DCIMetricId *metricId,
DCIReturn **bufferAddress, UMAUint4 bufferSize);
DCIStatus dciWaitRequest(DCIMetricId *metricIdList, UMAUint4 numIds,
UMAUint4 *operation, UMAUint4 *transactionID,
DCIReturn **bufferAddress,
UMAUint4 bufferSize, UMATimeVal *timeout);
DCIStatus dciPostData(UMAUint4 operation, UMAUint4 transactionID,
DCIReturn *status, void *data, UMAUint4 dataSize,
DCIReturn **bufferAddress, UMAUint4 bufferSize);
DCIStatus dciUnregister(DCIClassId *classId,
DCIReturn **bufferAddress, UMAUint4 bufferSize);
DCIStatus dciSetClassAccess(DCIClassId *classIdList,DCIAccess *accessList,
UMAUint4 numIds,DCIReturn **bufferAddress, UMAUint4 bufferSize);
DCIStatus dciSetInstAccess(DCIMetricId *metricIdList,DCIAccess *accessList,
UMAUint4 numIds,DCIReturn **bufferAddress, UMAUint4 bufferSize,
UMATimeVal *timeout);
/* Event Delivery */
DCIStatus dciWaitEvent(DCIHandle handle, DCIMetricId *metricIdList,
UMAUint4 numIds, DCIEventReturn **bufferAddress,
UMAUint4 bufferSize, void **dataAddress, UMAUint4 *dataSize,
UMATimeVal *timeout , UMAUint4 eventFlags);
DCIStatus dciPostEvent(DCIMetricId *metricId,
UMAUint4 eventDataCount, UMAUint4 eventDataSize,
UMAVarLenData *eventData);
#endif /* _NO_PROTO */
#endif /* _SYS_DCI_H_ */
| Contents | Next section | Index |