Previous section.

UMA Data Capture Interface (DCI)
Copyright © 1997 The Open Group

C Language Header Files

The include files <dci.h> and <uma.h> are used with the C language to define the DCI data types and structures. They also include the function prototypes for all exported DCI interfaces.


The <uma.h> header file is given in the MLI Specification, which is in Part 2 Appendix A of this publication.


The <dci.h> header file is given below.

#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_BADFLAGS            (DCI_FATAL | 0x0a)   

/* 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_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_NOTENABLED            (DCI_FAILURE | 0x15)    
#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_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)

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_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_MASK               _DCI_SUBSET_BASIC                | \
                                       _DCI_SUBSET_MULTIPLE_PROVIDERS   | \
                                       _DCI_SUBSET_ACCESS_CONTROL       | \
                                       _DCI_SUBSET_EVENT_SUPPORT        | \

 * 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_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_ */

Why not acquire a nicely bound hard copy?
Click here to return to the publication details or order a copy of this publication.

Contents Next section Index