/* IBM_PROLOG_BEGIN_TAG                                                   */
/* This is an automatically generated prolog.                             */
/*                                                                        */
/* bos720 src/bos/kernel/ewlm/ewlmplat.h 1.6.1.1                          */
/*                                                                        */
/* Licensed Materials - Property of IBM                                   */
/*                                                                        */
/* COPYRIGHT International Business Machines Corp. 2003                   */
/* All Rights Reserved                                                    */
/*                                                                        */
/* US Government Users Restricted Rights - Use, duplication or            */
/* disclosure restricted by GSA ADP Schedule Contract with IBM Corp.      */
/*                                                                        */
/* IBM_PROLOG_END_TAG                                                     */
/* @(#)95       1.6.1.1  src/bos/kernel/ewlm/ewlmplat.h, sysewlm, bos720 3/29/07 17:37:50 */
/*
 *   COMPONENT_NAME: SYSEWLM
 *
 *   DESCRIPTION:  EWLM common code native service definitions
 *
 *   ORIGINS: 27
 */
/* ------------------------------------------------------------------------- */
/* ewlmplat.h - EWLM Platform Services API Declarations header file          */
/*                                                                           */
/* This header file declares the platform service APIs.                      */
/* -------------------------------------------------------------------------
 * Change Activity:
 * Reason      Date      Origin               Description
 * -------  ----------  -----------     ------------------------------------ 
 * DCR 011  2003-08-28  John Arwe       Pass policy into ewlm_xxx_policy APIs
 *                                      as unencodedbytestream
 * DCR 002  2003-08-31  John Arwe       Add AIID to parent identity, 4 records
 * DCR 011  2003-09-01  John Arwe       Allow thread-level idle and other
 *                                      samples rather than process-level only
 * DCR 011  2003-09-01  John Arwe       Removed process name from query
 *                                      server configuration.  Seems to have
 *                                      been copied in error from get_appldata
 * DCR 011  2003-09-02  John Arwe       Rename files to be within 8-char limit
 * DCR xxx  2003-09-17  John Arwe       Fix typo in invalidation record name
 * DCR xxx  2003-09-21  John Arwe       Distinguish between required and 
 *                                      optional return codes for each API
 * DCR xxx  2003-09-23  Geoff Lubold    Change XXX_t types to ewlm_XXX_t 
 *                                      types
 * DCR xxx  2003-09-29  Geoff Lubold    AEIID changed to AEID
 * DCR xxx  2003-09-29  Geoff Lubold    Partially Instrumented #define sizeof
 *                                      fixed
 * DCR 018  2003-09-29  Geoff Lubold    Instrumented application termination 
 *                                      handling - AIID termination records
 *          2003-10-10  Geoff Lubold    Moved EWLM_ARM_STATUS_ABANDONED from
 *                                      ewlmplos.h to ewlmplat.h
 *          2003-10-25  Geoff Lubold    get_completion cancel wait comment 
 *                                      text changed.
 * F2691    2003-10-28  Geoff Lubold    Includes changed from " " to < >
 * DCR 010  2003-10-31  Geoff Lubold    Removed local server ID from 
 *                                      ewlm_connect_input_t
 * DCR 030  2003-11-23  John Arwe       Fix doc: 
 *                                      - blocked time always in total mode
 *                                      - remove DE references and open
 *                                        questions
 *                                      - correct start time description
 *                                        to allow for non-zero queue time
 *                                      - change EWLM_SUPPORT_NOT_ENABLED from
 *                                        optional to required on all APIs
 *                                      - final policy management API rc doc
 * DCR 030  2003-11-23  John Arwe       Document new rc for get_activedata
 *                                        continue requests with invalid 
 *                                        cursor
 * DCR 030  2003-11-26  John Arwe       Document new bit on ewlm_query
 *                                        ResourceMetricsCollected
 *                                      Document blocked time overflow bits
 *                                      Remove extraneous record mappings
 *                                      Reorder performance-sensitive record
 *                                        mappings to minimize wasted space
 *                                        (averaged across all platforms)
 *                                      Rename enforcement layer bit
 *                                      Rename EWLM 1st release bit
 *                                      Reword comment to address legal issue
 * D3094   2003-12-08   Geoff Lubold    Addition of C++ support 
 * D3127   2003-12-09   Geoff Lubold    moved hopcount and classification ID
 *                                      to arm4ewlm.h. Also included
 *                                      arm4ewlm.h
 * D3395   2004-01-09   Geoff Lubold    Removal of *VERSIONLATEST
 * DCR 021 2004-01-08   Geoff Lubold    Created new internal error code range 
 *                                      & changed comment wording for error -222
 * DCR 034  2004-01-07  John Arwe       Define bit to detect a system time
 *                                        change occurred which the OS 
 *                                        believes might impact reported times.
 *                                        Adds version 002 of get_activedata
 *                                        end of buffer record.
 * DCR 033  2004-01-07  John Arwe       Define version 002 of query resource
 *                                        metrics to allow OS to return
 *                                        its sample conversion factor.
 * D4040    2004-02-10  G. Lubold       Copyright updates
 * D4380    2004-02-25  G. Lubold       Copyright updates
 * F12760   2004-11-01  G. Lubold       QueryServerConfig output buffer version 2,
 *                                      pass samplingTimer value on ewlmConnect
 *                                      call from Java
 * F15321   2005-01-13  G. Lubold       new define for release level for
 *                                      ewlm_query
 * F15541   2005-01-27  G. Lubold       correct version for platforms at higher
 *                                      level than EWLM
 * F16156   2005-03-02  G. Lubold               Added Solaris and HP/UX return code ranges
 * F16861   2005-03-29  G. Lubold       DCR 19- microsecond reporting and versioning
 *                                      changes
 * F28712   2006-06-07  G  Readler      Local CPU resource management support
 *          2006-06-19  K. Ng           z/OS End-to-End support
 *          2006-07-13  G.  Bosch       Added MQ support
 *          2006-07-23  D.  Manners     Additional MQ support
 * F29843   2006-07-24  G  Readler      Put into cmvc
 *          2006-08-01  D.  Manners     Corrections to 2006-07-23 adds
 * F30117   2006-08-21  G Readler       change EWLM_QUERY_HYPERVISOR_VMWARE back to 4
 * DCR 015  2006-09-08  G Readler       New types for async get_completions
 *                                      and get_activedata output records.
 *                                      Additional 16Bit flagsv3 fields for
 *                                      in-flight and completion records.
 * F30592   2006-09-19  G Readler       management_id changed to 64 bit value.
 * F32148   2006-11-16  G Readler       DCR24 scaled cpu clock  
 * ------------------------------------------------------------------------- */

#ifndef _H_EWLM_EWLMPLAT 
#define _H_EWLM_EWLMPLAT

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */


/* Pending issues - may or may not be implemented
 * 
 * Guidelines for files like this which are intended to be the same across all 
 * platforms:
 * - Not all platforms support int_64 natively, so an ewlm_int64 type is defined
 *   in ewlmplatos.h, and each platform completes the definition there.
 * - Not all C compilers support the double-slash end of line comments, so stick 
 *   to the explicit open/close style comments.
 * - Use char * instead of void * for better OS/400 performance.
 * - REQUIREMENT: Code to use C89 (1989 C standard) constructs only!  Not all
 *   supported platforms have compilers which support the 1999 C standard yet.
 * - REQUIREMENT: Do not define flag constants as 0x80000000.  Code exists to
 *   verify at compile time that the EWLM agent's Java flags are the same as
 *   this file's C declarations.  The javah process which generates the JNI
 *   constants generates numeric constant values for 0x8000000 as a signed
 *   32-bit integer which the Windows C compiler flags as being out of range.
 */ 


/* -------------------------------------------------------------------------
 * ---------------------------  DOCUMENTATION  -----------------------------
 * ------------------------------------------------------------------------- 
 * Finding things:
 * - Function signatures: search for ewlm_status_t
 * - Inputs or outputs for a particular API: apiname_input/output, e.g.
 *   for ewlm_connect search for ewlm_connect_input and ewlm_connect_output
 * - Output records from get_activedata and get_completions: search on
 *   apiname_ 
 * 
--- API Signature ---
input_buffer
    Storage allocated by EWLM agent for API inputs.  Required for all APIs.

input__buffer_size
    Size of the input buffer (in bytes) allocated by the API caller.
    
output_buffer
    Storage allocated by EWLM agent for API outputs.  Required for all APIs.

output_buffer_size
    Size of the output buffer (in bytes) allocated by the API caller. 
    
--- Common API fields ---
version
    In order to support migration goals, virtually every structure mapping
    has a version.  Version numbers for each structure are independent.  A
    given version number + structure combination implicitly determines the set
    of data and offsets used to map the structure.
    
    Version numbers should be incremented for each structure update.  Such 
    updates must be compatible (no removal of existing field names, changes
    to offsets of existing fields, changes to values of existing constants, 
    changes to lengths of existing fields).
    
request_type
    For APIs which support multiple functions, this parameter determines which
    function the caller wishes performed.

connect_handle
    A platform-specific token whose value is opaque to the caller.  It is an
    output from ewlm_connect(), and input to all other services.  It's function
    is to restrict the usage of ewlm_ APIs to the set of user(s) authorized
    by ewlm_connect's platform-specific checks.
    
sizeneeded
    The size in bytes of the storage area needed to hold the API's output.
    APIs with versioned output buffers use this field to return the size of the
    output area needed to hold the API's output.  It is filled in with the OS's
    storage size requirement whenever the API return code indicates that the
    output buffer size is too small, but large enough to contain version 1's
    output buffer mapping.
    
    A valid migration scenario is one where a caller compiled to use version 1
    input/output buffer mappings, but the caller's code is run on an OS which
    has been compiled with version 2 input/output mappings.  This field allows
    the caller to find out the proper size buffers to pass in (version 1 input,
    version 2 output).


--- OS identity - processes and fully instrumented ARM transactions ---
pid
    Opaque identifier owned by the ARM/OS layer which uniquely identifies a
    unit of work ("process") to the OS.  This is a platform-dependent value,
    which might be called by different native terms on each platform (e.g. a
    process ID on Unix platforms, a Job ID on OS/400, an ASID/STOKEN/EncToken
    on z/OS).

--- Reporting aggregation data - all work types ---
reporting_id
    Output ID from EWLM classification which maps to a transaction class (ARM
    transactions), process class (processes), or tier (processes controlled by
    an entitlement policy).  Its value is implicitly scoped by the active
    policies.

period_number
    Period number within the service class that the work is being reported in.
    Always 1 (one) in EWLM 1.0.

--- Reporting aggregation data - ARM work only ---
hop_count
    Value which influences reporting aggregation.  This is determined during 
    arm_start_transaction() based upon examination of the parent correlator 
    if one exists, and stored in the owning transaction's correlator.

--- ARM transaction identity ---
appl_inst_id
        This represents the application instance in a specific process which 
        executed the transaction.  The AIID is created by the ARM implementation
        and needs to be unique relative to all active application instances 
        currently running on the system.  It does not need to be the same value 
        that is returned as a handle to the application (though it can be, if it 
        fits in 64 bits).  The first time that WLM encounters a particular AIID 
        value it will invoke ewlm_get_appldata() to get the definition of  the 
        application instance.

---    Parent ARM transaction identity ---
parent_applenv_id
    Proxy for the application environment (application name and application 
    group name) of the parent transaction.  It comes from the transaction’s 
    parent correlator.  If the transaction has no parent correlator, the value 
    should be 0.  The ID is assigned by the ARM component which constructed
    the parent correlator.  Since the ID is not guaranteed to be unique within 
    the management domain, the EWLM agent must resolve it in combination with
    the transaction’s parent server identity.
    
parent_applinst_id
    Application instance of the parent transaction.  
    It comes from the transaction’s 
    parent correlator.  If the transaction has no parent correlator, the value 
    should be 0.  The ID is assigned by the ARM component which constructed
    the parent correlator.  Since the ID is not guaranteed to be unique within 
    the management domain, the EWLM agent must resolve it in combination with
    the transaction’s parent server identity.
    
parent_sys_id
        The server ID that was in the transaction’s parent correlator.  If the 
        transaction had no parent correlator or the parent correlator was not in 
        EWLM’s format, this field is zero.

--- Generic completion transaction/process data ---
response_time
    Elapsed time in milliseconds that the work was associated with the OS or
    ARM instance; sum of queue time and active time.  Since response time is
    only reported once per completed transaction/process, its value is always
    in total mode.

    The minimum value is 0 millisecond.  The maximum value is 2147483647
    (value of the maximum signed integer) which represents over 24 days of
    time.  If the platform calculates a response time greater than the max
    value, it must turn on EWLM_GET_COMPLETIONS_RESPONSE_TIME_OVERFLOW in
    the corresponding get_completions record and set the reported value to the
    max value (this allows OS's to track
    times using precisions different from EWLM without adding new code).
    The remainder ,micro seconds, should be reported in the associated micro
    second field.

    Queue_time = max( Start time - arrival time , 0 )
    Active_time = Stop time - start time

    - Arrival time
        - ARM transactions
            A transaction's arrival time is
            set via the optional arrival time subbuffer passed to 
            arm_start_transaction().  If no such subbuffer is passed, 
            the arrival time defaults to the time that arm_start_transaction() 
            is invoked and the resulting queue time is zero.
        - Processes
            A process's arrival time is the time at which the OS accepted
            the work for later execution.  If process-oriented work is not 
            queued prior to execution, arrival time is equal to start time.

            Arrival time is reset to time of classification if the process is
            reclassified after it is initially queued or after it begins
            execution.  If the EWLM agent has been made aware of the work via
            an in-flight record before reclassification occurs, the revised
            arrival time takes effect *after* generating an artificial
            completion record covering the process's resource usage prior to
            reclassification.
    - Start time
        - ARM transactions
            The transaction's start time is the time that arm_start_transaction()
            is invoked.  
        - Processes
            The process's start time is the later of two events: process
            creation and latest reclassification.  Processes may be reclassified
            in response to changes in their classification attributes (change
            of user ID/name, group ID) or in response to policy activation.

            Start time is reset to time of classification if the process is
            reclassified after it begins
            execution.  If the EWLM agent has been made aware of the work via
            an in-flight record before reclassification occurs, the revised
            start time takes effect *after* generating an artificial
            completion record covering the process's resource usage prior to
            reclassification.
            
    - Stop time
        - ARM transactions
            The stop time is set when arm_stop_transaction() is invoked.  

        - Processes
            Stop time is the time at which the process terminates.

EWLM_GET_COMPLETIONS_RESPONSE_TIME_OVERFLOW
    Response time calculated for the work described by this record was greater
    than the max value allowed by EWLM (see response_time description) so its
    data needs special handling.
    
EWLM_GET_COMPLETIONS_ARTIFICIAL_COMPLETION
    The work described by this record has not actually ended, but a change
    to its management (e.g. a change in process service class triggered by a 
    change in userid) requires that its historical times and resource usage 
    be recorded here for proper reporting bookkeeping.  If the platform is
    reporting metrics data in total mode, the EWLM agent will use the values
    in this record as bases going forward.

--- Generic ARM transaction completion data ---
completion_status
    - ARM transactions
        Value describing the final disposition of the transaction, from
        arm_stop_transaction.

--- Generic process/transaction data ---
queue_time
    Elapsed time in milliseconds between the transaction’s arrival time 
    and its start time (see the response_time explanation for definitions
    of these values).  Always reported in total mode.
        
    If the platform calculates a queue time greater
    than the max allowed (same value as for response times), it must set
    EWLM_GET_ACTIVEDATA_QUEUE_TIME_OVERFLOW (get_activedata record) or
    EWLM_GET_COMPLETIONS_QUEUE_TIME_OVERFLOW (get_completions record) in
    each record generated for the transaction and return the max value as
    the queue time.

EWLM_GET_ACTIVEDATA_QUEUE_TIME_OVERFLOW and
EWLM_GET_COMPLETIONS_QUEUE_TIME_OVERFLOW
    Calculated queue time exceeded the maximum value which fits in a signed
    integer (see response_time for exact value).
    
--- Generic ARM transaction data ---
blocked_time
    - ARM transactions
        Elapsed time in milliseconds that the transaction was in a blocked 
        state (one or more arm_block()s was outstanding).
        Always in total mode.  The EWLM agent could not support delta mode
        reporting of this field without maintaining a per-transaction base
        value, or having the platform report the value of blocked time as 
        reported at the last get_activedata before completion as well as 
        the total at completion,
        which is believed to result in too much overhead.

EWLM_GET_ACTIVEDATA_BLOCKED_TIME_OVERFLOW and
EWLM_GET_COMPLETIONS_BLOCKED_TIME_OVERFLOW
    Calculated blocked time exceeded the maximum value which fits in a signed
    integer (see response_time for exact value).

EWLM_GET_ACTIVEDATA_STALE_REPORTING_ID and
EWLM_GET_COMPLETIONS_STALE_REPORTING_ID
    If on, this bit indicates that the work described by the record was 
    classified using a policy that is no longer active.  Hence its 
    reporting_id may be invalid, and its data requires special handling.

--- Generic in-flight data ---
classify_time
    Time when the work (transaction or process) was last EWLM-classified.
    (see the response_time explanation for related information).
    - ARM transactions
        Transaction start time (transactions are not reported prior to 
        beginning execution), as defined under response_time.
    - Processes
        Process start time, as defined under response_time.

--- Metrics ---
Metrics in general may be reported by each platform in either total mode or
delta mode.  EWLM knows which mode to expect, by field, based on the output
of ewlm_query Resource Metrics Collected which is invoked during EWLM agent
initialization.

times_sampled
    This count is logically incremented each time that a call to 
    ewlm_collect_samples() results in at least one state sample being collected
    for the process.  Unlike the state samples themselves, if the OS separates
    the concepts of thread and process then this should be incremented once
    per process.  Thus for any given interval, dividing the total of all state 
    samples by times_sampled would provide a good approximation of the
    average process multithreading level.  
    
    times_sampled should be the
    same as the number of calls to ewlm_collect_samples() during which the
    entity being sampled (e.g. process) existed.  The preceding text is the
    logical view that EWLM expects.  Each platform is free to implement the
    actual state sampling in any way which preserves the appearance of 
    ewlm_collect_samples() acting as the trigger for state sampling.

cpu_time
    Microseconds of CPU time consumed by the work being measured.

    More exact platform-dependent definitions of what is returned for each
    state sample type are located in ewlmplatos.h.

    cpu_using
        This count is incremented once for each thread found to be dispatched
        (running on a CPU) during state sampling.  The state sampler also 
        attributes a single cpu_using sample to whichever thread the OS would
        dispatch if a work search were done at the instant the state sampler
        runs, in place of the thread under which the state sampler is running,
        to preserve the illusion that the state sampler does not exist.
        This prevents a built-in sampling bias where the thread running the 
        state sampler code would always be observed to be using a CPU.
        
    cpu_delay
        This count is incremented once for each thread found to be ready for
        dispatch (waiting for a CPU).  One CPU delay sample per call to 
        ewlm_collect_samples() is converted to a CPU using sample, as 
        described under cpu_using.
        
    page_delay
        This count is incremented once for each thread found to be waiting for
        resolution of paging I/O due to lack of real memory.
    
    io_delay
        This count is incremented once for each thread found to be waiting for
        a user-initiated I/O request to complete.
    
    
    idle
        This count is incremented once for each process (or thread, depending 
        upon the platform) found to
        have no work at all to do, and the OS knows that at least one thread
        in the process is in a wait (e.g. timer wait) that indicates it is 
        definitely waiting to receive work to do.
    
    other
        This count is incremented once for each process (or thread, depending 
        upon the platform) found to
        have no work at all to do, but the OS is unaware that the process is
        definitely waiting to receive work to do.

    scaled_cpu_time (added by DCR24)
        Scaled microseconds of CPU time consumed by the work being measured.   
        
VERSIONING - PLEASE NOTE
Problem - In EWLM release 1 each structure's version 1 size was set to the
sizeof(struct). The sizeof operator according to the ISO/IEC 9899:1999 states
"When (sizeof is) applied to an operand that has structure or union type,
the result is the total number of bytes in such an object, including internal
and trailing padding." This causes EWLM problems when structs are modified to
include version 2 fields, since the assumption was that sizeof() did not
include trailing padding. The size of the version 1 structure in the version
2 header file can be smaller if the version 2 fields fit within the trailing
padding added by the compiler in version 1.

Solution - Get rid of calculations and code constant based on platform for all
but latest version. This would move constant definitions to ewlmplos.h.
*/
/* DCR 19
 * queue_time_microsec
 * blocked_time_microsec
 * response_time_microsec
 *
 * If a platform can measure time more accurately than milliseconds, it would set
 * version of the output record to 2 and put the microsecond part of these times in
 * the new fields. If the accuracy of the platform's time measurement is somewhere
 * between milliseconds and microseconds, the platform code needs convert its time
 * stamp to microsecond.
 *
 * The other mapping EWLMPLAT.H that will be impacted:
 *
 * ewlm_get_completions_process_output
 * version 2 mapping
 * add queue_time_microsec
 * add response_time microsec
 *
 * ewlm_get_activedata_inflight_process_output
 * add version 2 mapping
 * add queue_time_microsec
 *
 * ewlm_get_activedata_inflight_ARM_partially_instrumented_output
 * add version 2 mapping
 * add queue_time_microsec
 * add blocked_time_microsec
*/

/* --------------------------------------------------------------------------*/
/* --------------------- contents from ewlmplos.h ---------------------------*/
/* ------------------------------------------------------------------------- */
typedef long long ewlm_process_id_t;   /* process ID, various APIs */
typedef long long ewlm_get_activedata_cursor_t; /* restart cursor,
                                                         ewlm_get_activedata */
typedef long long ewlm_connect_handle_t;         /* All ewlm_ APIs */
#define EWLM_INVALID_CONNECT_HANDLE \
((ewlm_connect_handle_t)(-1LL))

typedef long long           ewlm_cpu_time_t;
typedef int                 ewlm_num_samples_t;
typedef int                 ewlm_state_sample_t; /* all state samples 
                                    must be the same size */

#define EWLM_BIG_ENDIAN  1 /* define if big endian */

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

typedef char                 ewlm_char_t;
typedef signed char          ewlm_int8_t;
typedef unsigned char        ewlm_uint8_t;
typedef signed short         ewlm_int16_t;
typedef unsigned short       ewlm_uint16_t;
typedef signed int           ewlm_int32_t;
typedef unsigned int         ewlm_uint32_t;
typedef signed long long     ewlm_int64_t;
typedef unsigned long long   ewlm_uint64_t;
typedef long long            ewlmpol_int_t; /* Used by ewlmpols.h. */

/*
 * previous version constant defintion
 */
#define EWLM_GET_ACTIVEDATA_INFLIGHT_PROCESSES_V001SIZE         (72)
#define EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_V001SIZE    (64)
#define EWLM_GET_COMPLETIONS_PROCESSES_V001SIZE                 (72)
#define EWLM_GET_COMPLETIONS_PARTIALINSTARM_V001SIZE            (56)

/* --------------------------------------------------------------------------*/
/* ------------------------ content of ewlmrcs.h ----------------------------*/
/* ------------------------------------------------------------------------- */
/*
 * Change Activity:
 * Reason      Date      Origin               Description
 * -------  ----------  -----------     ------------------------------------ 
 *          2003-09-29  Geoff Lubold    Return Codes updated to new structure
 *          2003-09-29  Geoff Lubold    ARM Standard Reserved codes added
 *          2003-10-03  Geoff Lubold    Removal and addition of common error
 *                                      EWLM services (policy changes).
 *          2003-10-29  Geoff Lubold    Addition of common error EWLM
 *                                      services (policy changes).
 *          2003-10-31  Geoff Lubold    Merged common EWLM Java and JNI codes
 * D2944    2003-11-18  Geoff Lubold    Common C ARM API's moved to arm4ewlm.h
 * D2989    2003-11-23  John Arwe       Renamed -204 symbol to get rid of DE
 *                                      API name reference
 *                                      from: _TRANDATA_ALREADY_WAITER
 *                                      to:   _GETCOMPLETIONS_SECOND_WAITER  
 * ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
/* -----------------------non-error return codes --------------------------- */
/* ------------------------------------------------------------------------- */

/*
 * Return codes 0 through 999 are reserved for common non-error
 * EWLM services use.
 */
#define EWLM_IRC_EWLM_RANGE_START        (0)

#define EWLM_SUCCESS                     (0)/* Data was returned in the buffer
                                               provided, and no more data
                                               can be returned at this time. */
#define EWLM_MORE_DATA                   (1)/* Data was returned in the buffer 
                                               provided, and more data can be 
                                               returned at this time.  The 
                                               cursor parameter has been
                                               updated to contain a 
                                               platform-dependent restart 
                                               point, and this value must be 
                                               passed on a CONTINUE request in 
                                               order to obtain the next window 
                                               of data. */ 

#define EWLM_IRC_EWLM_RANGE_END          (999)

/*
 * Return codes 1000 through 1999 are reserved for common non-error
 * ARM services use.
 */
#define EWLM_IRC_ARM_RANGE_START           (1000)
#define EWLM_IRC_ARM_RANGE_END             (1999)

/*
 * Return codes 2000 through 2999 are reserved for AIX non-error use.
 */
#define EWLM_IRC_AIX_RANGE_START           (2000)
#define EWLM_IRC_AIX_RANGE_END             (2999)

/*
 * Return codes 3000 through 3999 are reserved for OS/400 non-error use.
 */
#define EWLM_IRC_OS_400_RANGE_START        (3000)
#define EWLM_IRC_OS_400_RANGE_END          (3999)

/*
 * Return codes 4000 through 4999 are reserved for z/OS non-error use.
 */
#define EWLM_IRC_Z_OS_RANGE_START          (4000)
#define EWLM_IRC_Z_OS_RANGE_END            (4999)

/*
 * Return codes 5000 through 5999 are reserved for common EWLM Java and JNI
 * services non-error use.
 */
#define EWLM_IRC_EWLM_JAVA_RANGE_START     (5000)
#define EWLM_IRC_EWLM_JAVA_RANGE_END       (5999)

/*
 * Return codes 6000 through 6999 are reserved for Windows non-error use.
 */
#define EWLM_IRC_WINDOWS_RANGE_START       (6000)
#define EWLM_IRC_WINDOWS_RANGE_END         (6999)

/*
 * Return codes 7000 through 7999 are reserved for Linux non-error use.
 */
#define EWLM_IRC_LINUX_RANGE_START         (7000)
#define EWLM_IRC_LINUX_RANGE_END           (7999)

/*
 * Return codes 8000 through 8999 are reserved for Solaris non-error use.
 */
#define EWLM_IRC_SOLARIS_RANGE_START       (8000)
#define EWLM_IRC_SOLARIS_RANGE_END         (8999)

/*
 * Return codes 9000 through 9999 are reserved for HP/UX non-error use.
 */
#define EWLM_IRC_HP_UX_RANGE_START         (9000)
#define EWLM_IRC_HP_UX_RANGE_END           (9999)


/*
 * Return codes 15000 through 16999 are reserved for common ARM Java and JNI
 * services non-error use.
 */
#define EWLM_IRC_ARM_JAVA_RANGE_START      (15000)
#define EWLM_IRC_ARM_JAVA_RANGE_END        (16999)

#define EWLM_IRC_JAVA_RANGE_START          (15000)
#define EWLM_IRC_JAVA_RANGE_END            (16999)

/*
 * Return codes 20000 through 20999 are reserved for ARM Standard
 * services use.
 */
#define ARM_IRC_RESERVED_START             (20000)
#define ARM_IRC_RESERVED_END               (20999)


/* ------------------------------------------------------------------------- */
/* -------------------------error return codes ----------------------------- */
/* ------------------------------------------------------------------------- */
    
/*
 * Return codes -1 through -999 are reserved for common EWLM services use.
 */
#define EWLM_RC_EWLM_RANGE_START            (-1)
#define EWLM_RC_EWLM_RANGE_END            (-999)

#define EWLM_RC_POLICY_MAX                (-100)
#define EWLM_NO_CONNECTION                (-100)/* The EWLM agent was not 
                                                   connected to the platform 
                                                   component. */
#define EWLM_BAD_CONNECT_HANDLE           (-101)/* The input connect handle was
                                                   not recognized as valid by 
                                                   the platform component.  
                                                   Either the value is invalid,
                                                   or the value is valid but 
                                                   the connect handle is not 
                                                   associated with the EWLM 
                                                   agent this latter check is 
                                                   not implemented by all 
                                                   platforms, i.e. Linux). */
#define EWLM_BAD_POLICY                   (-102)
#define EWLM_NO_PREPARED_POLICY           (-103)
#define EWLM_WRONG_POLICY                 (-104)
#define EWLM_BAD_POLICY_ADDR              (-105)
#define EWLM_BAD_POLICY_HEADER            (-106)
#define EWLM_BAD_POLICY_SIZE              (-107)

#define EWLM_BAD_POLICY_TRIPLET_POLICY    (-108)
#define EWLM_BAD_POLICY_TRIPLET_WORKLOAD  (-109)
#define EWLM_BAD_POLICY_TRIPLET_SCLS      (-110)
#define EWLM_BAD_POLICY_TRIPLET_GOAL      (-111)
#define EWLM_BAD_POLICY_TRIPLET_APPLENV1  (-112)
#define EWLM_BAD_POLICY_TRIPLET_APPLENV2  (-113)
#define EWLM_BAD_POLICY_TRIPLET_APPLENV3  (-114)
#define EWLM_BAD_POLICY_TRIPLET_TCCLS     (-115)
#define EWLM_BAD_POLICY_TRIPLET_TCFILT    (-116)
#define EWLM_BAD_POLICY_TRIPLET_SERV      (-117)
#define EWLM_BAD_POLICY_TRIPLET_PCCLS     (-118)
#define EWLM_BAD_POLICY_TRIPLET_PCFILT    (-119)
#define EWLM_BAD_POLICY_TRIPLET_FILTVAL   (-120)
#define EWLM_BAD_POLICY_APPLENV1          (-121)
#define EWLM_BAD_POLICY_APPLENV2          (-122)
#define EWLM_BAD_POLICY_APPLENV3          (-123)
#define EWLM_BAD_POLICY_TCLASS1           (-124)
#define EWLM_BAD_POLICY_TCLASS2           (-125)
#define EWLM_BAD_POLICY_TCLASS3           (-126)
#define EWLM_BAD_POLICY_TCFILTER_EYE      (-127)
#define EWLM_BAD_POLICY_TCFILTER_INDEX    (-128)
#define EWLM_BAD_POLICY_TCFILTER_SDA      (-129)
#define EWLM_BAD_POLICY_SERV              (-130)
#define EWLM_BAD_POLICY_PCLASS            (-131)
#define EWLM_BAD_POLICY_PCFILTER_EYE      (-132)
#define EWLM_BAD_POLICY_PCFILTER_INDEX    (-133)
#define EWLM_BAD_POLICY_PCFILTER_SDA      (-134)

#define EWLM_BAD_POLICY_TYPE              (-199)/* Policy type not supported */
#define EWLM_RC_POLICY_MIN                (-199)


#define EWLM_RC_COM_MIN                   (-200)
#define EWLM_BAD_FLAGS                    (-200)
#define EWLM_BAD_BUFFER                   (-201)
#define EWLM_BAD_TIMEOUT                  (-202)/* Timeout value not in range 
                                                   1..600,000 inclusive */
#define EWLM_ENOMEM                       (-203)
#define EWLM_GETCOMPLETIONS_SECOND_WAITER (-204)
#define EWLM_MISSING_PARM                 (-205)/* Required input parameter s) 
                                                   not provided. */
#define EWLM_BAD_PARAMETER_ADDRESS        (-206)
#define EWLM_NOT_AUTHORIZED               (-207)
#define EWLM_BAD_APPL_INST                (-208)
#define EWLM_LIMITOF1_CONNECTION          (-209)/* The platform has another 
                                                   connection currently open.
                                                   This connection request was
                                                   rejected due to the limit of
                                                   one active connection per OS
                                                   image. */
#define EWLM_INVALID_SIZE                 (-210)
#define EWLM_INVALID_TOKEN                (-211)/* API such as get_activedata
                                                   received a value, such as a
                                                   token or cursor, which is 
                                                   invalid and the platform can 
                                                   guarantee that this is the 
                                                   result of a bug in the caller 
                                                   */
#define EWLM_BAD_IN_BUFFER                (-212)/* Error referencing input 
                                                   buffer bad address, not 
                                                   readable...). */
#define EWLM_BAD_OUTBUFFER                (-213)/* Error referencing output 
                                                   buffer bad address, not 
                                                   writable...). */
#define EWLM_UNSUPPORTED_REQUEST_TYPE     (-214)/* Request type not 
                                                   supported */
#define EWLM_OUTBUFFER_BELOW_V1SIZE       (-215)/* Output buffer below minimum
                                                   size. At least enough 
                                                   storage must be provided to 
                                                   return the version number 
                                                   and required output size. */
#define EWLM_OUTBUFFER_TOO_SMALL          (-216)/* Output buffer too small to 
                                                   contain all data the OS 
                                                   returns. Sizeneeded contains
                                                   the buffer size that should 
                                                   be used. */
#define EWLM_OUTBUFFER_TOO_LARGE          (-217)/* Output buffer above maximum
                                                   size. */
#define EWLM_INBUFFER_BELOW_V1SIZE        (-218)/* Input buffer below minimum 
                                                   size. */
#define EWLM_INBUFFER_TOO_SMALL           (-219)/* Input buffer too small. */
#define EWLM_INBUFFER_TOO_LARGE           (-220)/* Input buffer too small. */
#define EWLM_AIID_NOT_FOUND               (-221)/* AIID not found */
#define EWLM_SUPPORT_NOT_ENABLED          (-222)/* Error because ewlm support 
                                                   not enabled in the OS by 
                                                   default. */
#define EWLM_COMPONENT_ERROR              (-223)/* The platform experienced an
                                                   error not covered by other 
                                                   return codes, and recovered.
                                                   This is normally an 
                                                   environmental error such as 
                                                   an unsolicited exception.
                                                   For errors whose cause can 
                                                   be narrowed down, use and/or
                                                   define a specific return 
                                                   code rather than using this 
                                                   catch-all.*/
#define EWLM_LOCAL_WLM_NOT_ACTIVE         (-224) /* Return code to signal
                                                    that local WLM is not
                                                    active.*/
#define EWLM_LOCAL_WLM_PASSIVE            (-225) /* Return code to signal
                                                    that local WLM is in
                                                    passive mode. */
#define EWLM_MAX_MGMTCLASSES              (-226) /* Return code to signal
                                                    that platform reached
                                                    maximum number of
                                                    classes it can support.*/
#define EWLM_PROCESS_LOCAL_WLM_MANAGED    (-227) /* Return code to signal
                                                    that platform can not
                                                    manage process to EWLM
                                                    policy because process
                                                    is already associated
                                                    to local WLM management.*/
#define EWLM_BAD_MANAGEMENT_ID            (-228) /* Return code to signal
                                                    that platform can not
                                                    find the management
                                                    class for the
                                                    specified id */
#define EWLM_UNSUPPORTED_RESOURCE_TYPE    (-229) /* Return code to signal
                                                    that platform does not
                                                    support local
                                                    resource management
                                                    for the specified
                                                    resource type. */
#define EWLM_PLATFORM_COMPONENT_ERROR     (-230) /* Return to indicate
                                                    that a severe error was
                                                    encountered during 
                                                    platform service 
                                                    processing */
#define EWLM_RC_PROBLEMATIC_ENV           (-231) /* There is a configuration
                                                    problem detected on the managed
                                                    node that prevent EWLM to manage
                                                    effectively. Details of the
                                                    problem are logged in the
                                                    system logs, such as Linux
                                                    syslogs or Windows event logs.
                                                    If you are running an EWLM MS 
                                                    after the problem is fixed,
                                                    restart the MS. */
#define EWLM_RC_NOT_IN_LPAR               (-232) /* The managed node was previously
                                                    running in an LPAR (or VM), but
                                                    it's been detected that it now
                                                    runs on a different LPAR
                                                    environment, or possibly, on
                                                    a non-LPAR environment.
                                                    If you are running an EWLM MS
                                                    then restarting the MS may be
                                                    required to allow the MS to
                                                    reconfigure itself for the
                                                    new environment, accordingly. */
#define EWLM_LOCAL_MANAGEMENT_NOT_ACTIVE  (-233) /* Local resource management
                                                    not active. */
#define EWLM_LOCAL_MANAGEMENT_ALREADY_ACTIVE (-234) /* Local resource management
                                                       already active.*/
#define EWLM_INVALID_PID                  (-235) /* PID argument to reassign
                                                    function is invalid. */

#define EWLM_RC_COM_MAX                   (-235)


/*
 * Return codes -1000 through -1999 are reserved for common ARM services use.
 */
#define EWLM_RC_ARM_RANGE_START           (-1000)
#define EWLM_RC_ARM_RANGE_END             (-1999)

/*
 * Return codes -2000 through -2999 are reserved for AIX use.
 */
#define EWLM_RC_AIX_RANGE_START           (-2000)
#define EWLM_RC_CONVERT_INVAL             (-2000)/* Unable to open string converter */
#define EWLM_RC_INVAL_STRING              (-2001)/* Invalid input string, 
                                                    string has an input character
                                                    that can not be converted  */ 
#define EWLM_BAD_IN_VERSION               (-2002) /* version number <= 0 */
#define EWLM_RC_INT_ERROR_0               (-2003) /* string table overflow
                                                     in libewlmplat.a       */
#define EWLM_RC_AIX_RANGE_END             (-2999)

/*
 * Return codes -3000 through -3999 are reserved for OS/400 use.
 */
#define EWLM_RC_OS_400_RANGE_START        (-3000)
#define EWLM_RC_OS_400_RANGE_END          (-3999)

#define EWLM_INT_ERROR_0                  (-3003)
#define EWLM_INT_ERROR_1                  (-3004)

/*
 * Return codes -4000 through -4999 are reserved for z/OS use.
 */
#define EWLM_RC_Z_OS_RANGE_START          (-4000)
#define EWLM_RC_Z_OS_RANGE_END            (-4999)

/*
 * Return codes -5000 through -5999 are reserved for common EWLM Java and JNI
 * services use.
 */
#define EWLM_RC_EWLM_JAVA_RANGE_START     (-5000)

#define EWLM_RC_EWLM_ARMJNI_START         (-5001)
#define EWLM_RC_EWLM_ARMJNI_END           (-5099)

#define EWLM_RC_EWLM_PLATJNI_START        (-5101)
#define EWLM_RC_EWLM_PLATJNI_END          (-5199)

#define EWLM_RC_EWLM_NONIBMJNI_START      (-5201)
#define EWLM_RC_EWLM_NONIBMJNI_END        (-5299)

#define EWLM_RC_EWLM_NETWLMJNI_START      (-5301)
#define EWLM_RC_EWLM_NETWLMJNI_END        (-5399)

#define EWLM_RC_EWLM_LOCALRESMGMTJNI_START (-5401)
#define EWLM_RC_EWLM_LOCALRESMGMTJNI_END   (-5449)

#define EWLM_RC_EWLM_JAVA_RANGE_END       (-5999)

/*
 * Return codes -6000 through -6999 are reserved for Windows use.
 */
#define EWLM_RC_WINDOWS_RANGE_START       (-6000)
#define EWLM_RC_WINDOWS_RANGE_END         (-6999)

/*
 * Return codes -7000 through -7999 are reserved for Linux use.
 */
#define EWLM_RC_LINUX_RANGE_START         (-7000)
#define EWLM_RC_LINUX_RANGE_END           (-7999)

/*
 * Return codes -8000 through -8999 are reserved for Solaris use.
 */
#define EWLM_RC_SOLARIS_RANGE_START       (-8000)
#define EWLM_RC_SOLARIS_RANGE_END         (-8999)

/*
 * Return codes -9000 through -9999 are reserved for HP/UX use.
 */
#define EWLM_RC_HP_UX_RANGE_START         (-9000)
#define EWLM_RC_HP_UX_RANGE_END           (-9999)

/*
 * Return codes -15000 through -16999 are reserved for common ARM Java and JNI
 * services use.
 */
#define EWLM_RC_ARM_JAVA_RANGE_START      (-15000)
#define EWLM_RC_ARM_JAVA_RANGE_END        (-16999)

#define EWLM_RC_JAVA_RANGE_START          (-15000)
#define EWLM_RC_JAVA_RANGE_END            (-16999)

/*
 *Return codes -17000 to -17999 are reserved for internal error codes.
 */
#define EWLM_RC_EWLMOTHR_ERROR_RANGE_START                (-17000)
#define EWLM_RC_EWLMOTHR_ERROR_RANGE_END                  (-17999)
/*
 * Return codes -20000 through -20999 are reserved for ARM Standard
 * services use.
 */
#define ARM_ERROR_CODE_RESERVED_START     (-20000)
#define ARM_ERROR_CODE_RESERVED_END       (-20999)

/*
 * Return codes -28000 to -29999 are reserved for EWLM common use.
 * No dump will be generated.  A configuration error will be issued.
 */
#define EWLM_RC_EWLM_COMMON_NODUMP_CONFIG_RANGE_START     (-28000)
#define EWLM_RC_EWLM_COMMON_NODUMP_CONFIG_RANGE_END       (-29999)

/*
 * Return codes -30000 to -32767 are reserved for EWLM common use.
 * No dump will be generated and no configuration error will be issued.
 */
#define EWLM_RC_EWLM_COMMON_NODUMP_NOCONFIG_RANGE_START   (-30000)
#define EWLM_RC_EWLM_COMMON_NODUMP_NOCONFIG_RANGE_END     (-32767)

/* --------------------------------------------------------------------------*/
/* ------------------------ content of ewlmtype.h ---------------------------*/
/* ------------------------------------------------------------------------- */
/* Change Activity:
 * Reason      Date      Origin               Description
 * -------  ----------  -----------     ------------------------------------ 
 * DCR 002  2003-08-31  John Arwe       Add 2 bits to completion records for
 *                                      tracking of why hop count was not
 *                                      incremented
 * DCR 011  2003-09-01  John Arwe       Change duration to signed per Yocom
 *                                      note
 * DCR 011  2003-09-02  John Arwe       Rename files to be within 8-char limit
 *                                      Update un/encodedbytestream comments
 *                                      with default origin
 * DCR xxx  2003-09-23  Geoff Lubold    Change XXX_t types to ewlm_XXX_t 
 *                                      types
 * DCR 010  2003-10-01  Geoff Lubold    updated Platform OS API LLD to 
 *                                      include flag under Generic ARM 
 *                                      transaction Data.
 * F2691    2003-10-28  Geoff Lubold    Includes changed from " " to < >
 * D2593    2003-11-11  John Arwe       Clarify encodings comments
 * DCR 030  2003-11-24  John Arwe       Add blocked time overflow bits
 * ------------------------------------------------------------------------- */
/* 
 * Guidelines for files like this which are intended to be the same across all 
 * platforms:
 * - Not all platforms support int_64 natively, so an ewlm_int64 type is defined
 *   in ewlmplatos.h, and each platform completes the definition there.
 * - Not all C compilers support the double-slash end of line comments, so stick 
 *   to the explicit open/close style comments.
 */ 
#include <arm4ewlm.h>

/* ------------------------------------------------------------------------- */
/* --------------------------- type definitions ---------------------------- */
/* ------------------------------------------------------------------------- */

typedef ewlm_int8_t             ewlm_period_t;
typedef ewlm_int64_t            ewlm_timestamp_t;    /* Same as ARM 4.0 timestamps:
                                                microseconds since 
                                                1 January 2000 using the
                                                Gregorian calendar
                                                */
typedef ewlm_int32_t            ewlm_duration_t;  /* Millisecond unit elapsed
                                                time.  Intentionally smaller
                                                than timestamp to limit the 
                                                size of in-flight and 
                                                completion records.
                                                */
typedef ewlm_int16_t            ewlm_get_activedata_flags_t; /* 
                                                for in-flight records */
                                                
typedef ewlm_int16_t            ewlm_micro_duration_t; /* Microsecond unit elapsed
                                                          time. (remainder of
                                                          millisecond unit elapsed
                                                          time.)*/
typedef ewlm_int64_t            ewlm_arrival_delay_duration_t; /* Microsecond unit
                                                 duration from tran edge arrival
                                                 time to current hop arrival
                                                 time.  (This delay can only be
                                                 computed when EWLM time sync is
                                                 actively monitoring clock deltas
                                                 on the transaction edge and at
                                                 the current hop.) */


#define EWLM_GET_ACTIVEDATA_STALE_REPORTING_ID      (0x8000)
#define EWLM_GET_ACTIVEDATA_QUEUE_TIME_OVERFLOW     (0x4000)
#define EWLM_GET_ACTIVEDATA_NO_HOP_SAME_AE          (0x2000)
#define EWLM_GET_ACTIVEDATA_NO_HOP_SAME_AI          (0x1000)
#define EWLM_GET_ACTIVEDATA_TOPOLOGY_NOT_VALID      (0x0800)
#define EWLM_GET_ACTIVEDATA_REPORTING_GAP           (0x0400)
#define EWLM_GET_ACTIVEDATA_BLOCKED_TIME_OVERFLOW   (0x0200)
#define EWLM_GET_ACTIVEDATA_LOCAL_WLM_MANAGED       (0x0100)
#define EWLM_GET_ACTIVEDATA_TIME_SUSPECTED          (0x0080)

/* definitions for flagsv3 */
#define EWLM_GET_ACTIVEDATA_ARRIVAL_DELAY           (0x8000)
#define EWLM_GET_ACTIVEDATA_ASYNC_PARENT            (0x4000)
#define EWLM_GET_ACTIVEDATA_INDEPENDENT_TRAN        (0x2000)
#define EWLM_GET_ACTIVEDATA_MSGEVENT_START          (0x1000)
#define EWLM_GET_ACTIVEDATA_BLOCKED_ON_MESSAGE      (0x0800)

typedef ewlm_int16_t           ewlm_get_completions_flags_t; /* 
                                                for completion records */
#define EWLM_GET_COMPLETIONS_STALE_REPORTING_ID     (0x8000)
#define EWLM_GET_COMPLETIONS_QUEUE_TIME_OVERFLOW    (0x4000)
#define EWLM_GET_COMPLETIONS_NO_HOP_SAME_AE         (0x2000)
#define EWLM_GET_COMPLETIONS_NO_HOP_SAME_AI         (0x1000)
#define EWLM_GET_COMPLETIONS_TOPOLOGY_NOT_VALID     (0x0800)
#define EWLM_GET_COMPLETIONS_REPORTING_GAP          (0x0400)
#define EWLM_GET_COMPLETIONS_BLOCKED_TIME_OVERFLOW  (0x0200)

#define EWLM_GET_COMPLETIONS_ARTIFICIAL_COMPLETION  (0x0080)
#define EWLM_GET_COMPLETIONS_RESPONSE_TIME_OVERFLOW (0x0040)
#define EWLM_GET_COMPLETIONS_LOCAL_WLM_MANAGED      (0x0020)
#define EWLM_GET_COMPLETIONS_TIME_SUSPECTED         (0x0010)

/* definitions for flagsv3 */
#define EWLM_GET_COMPLETIONS_ARRIVAL_DELAY          (0x8000)
#define EWLM_GET_COMPLETIONS_ASYNC_PARENT           (0x4000)
#define EWLM_GET_COMPLETIONS_INDEPENDENT_TRAN       (0x2000)
#define EWLM_GET_COMPLETIONS_MSGEVENT_START         (0x1000)
#define EWLM_GET_COMPLETIONS_MSGFLOW_COMPLETE       (0x0800)
#define EWLM_GET_COMPLETIONS_REPORTED_TRANSACTION   (0x0400)

typedef ewlm_int16_t            ewlm_ARM_completion_status_t; /* ARM transaction
                                                completion status
                                                */
                                                
typedef ewlm_int32_t            ewlm_policytype_t;   /* ewlm_x_policy APIs
                                                Policy type
                                                */
                                                
typedef ewlm_int32_t            ewlm_status_t;       /* API return code
                                                */
typedef ewlm_int64_t      ewlm_applenv_id_t;   /* AEID: 
                                                application environment ID
                                                assigned by ARM implementation
                                                */
typedef ewlm_int64_t      ewlm_applinst_id_t;  /* AIID: 
                                                application instance ID
                                                assigned by ARM implementation
                                                */
typedef ewlm_int16_t            ewlm_local_server_id_t; /* Local server ID 
                                                (short form of server UUID)
                                                assigned by EWLM
                                                */
typedef ewlm_int32_t            ewlm_bytelength_t;   /* Size in bytes of 
                                                whatever context it describes
                                                */
typedef ewlm_int16_t            ewlm_APIlevel_t;     /* Support level of a set of 
                                                APIs, used by EWLM to know if
                                                a given set of API signatures
                                                is supported by the platform
                                                (thus EWLM may call them).
                                                */
typedef ewlm_int16_t            ewlm_APIversion_t;   /* Version number, 
                                                specific to each API.  Replaces
                                                any code dependency on size to
                                                know which data is returned.  So
                                                if version 2 of an interface 
                                                adds 3 pieces of data, the 
                                                receiver of the structure would
                                                test the version to know whether
                                                or not the 3 new pieces of data
                                                came back.
                                                */

typedef ewlm_int16_t           ewlm_tranevent_count_t; /* Transaction
                                                instance event count
                                                type.        */
typedef ewlm_int16_t            ewlm_msg_correlation_flags_t; /* Flags
                                                for message correlation
                                                records      */
/* Flag to indicate this correlator was a secondary  correlator from the
   arm_start_transaction() event.                            */
#define EWLM_MSG_CORR_STARTTRAN     (0x8000)

/* ------------------------------------------------------------------------- */
/* --------------------------- macro definitions --------------------------- */
/* ------------------------------------------------------------------------- */

#define MAXVERSIONSIZE(old,latest) (old>latest ? old:latest)
#define IS_EWLM_PROC(pv) (((pv->pv_class >= WLM_EWLM_LOW) && \
                          (pv->pv_class < WLM_EWLM_HI))? 1 : 0)

/* --------------------------------------------------------------------------
The string descriptor type allows the size of a string returned to change
without causing a version number or API support level change (in other words, 
simply by recompiling).  If the string were allocated in-line as an array of 
char, a subsequent length change (e.g. from a later version of some standard, 
or an OS change which increases the maximum size of a string already being 
returned) would force one of the following:
- Splitting of the string into new and old pieces (compatible)
- Changing the offset of the string in the output buffer (incompatible)
- Changing the length of the string in the output buffer, but not the offset
  (incompatible, since later fields would have to change offsets to make room).
Can be used by APIs which return several strings with the same encoding to save
memory.
---------------------------------------------------------------------------- */ 
typedef struct ewlm_unencodedbytestream
{
    ewlm_int32_t        offset;       /* Offset from some documented point to the 
                                  first byte.  If the place where this type
                                  is instantiated does not document the origin
                                  the default is the containing structure */

    ewlm_int32_t        length;       /* Length of value in bytes not characters
                                  excluding any termination byte(s). */

/* If both the offset and length are zero the string is not provided. 
 * A non-zero offset and zero length denote the null string (which might be
 * considered equivalent to not providing the string, depending upon the 
 * the API where this is used).
 */
} ewlm_unencodedbytestream_t;

/* --------------------------------------------------------------------------
The string described may be in any supported encoding.  
Used by APIs which find it more efficient to
encapsulate the encoding with the string.
---------------------------------------------------------------------------- */ 

typedef struct ewlm_encodedbytestream
{
    ewlm_int32_t        offset;       /* Offset from some documented point to the 
                                  first byte.  If the place where this type
                                  is instantiated does not document the origin
                                  the default is the containing structure */

    ewlm_int32_t        length;       /* Length of value in bytes (not characters)
                                  excluding any termination byte(s). */
/* If both the offset and length are zero the string is not provided. 
 * A non-zero offset and zero length denote the null string (which might be
 * considered equivalent to not providing the string, depending upon the 
 * the API where this is used).
 */
    ewlm_int16_t        value;       /* The same encoding values as supported in 
                                   the ARM 4.0 standard are used.  Reqd-ARM shows
                                   those required by the ARM standard, Reqd-EWLM
                                   shows those required by the EWLM ARM 
                                   implementation, Allowed shows those allowed by
                                   the EWLM product/supporting ARM implementations.
                                                  ARM APIs          ewlmplat APIs
                             3    US-ASCII        Reqd-ARM          specify 106
                           106    UTF-8           Reqd-ARM          Allowed
                          1013    UTF-16BE        z,i,p             specify 1015
                          1014    UTF-16LE        Reqd-ARM-Windows  specify 1015
                          1015    UTF-16          Reqd-EWLM         Allowed
                          2028    EBCDIC IBM037   i: Reqd-ARM
                          2102    EBCDIC IBM1047  z: Reqd-ARM       z: Allowed

                                  Note on UTF-16: only 1015 is supported by
                                  the ewlmplat APIs, which uses platform default
                                  Endian-ness.  Thus on z,i,p it is equivalent to
                                  1013 without a byte order marker, and on x it is
                                  equivalent to 1014 without a marker.
                                */
    
    ewlm_int16_t        flags;
    
    #define EWLM_NULL_TERMINATED      (0x0001) 
    /* If EWLM_NULL_TERMINATED is on, the termination byte(s) are dependent upon
       the encoding value used.
       UTF-8         Single null terminator
       UTF-16        Double null terminator
    */
} ewlm_encodedbytestream_t;

/* ------------------------------------------------------------------------- */
/* --------------------------- query services ------------------------------ */
/* ------------------------------------------------------------------------- */

/* 
 *  Signature: 
 *              EWLM query 
 */ 
ewlm_status_t   ewlm_query(
    /* [in]  */ ewlm_char_t                       *input_buffer,
    /* [in]  */ ewlm_bytelength_t          input__buffer_size,
    /* [i/o] */ ewlm_char_t                       *output_buffer,
    /* [in]  */ ewlm_bytelength_t          output_buffer_size
);

/* 
    Required Return codes:
       0    EWLM_SUCCESS
    -100    EWLM_NO_CONNECTION
    -214    EWLM_UNSUPPORTED_REQUEST_TYPE
    -215    EWLM_OUTBUFFER_BELOW_V1SIZE
    -216    EWLM_OUTBUFFER_TOO_SMALL
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -222    EWLM_SUPPORT_NOT_ENABLED

    Optional Return codes:
    -101    EWLM_BAD_CONNECT_HANDLE
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
    -213    EWLM_BAD_OUTBUFFER
*/ 


/*
 * Query Server Configuration Input
 */ 
typedef struct ewlm_query_server_configuration_input
{
    ewlm_APIversion_t          version;
    ewlm_int32_t                    request_type;
    #define EWLM_QUERY_SERVER_CONFIGURATION        (1)
    #define EWLM_QUERY_SERVER_STATISTICS           (2)
    #define EWLM_QUERY_RESOURCE_METRICS_COLLECTED  (3)

    ewlm_connect_handle_t      connect_handle;
    /* ------- end of data present in version 1        */
    #define EWLM_QUERY_SERVER_CONFIGURATION_IN_VERSION001     (1)
    #define EWLM_QUERY_SERVER_CONFIGURATION_INPUT_V001SIZE \
    sizeof(ewlm_query_server_configuration_input_t) 
} ewlm_query_server_configuration_input_t;

/*
 * Query Server Configuration Output
 */ 
typedef struct ewlm_query_server_configuration_output
{ 
   ewlm_APIversion_t           version;
   ewlm_bytelength_t           sizeneeded;

   ewlm_int32_t                platform_support_level1; /* ewlm_ API support */
   /* F15321 */
   #define EWLM_QUERY_PLATFORMAPI_EWLM12    (0x80000000)/* EWLM 1.2 release */
   #define EWLM_QUERY_PLATFORMAPI_EWLM10    (0x40000000)/* EWLM 1.0 release */
   #define EWLM_QUERY_PLATFORMAPI_EL        (0x20000000)/* Non-IBM
                                                           enforcement layer
                                                           APIs exist */
   #define EWLM_QUERY_PLATFORMAPI_EWLM31    (0x01000000)/* EWLM 3.1 release */

   ewlm_int32_t                platform_support_level2;
   #define EWLM_QUERY_GLOBAL_PERF_DATA      (0x80000000) /* Platform supports the
                                                             ewlm_global_perf_data
                                                             API                */
    #define EWLM_QUERY_SPURR_SUPPORTED      (0x40000000) /* F32148 DCR24
                                                            Platform supports reporting
                                                            Scaled CPU Utilization when
                                                            processor frequency is 
                                                            variable */
                                                            
   #define EWLM_QUERY_PROC_SPURR_CAPPED     (0x20000000) /* F32148 DCR24
                                                            Platform is capping per process
                                                            scaled CPU utilization to
                                                            un-scaled CPU utilization.
                                                            cpu_time and scaled_cpu_time 
                                                            reported in process data will 
                                                            be same. System level scaled
                                                            CPU utilization reported in 
                                                            server statistics is not capped */                                                           

   ewlm_int32_t                entitlement_support_level;
   #define EWLM_QUERY_ENTITLEMENTAPI_NONE   (0x40000000)/* No entitlement    */
   #define EWLM_QUERY_ENTITLEMENTAPI_CPU    (0x80000000)/* Local CPU Resource*/
                                                        /* Management        */


   ewlm_int32_t                network_support_level;
   #define EWLM_QUERY_NETWORKAPI_NONE       (0x40000000)/* No net_ APIs */
   #define EWLM_QUERY_NETWORKAPI_LOADBAL    (0x20000000)/* Load balancing */
   #define EWLM_QUERY_NETWORKAPI_ACCEPTQ    (0x10000000)/* Accept queue */

   ewlm_bytelength_t           max_practical_get_completions_buffer_size;/*
                                OS-suggested size for ewlm_get_completions
                                output buffer.  The value returned should be no
                                larger than the size of the buffer used by the
                                OS to buffer completion records. */
    ewlm_bytelength_t          recommended_get_activedata_buffer_size;/* 
                                OS-suggested size for ewlm_get_activedata
                                output buffer.  
                                The platform will be in a better position 
                                than the caller to understand the relative 
                                importance of memory size, and any limits 
                                within the platform code that would influence
                                the maximum number of concurrent processes 
                                and/or ARM transactions. The tradeoff here is 
                                between memory size and the number of restarts. 
                                The callers is free to accept or ignore the 
                                recommendation, but as long as it appears to be 
                                reasonable it should be used. */
    ewlm_int32_t                    flags001;
   /* Hypervisors */
   #define EWLM_QUERY_SERVER_CONFIGURATION_OS_UNDER_ZVM     (0x40000000)
   #define EWLM_QUERY_SERVER_CONFIGURATION_OS_UNDER_LPAR    (0x20000000)
   #define EWLM_QUERY_SERVER_CONFIGURATION_OS_UNDER_VMWARE  (0x10000000)

    ewlm_encodedbytestream_t   hostname;/* TCP hostname */
    ewlm_encodedbytestream_t   software_cluster_name;/*
                                If the platform has a platform-specific cluster 
                                name, e.g. z/OS sysplex, the sysplex name is 
                                here. Null string otherwise. */
    ewlm_encodedbytestream_t   hardware_cluster_name;/*
                                If the image is running in a hypervisor-managed 
                                cluster, this field contains a numeric group ID
                                followed by a space, the manufacturer name 
                                followed by a space and model number 
                                concatenated with serial number 
                                e.g 9406-57010-XYZ10. '-' in model number or
                                serial number should be included. If model 
                                number and serial number contains manufacturer 
                                name it should be stripped off. For example, if 
                                model number is "IBM,9119-595", only "9119-595" 
                                should be included in model number and "IBM" 
                                should be returned as part of manufacturer name.
                                */
                                /*
                                with EWLM Release 3.1 the hardware_cluster_name
                                can be the hostname of the LPAR hosting server
                                when the MS is running in an LPAR/VM. The
                                hardware_cluster_name can also be an empty
                                string when the MS is running on an LPAR/VM
                                if the platform support code cannot access this
                                information.
                                */
    ewlm_unencodedbytestream_t hardware_cluster_name_binary;/*
                                Same info as the previous field, but not
                                required to be in printable format. Used to
                                recognize the boundary of the hardware cluster.
                                All images with an identical binary h/w cluster
                                name are assumed to belong to the same 
                                hypervisor cluster. */
    ewlm_encodedbytestream_t   os_platform;/* Classification filter, value is
                                one of:
                                z/OS, AIX, OS/400, Solaris, Linux, Windows */
    ewlm_encodedbytestream_t   os_architecture;/* Used for reporting only.  
                                Reflects the machine's hardware architecture 
                                family.  The value returned is owned by the 
                                platform. */
    ewlm_encodedbytestream_t   os_level_summary;/* Used for classification. 
                                Format of the value is 
                                v.r.j.n, where 
                                    v = version
                                    r = release
                                    j = major modification level
                                    n = minor modification level
                                Any of the component values maybe alphanumeric.
                                Leading zeros on numeric values should be 
                                suppressed. */
    ewlm_encodedbytestream_t   os_level_detail;/*
                                Used for reporting only.  Should include the 
                                same info as the summary version, although 
                                not necessarily in the same format.  Can 
                                optionally include more detailed info such 
                                as service pack level. */
    ewlm_encodedbytestream_t   os_instance_name;/* 
                                If the platform has a native image name, e.g. 
                                z/OS system name, its value goes here. 
                                Otherwise the TCP hostname should be used. */

    /* ------- end of data present in version 1 */
    #define EWLM_QUERY_SERVER_CONFIGURATION_OUTVERSION001     (1)
    #define EWLM_QUERY_SERVER_CONFIGURATION_OUTPUT_V001SIZE \
        offsetof(ewlm_query_server_configuration_output_t,\
                 hypervisor_capability)
/*F12760 */
      ewlm_int32_t                hypervisor_capability;
   #define EWLM_QUERY_HYPERVISOR_NONE    0            /* None or unknown 
                                                         hypervisor */
   #define EWLM_QUERY_HYPERVISOR_POWER5  1            /* IBM i/p POWER5/later */
           /* If POWER5 capability is true, the OS supports APIs to query and
              update partition attributes consistent with the POWER5 platform.
              The actual hardware may be at a later level than POWER5, with
              additional capabilities.  */
   #define EWLM_QUERY_HYPERVISOR_PRSM    2            /* IBM z PR/SM */
   #define EWLM_QUERY_HYPERVISOR_VMWARE  4            /* VMware ESX  */


      ewlm_int32_t                os_dynamic_lpar_capability; 
   #define EWLM_QUERY_DLPAR_NONE    (0x000000000) /* partition does not supports 
                                                 dynamic lpar management because
                                                 it is running on non supported
                                                 platform or it is not part of 
                                                 any partition group */  

   #define EWLM_QUERY_DLPAR_CPU_CAPACITY (0x00000001) /* partition supports 
                                                      dynamic lpar management 
                                                      of CPU capacity */
   #define EWLM_QUERY_DLPAR_CPU_WEIGHT   (0x00000002) /* partition supports 
                                                      dynamic lpar management 
                                                      of CPU weight */
   #define EWLM_QUERY_DLPAR_INT_CAPACITY (0x00000004) /* partition supports
                                                      dynamic lpar management 
                                                      of interactive capacity 
                                                      */
   #define EWLM_QUERY_DLPAR_VIRTUAL_CPU  (0x00000008) /* partition supports
                                                      dynamic management of 
                                                      virtual processors */
   #define EWLM_QUERY_DLPAR_MEMORY       (0x00000010) /* partition supports
                                                      dynamic lpar management 
                                                      of memory */

   ewlm_encodedbytestream_t    hypervisor_group_id;/* 
                                Printable hypervisor group ID (IBM zSeries 
                                sysplex name IBM p/iSeries: binary hypervisor 
                                value converted to numeric printable format. 
                                Platform should not provide any leading 0s. For 
                                example, if binary group ID is x'0001', the 
                                printable group ID will be "1".) or null string 
                                if not available. */
   ewlm_encodedbytestream_t    hw_manufacturer;/* 
                                Printable hardware manufacturer name, 
                                or null string if not available. For example,
                                for IBM hardware this field should be set to
                                "IBM" */
   ewlm_encodedbytestream_t    modelno_serialno; /* 
                                Printable hardware model number and serial
                                Number or null string if not available. '-' in 
                                model number or serial number should be
                                included. Model number should include
                                the hardware type e.g. 9406-570. The serial 
                                number (e.g. 10-XYZ10) is appended to
                                model number without any intervening
                                character e.g. "9406-57010-XYZ10" */
                                             
    /* ------- end of data present in version 2 */
    #define EWLM_QUERY_SERVER_CONFIGURATION_OUTVERSION002     (2)
    #define EWLM_QUERY_SERVER_CONFIGURATION_OUTPUT_V002SIZE \
        sizeof(ewlm_query_server_configuration_output_t)
             
    /*
     * In storage, this buffer should be immediately followed by the contents
     * of the data described by the ewlm_encodedbytestream_t components.  
     * All offsets in these components are relative to the beginning of the
     * ewlm_query_server_configuration_output structure.
     */
} ewlm_query_server_configuration_output_t;

/*
 *    Query Server Statistics Input
 */ 
typedef struct ewlm_query_server_statistics_input
{
    ewlm_APIversion_t          version;
    ewlm_int32_t               request_type;
    ewlm_connect_handle_t      connect_handle;
    /* ------- end of data present in version 1        */

    #define EWLM_QUERY_SERVER_STATISTICS_IN_VERSION001     (1)
    #define EWLM_QUERY_SERVER_STATISTICS_INPUT_V001SIZE \
        offsetof(ewlm_query_server_statistics_input_t, flags)
    ewlm_int32_t         flags;
    #define EWLM_QUERY_SERVER_STATISTICS_CLOCK_ACCOUNTING_INACTIVE (0x80000000)
    #define EWLM_QUERY_SERVER_STATISTICS_CLOCK_ACCOUNTING_UPDATE   (0x40000000)
    ewlm_int64_t         master_clock_delta;
    #define EWLM_QUERY_SERVER_STATISTICS_IN_VERSION002     (2)
    #define EWLM_QUERY_SERVER_STATISTICS_INPUT_V002SIZE \
        sizeof(ewlm_query_server_statistics_input_t)
} ewlm_query_server_statistics_input_t;

/*
 *    Query Server Statistics Output
 */ 
typedef struct ewlm_query_server_statistics_output
{
    ewlm_APIversion_t          version;
    ewlm_bytelength_t          sizeneeded;
    /*
     * All of the version 1 data is used for reporting only, and may not be
     * (in some cases, definitely is not) suitable for management uses.
     * PBY decided to go with this for the first release, and we will add data
     * in later release(s) as needed for management.
     */
    ewlm_int32_t                    online_cpus;/* 
                                Number of online logical CPUs the instant this
                                interface is called */
    ewlm_cpu_time_t            cpu_time;/*
                                Total mode microseconds of CPU time consumed by
                                the OS image since a platform-dependent
                                initialization point (e.g. boot)
                                This field should not include idle time */
    ewlm_int64_t               physical_memory_size;/*
                                Kilobytes of real memory configured to the OS at 
                                the instant this interface is called */
    ewlm_uint64_t              paging_space_faults;/*
                                Number of page faults requiring I/O since the 
                                same system initialization point as used for 
                                cpu_time. May wrap. Thus this describes page-ins
                                due to lack of memory, exclusive of file system 
                                activity. */

  /* ------- end of data present in version 1 */
    #define EWLM_QUERY_SERVER_STATISTICS_OUTVERSION001     (1)
    #define EWLM_QUERY_SERVER_STATISTICS_OUTPUT_V001SIZE \
        offsetof(ewlm_query_server_statistics_output_t,\
                 local_wlm_state)


    ewlm_int32_t               local_wlm_state; /* If platform has local work
                                                 load manager, report the
                                                 current state of the local
                                                 wlm */
    #define EWLM_QUERY_LOCAL_WLM_NOT_ACTIVE   (0x00000000) /* Either
                                                 platform does not support
                                                 local WLM or it is not
                                                 running */

    #define EWLM_QUERY_LOCAL_WLM_ACTIVE       (0x40000000) /* Local WLM is
                                                 active */
    #define EWLM_QUERY_LOCAL_WLM_PASSIVE      (0x80000000) /* Local WLM is
                                                 passive, monitoring mode
                                                 only */

     ewlm_int32_t             ewlm_manageable_resources; /* Types of system
                                                 resources that EWLM
                                                 can manage*/
     #define EWLM_QUERY_NO_LOCAL_RESOURCE_MGMT   (0x00000000) /* System does
                                                not support any EWLM resource
                                                management at this point. If
                                                ewlm_query() is invoked
                                                while EWLM local resource
                                                management is disabled,
                                                platform reports that there
                                                are no EWLM manageable
                                                resources */
     #define EWLM_QUERY_LOCAL_CPU_MGMT   (0x40000000) /* System supports
                                                 local CPU management. At
                                                 present only local CPU
                                                 mgmt support is provided */


     ewlm_int32_t             ewlm_cpu_share; /* CPU share assigned to EWLM
                                                 managed work. 0 means
                                                 local resource management
                                                 is not active. -1 indicates
                                                 that shares for EWLM managed
                                                 work is not defined and
                                                 EWLM managed work can
                                                 consume 100% of system
                                                 CPU resources if there is a
                                                 demand for CPU and there is
                                                 no competition from other
                                                 non EWLM managed work. */

      ewlm_int32_t            ewlm_cpu_consumed; /* Percentage of processing
                                                 capacity consumed by OS
                                                 image that is attributed to
                                                 to work running under
                                                 EWLM management. 0 means
                                                 local resource management
                                                 is not active. This number
                                                 is scaled by 100. So, to
                                                 compute percentage,
                                                 this number needs to be
                                                 divided by 100*/
      ewlm_cpu_time_t         scaled_cpu_time;   /* F32148 DCR24
                                                    Total mode microseconds
                                                    of scaled CPU time consumed
                                                    by the OS image since a
                                                    platform-dependent
                                                    initialization point
                                                    (e.g. boot).
                                                    This field should not 
                                                    include idle time */
      /* ------- end of data present in version 2 */
    #define EWLM_QUERY_SERVER_STATISTICS_OUTVERSION002     (2)
    #define EWLM_QUERY_SERVER_STATISTICS_OUTPUT_V002SIZE \
        sizeof(ewlm_query_server_statistics_output_t)
} ewlm_query_server_statistics_output_t;

/* 
 *    Query Resource Metrics Collected Input
 */ 

typedef struct ewlm_query_resource_metrics_collected_input
{
    ewlm_APIversion_t          version;
    ewlm_int32_t                    request_type;
    ewlm_connect_handle_t      connect_handle;

    /* ------- end of data present in version 1 */
    #define EWLM_QUERY_RESOURCE_METRICS_IN_VERSION001     (1)
    #define EWLM_QUERY_RESOURCE_METRICS_COLLECTED_INPUT_V001SIZE \
        sizeof(ewlm_query_resource_metrics_collected_input_t)

} ewlm_query_resource_metrics_collected_input_t;

/* 
 *    Query Resource Metrics Collected Output
 */ 
typedef struct ewlm_query_resource_metrics_collected_output
{
    ewlm_APIversion_t          version;
    ewlm_bytelength_t          sizeneeded;
    ewlm_int8_t                     cpu_time_mode;   /* total or delta mode */
    #define EWLM_QUERY_RESOURCE_METRICS_COLLECTED_TOTAL_MODE  (1)
    #define EWLM_QUERY_RESOURCE_METRICS_COLLECTED_DELTA_MODE  (2)

    ewlm_int8_t                     samples_mode;    /* total or delta mode, 
                                applies to all state samples and 
                                number of samples collected */
    ewlm_int32_t                    samplescollectedflags;/* 
                                Idle and Other are required if any of the other
                                types are collected, hence they are not 
                                explicitly flagged here */
    #define EWLM_QUERY_RESOURCE_METRICS_COLLECTED_CPU_USING         (0x40000000)
    #define EWLM_QUERY_RESOURCE_METRICS_COLLECTED_CPU_DELAY         (0x20000000)
    #define EWLM_QUERY_RESOURCE_METRICS_COLLECTED_PAGE_DELAY        (0x10000000)
    #define EWLM_QUERY_RESOURCE_METRICS_COLLECTED_IO_DELAY          (0x08000000)
            /* Some platforms which collect process delay samples may choose to 
               not return records for processes which are idle (no sampled delay
               or using states observed between two invocations of get_activedata
               omitting CONTINUE requests).  The caller must then adjust the
               idle samples accordingly. */
    #define EWLM_QUERY_RESOURCE_METRICS_COLLECTED_IDLEPROCS_SKIPPED (0x04000000)

    /* ------- end of data present in version 1 */
    #define EWLM_QUERY_RESOURCE_METRICS_OUTVERSION001     (1)
    #define EWLM_QUERY_RESOURCE_METRICS_COLLECTED_OUTPUT_V001SIZE \
        offsetof(ewlm_query_resource_metrics_collected_output_t,\
                 os_sampling_1000sec_conversion_factor)

    ewlm_int32_t              os_sampling_1000sec_conversion_factor;/* 
                                If the platform calculates its samples rather
                                than directly sampling them, then this constant
                                represents the number of samples which the 
                                platform would return for a single threaded
                                process over one thousand seconds of wall clock
                                time.  Platforms which do not calculate
                                their samples should return 0. If version 1 of
                                this area is returned, its value is assumed 
                                to be 0. The value may only used if 
                                COLLECTED_IDLEPROCS_SKIPPED is on. */

    /* ------- end of data present in version 2 */
    #define EWLM_QUERY_RESOURCE_METRICS_OUTVERSION002     (2)
    #define EWLM_QUERY_RESOURCE_METRICS_COLLECTED_OUTPUT_V002SIZE \
        sizeof(ewlm_query_resource_metrics_collected_output_t)
} ewlm_query_resource_metrics_collected_output_t;

/* ------------------------------------------------------------------------- */
/* --------------------------- state services ------------------------------ */
/* ------------------------------------------------------------------------- */

/* 
 *  EWLM Connect Input   
 */ 
typedef struct ewlm_connect_input
{
    ewlm_APIversion_t          version;
    /* ------- end of data present in version 1        */
    #define EWLM_CONNECT_IN_VERSION001     (1)
    /* F15541 fix versioning for platform at higher level than EWLM */
    #define EWLM_CONNECT_INPUT_V001SIZE \
        (offsetof(ewlm_connect_input_t, version) + sizeof(ewlm_APIversion_t))

    ewlm_int32_t           sampling_timer;  /*F12760
                                              Optional input that identifies
                                              the time interval at which
                                              platform needs to collect
                                              samples. This field is millisec 
                                              units. This field is mainly for 
                                              LINUX platform to setup the 
                                              sampling interval. Other 
                                              platforms that run the sampling 
                                              task can also use this input to
                                              configure the sampling interval */
    /* ------- end of data present in version 2 */
    #define EWLM_CONNECT_IN_VERSION002     (2)
    #define EWLM_CONNECT_INPUT_V002SIZE sizeof(ewlm_connect_input_t)
} ewlm_connect_input_t;

/* 
 *  EWLM Connect Output   
 */ 
typedef struct ewlm_connect_output
{
    ewlm_APIversion_t          version;
    ewlm_bytelength_t          sizeneeded;
    ewlm_connect_handle_t      connect_handle;
    /* ------- end of data present in version 1 */
    #define EWLM_CONNECT_OUTVERSION001  (1)
    #define EWLM_CONNECT_OUTPUT_V001SIZE sizeof(ewlm_connect_output_t)
} ewlm_connect_output_t;

/* ewlm_connect() enforces that only one EWLM Workload Manager is active on a 
system.  The EWLM agent calls ewlm_connect() during its initialization to 
establish a connection with the platform component.  If there is no active EWLM 
already connected, ewlm_connect() records a successful connection and returns 
a valid connection handle and a zero status code.  If there is an active EWLM
agent already connected, ewlm_connect() returns an invalid connection handle 
and a negative status code.

There is a complementary function called ewlm_disconnect() that the EWLM agent 
calls before it shuts down.  In order to handle cases where the EWLM agent fails
and might not be able to call ewlm_disconnect(), the platform must either set 
up to be notified of the termination of the EWLM agent process so that it can 
disconnect implicitly, or it must be able to recognize in a subsequent 
ewlm_connect() call that the existing connection information refers to a process
that no longer exists.

Notes:
-  Although the EWLM management server prevents duplicate WLMs on a single 
    system from joining the management domain, this leaves exposed the case 
    where a WLM cannot join due to communication problems.  In that case the 
    EWLM agent proceeds by activating a cached policy or a default policy.  
    The ewlm_connect() function ensures only one WLM can invoke the ewlm_ APIs.

-    When ewlm_connect() returns the error code indicating a WLM is already 
    connected, the calling WLM terminates with an indicative error code.  It is
    assumed that system operations personnel will be able to use existing 
    operating system commands to identify the EWLM agent that is already running
    (e.g. by process name or by userid, if they have assigned a special userid 
    to the EWLM agent).  Therefore there is no requirement to implement a new 
    command to display the status of the EWLM agent connection.
    
-    The connect handle allows for the possibility that someday EWLM might 
    support some structure other than the current 1:1 agent:OS image
    mapping, e.g. by sharing a single handle amongst several processes or
    by allowing multiple valid handles.

*/

/* 
 *  Signature: 
 *              EWLM Connect   
 */ 

ewlm_status_t ewlm_connect(
    /* [in]  */ ewlm_connect_input_t       *input_buffer,
    /* [in]  */ ewlm_bytelength_t          input__buffer_size,
    /* [i/o] */ ewlm_connect_output_t      *output_buffer,
    /* [in]  */ ewlm_bytelength_t          output_buffer_size
);

/* 
    Required Return codes:
       0    EWLM_SUCCESS
    -209    EWLM_LIMITOF1_CONNECTION
    -215    EWLM_OUTBUFFER_BELOW_V1SIZE
    -216    EWLM_OUTBUFFER_TOO_SMALL
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -222    EWLM_SUPPORT_NOT_ENABLED

    Optional Return codes:
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
    -213    EWLM_BAD_OUTBUFFER
 */ 


typedef struct ewlm_disconnect_input
{
    ewlm_APIversion_t          version;
    ewlm_connect_handle_t      connect_handle;
    /* ------- end of data present in version 1        */
    #define EWLM_DISCONNECT_IN_VERSION001     (1)
    #define EWLM_DISCONNECT_INPUT_V001SIZE sizeof(ewlm_disconnect_input_t)
} ewlm_disconnect_input_t;

typedef struct ewlm_disconnect_output
{
    ewlm_APIversion_t          version;
    ewlm_bytelength_t          sizeneeded; 
    /* ------- end of data present in version 1 */
    #define EWLM_DISCONNECT_OUTVERSION001     (1)
    #define EWLM_DISCONNECT_OUTPUT_V001SIZE sizeof(ewlm_disconnect_output_t)
} ewlm_disconnect_output_t;

/*
ewlm_disconnect() ends the connection established by ewlm_connect().  
The EWLM agent calls this function before it shuts down.  Nevertheless the 
platform must handle the case when the EWLM agent fails and does not call 
ewlm_disconnect().  The platform must either be notified of the termination of 
the EWLM agent process so that it can delete the connection information, or it 
must be able to recognize in a subsequent ewlm_connect() call that the existing 
connection information refers to a process that no longer exists.

ewlm_disconnect() performs the following cleanup:
- The ARM implementation's copy of any committed service policy is unaffected.
- The platform's copy of any committed service policy, if any, is either 
  discarded or kept at the sole discretion of the platform.
- Completion records returned via the get_completions interface need not be
  collected any longer, and any OS-owned buffers for them may be freed.
*/
 
/* 
 *  Signature: 
 *              EWLM Disconnect   
 */  

ewlm_status_t ewlm_disconnect(
    /* [in]  */ ewlm_disconnect_input_t    *input_buffer,
    /* [in]  */ ewlm_bytelength_t          input__buffer_size,
    /* [i/o] */ ewlm_disconnect_output_t   *output_buffer,
    /* [in]  */ ewlm_bytelength_t          output_buffer_size
);        

/* 
    Required Return codes:
       0    EWLM_SUCCESS
    -100    EWLM_NO_CONNECTION
    -215    EWLM_OUTBUFFER_BELOW_V1SIZE
    -216    EWLM_OUTBUFFER_TOO_SMALL
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -222    EWLM_SUPPORT_NOT_ENABLED

    Optional Return codes:
    -101    EWLM_BAD_CONNECT_HANDLE
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
    -213    EWLM_BAD_OUTBUFFER
 */ 

/* ------------------------------------------------------------------------- */
/* --------------------------- sampling services --------------------------- */
/* ------------------------------------------------------------------------- */


/* 
ewlm_collect_samples() causes state sampling to occur on the local image (IBM
platforms only...enforcement layer calls implement sampling on other platforms).

The implementation is platform-dependent.  EWLM requires that the sampling 
output data gives the appearance that state sampling was triggered by this
call, regardless of the underlying platform implementation.

In other words, if a single-threaded process existed during an interval where
this interface was called three times, EWLM would expect to see three state
samples on average over the same interval returned as part of process metrics
on ewlm_get_activedata and/or ewlm_get_completions.

Functions currently supported by the command parameter:
Collect_now
    Called on the fine-grained sampling interval to trigger a single sampling
    cycle (all work supported by the sampler is sampled).  Some platforms sample
    both in-flight processes and ARM transactions as a result of this call, 
    others sample only ARM transactions.
    The output buffer is not used by this request.
    
*/ 


typedef struct ewlm_collect_samples_collect_now_input
{
    ewlm_APIversion_t          version;
    ewlm_int32_t                    request_type;
#define EWLM_COLLECT_SAMPLES_REQUEST_COLLECT_NOW  (1)

    ewlm_connect_handle_t      connect_handle;
    /* ------- end of data present in version 1        */
    #define EWLM_COLLECT_SAMPLES_COLLECT_NOW_IN_VERSION001     (1)
    #define EWLM_COLLECT_SAMPLES_COLLECT_NOW_INPUT_V001SIZE \
        sizeof(ewlm_collect_samples_collect_now_input_t)
} ewlm_collect_samples_collect_now_input_t;

typedef struct ewlm_collect_samples_collect_now_output
{
    ewlm_APIversion_t          version;
    ewlm_bytelength_t          sizeneeded;
     /* ------- end of data present in version 1 */
    #define EWLM_COLLECT_SAMPLES_COLLECT_NOW_OUTVERSION001  (1)
    #define EWLM_COLLECT_SAMPLES_COLLECT_NOW_OUTPUT_V001SIZE \
        sizeof(ewlm_collect_samples_collect_now_output_t)
} ewlm_collect_samples_collect_now_output_t;

ewlm_status_t ewlm_collect_samples(
    /* [in]  */ ewlm_char_t                       *input_buffer,
    /* [in]  */ ewlm_bytelength_t          input__buffer_size,
    /* [i/o] */ ewlm_char_t                       *output_buffer,
    /* [in]  */ ewlm_bytelength_t          output_buffer_size
);

/* 
    Required Return codes:
       0    EWLM_SUCCESS
    -100    EWLM_NO_CONNECTION
    -101    EWLM_BAD_CONNECT_HANDLE
    -214    EWLM_UNSUPPORTED_REQUEST_TYPE
    -215    EWLM_OUTBUFFER_BELOW_V1SIZE
    -216    EWLM_OUTBUFFER_TOO_SMALL
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -222    EWLM_SUPPORT_NOT_ENABLED

    Optional Return codes:
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
    -213    EWLM_BAD_OUTBUFFER
*/



/*
ewlm_get_appldata() returns data about a given application instance ID.  
The EWLM agent calls this function the first time it sees a given application 
instance ID returned by ewlm_get_completions() or ewlm_get_activedata().  
Note that the EWLM agent does not harden these definitions so it will ask for 
them again each time it is started.

It is possible that an instrumented application could start, run one or 
more transactions, and then terminate before EWLM gets any of its 
transaction completion records via ewlm_get_completions() or in-flight data
via ewlm_get_activedata().  If the platform simply deletes the definition 
of the application as soon as it terminates, then EWLM will get 
transaction completion records for an application instance ID which it 
would not be able to resolve via ewlm_get_appldata().  
In order to deal with this problem, the platform should not delete the 
definition of the application unless EWLM has retrieved it via 
ewlm_get_appldata() or the application has terminated and the ARM 
implementation has written the corresponding AEID/AIID invalidation 
records to the get_completions record buffer.
*/ 

typedef struct ewlm_get_appldata_input
{
    ewlm_APIversion_t          version;
    ewlm_applinst_id_t         applInstanceId;
    ewlm_connect_handle_t      connect_handle;
    /* ------- end of data present in version 1 */
    #define EWLM_GET_APPLDATA_IN_VERSION001     (1)
    #define EWLM_GET_APPLDATA_INPUT_V001SIZE sizeof(ewlm_get_appldata_input_t)
} ewlm_get_appldata_input_t;

typedef struct ewlm_get_appldata_output
{
    ewlm_APIversion_t          version;
    ewlm_bytelength_t          sizeneeded;
    ewlm_applenv_id_t          application_environment_id;/* ARM implementation-
                                assigned application environment ID, 
                                unique ID for combination of ARM appl name and 
                                group name */                    
    ewlm_process_id_t          process_id;/* 
                                Opaque platform-dependent process identifier. 
                                Must match the value returned to the EWLM agent 
                                on the sampling interfaces (ewlm_get_activedata,
                                ewlm_get_completions) for the same process. */
            
    ewlm_encodedbytestream_t   process_name;/* 
                                Printable version of a platform-dependent process 
                                identifier that would be recognized by humans. 
                                */    
    ewlm_encodedbytestream_t   application_name;/* specified on 
                                arm_register_application API */
    ewlm_encodedbytestream_t   application_group_name;/* specified on 
                                arm_start_application API */
    ewlm_encodedbytestream_t   application_instance_name;/* specified on 
                                arm_start_application API */
    /* ------- end of data present in version 1 */
    #define EWLM_GET_APPLDATA_OUTVERSION001  (1)
    #define EWLM_GET_APPLDATA_OUTPUT_V001SIZE sizeof(ewlm_get_appldata_output_t)
} ewlm_get_appldata_output_t;
/*
 * In storage, this buffer should be immediately followed by the contents of the
 * data described by the ewlm_encodedbytestream_t components.  All offsets in 
 * these components are relative to the beginning of the 
 * ewlm_get_appldata_output structure.
 */

ewlm_status_t ewlm_get_appldata(
    /* [in]  */ ewlm_get_appldata_input_t      *input_buffer,    
    /* [in]  */ ewlm_bytelength_t              input__buffer_size,
    /* [i/o] */ ewlm_get_appldata_output_t     *output_buffer,
    /* [in]  */ ewlm_bytelength_t              output_buffer_size
);

/* 
    Required Return codes:
       0    EWLM_SUCCESS
    -100    EWLM_NO_CONNECTION
    -211    EWLM_INVALID_TOKEN
    -215    EWLM_OUTBUFFER_BELOW_V1SIZE
    -216    EWLM_OUTBUFFER_TOO_SMALL
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -221    EWLM_AIID_NOT_FOUND
    -222    EWLM_SUPPORT_NOT_ENABLED

    Optional Return codes:
    -101    EWLM_BAD_CONNECT_HANDLE
 */ 


/*
ewlm_ARM_message_correlation_output_t is an additional structure to
record message correlation information in the get_activedata and
get_completions records for transactions. Several of these structures
(up to ARM_MESSAGE_RCVD_EVENT_MAX_COUNT - see ARM 4.1 standard) can
be present in one record. The number, offset and length of the
ewlm_ARM_message_correlation_output_t records is stored in the
messages_correlation_count/offset/length fields of the conatining
get_activedata or get_completions transaction records
*/
typedef struct ewlm_ARM_message_correlation_output
{
/* Message originator identity */
    ewlm_applenv_id_t            msgcorr_applenv_id; /* AEID */
    ewlm_applinst_id_t           msgcorr_applinst_id;/* AIID */
    ewlm_local_server_id_t       parent_sys_id;      /* SysId*/
/* Message originator hop count */
    ewlm_hopcount_t              hop_count;
/* Message originator transaction class */
    ewlm_classification_id_t     reporting_id;
/* Correlation flags */
    ewlm_msg_correlation_flags_t flags;
} ewlm_ARM_message_correlation_output_t;


/*
ewlm_get_activedata() collects data about in-flight ARM transactions (all 
platforms) and processes (IBM platforms).  It is called at the end of each 
coarse-grained sampling interval to collect the in-flight data as well as any 
metrics sampled during the just-ended coarse-grained sampling interval. 
Metrics data may be returned
either in delta mode or total mode, as communicated on an earlier ewlm_query
ResourceMetricsCollected.

If the buffer is not sufficiently large to contain all of the data, 
only the portion which will fit is returned and a cursor is returned which 
allows the caller to re-invoke the service to collect more of the data.
An end of data record is returned for each call to signal the last record
which fit in the output buffer; only the return code may be used by the caller
to decide whether or not more data is immediately available.

This interface is serially reusable with respect to restarts 
(only one restart cursor is saved).  If a restart cursor has been saved and 
a new request (not a continue at restart point request) comes in the saved 
restart point is lost.
    
Supported Request Types

PROCESSES_AND_TRANSACTIONS_START
    Synchronously return as much of the process and ARM transaction    data as 
    fits in the buffer provided, starting from the beginning of the set of all
    in-flight work.  The value in the cursor parameter is ignored.
PROCESSES_AND_TRANSACTIONS_CONTINUE
    Synchronously return as much of the process and ARM transaction    data as 
    fits in the buffer provided, starting from point where the prior START
    request ended.  The value in the cursor parameter contains the restart
    point; this value was set by the platform on the previous START/CONTINUE
    call which returned the "more data available" return code.
    If the cursor is invalid, the platform must select one of two possible
    behaviors:
    - If the platform's cursor implementation is such that its value cannot
      become invalid (e.g. due to timing, process or transaction completion)
      then this condition signals a bug on the part of the caller and return
      code EWLM_INVALID_TOKEN should be used.
    - If the platform's cursor implementation is such that its value can
      become invalid (e.g. due to timing, process or transaction completion)
      and the platform has no way to distinguish the cursor becoming stale
      from a bug in the API caller, then the API implementation should restart
      from the beginning (as if _START had been requested).  No indication of
      this is provided to the caller.
*/ 

typedef struct ewlm_get_activedata_input
{
    ewlm_APIversion_t          version;
    ewlm_int32_t                    request_type;
#define EWLM_GET_ACTIVEDATA_REQUEST_PROCESSES_AND_TRANSACTIONS_START     (1)
#define EWLM_GET_ACTIVEDATA_REQUEST_PROCESSES_AND_TRANSACTIONS_CONTINUE  (2)

    ewlm_connect_handle_t      connect_handle;
    ewlm_get_activedata_cursor_t cursor;/* 
                                 Opaque value used to continue an earlier 
                                 request when the buffer is too small to hold 
                                 all of the data.  */
    /* ------- end of data present in version 1 */
    #define EWLM_GET_ACTIVEDATA_IN_VERSION001     (1)
    #define EWLM_GET_ACTIVEDATA_IN_V001SIZE sizeof(ewlm_get_activedata_input_t)
} ewlm_get_activedata_input_t;

ewlm_status_t ewlm_get_activedata(
    /* [in]  */ ewlm_get_activedata_input_t     *input_buffer,
    /* [in]  */ ewlm_bytelength_t               input__buffer_size,
    /* [i/o] */ ewlm_char_t                            *output_buffer,
    /* [in]  */ ewlm_bytelength_t               output_buffer_size
);

/* 
    Required Return codes:
       0    EWLM_SUCCESS
       1    EWLM_MORE_DATA
    -100    EWLM_NO_CONNECTION
    -215    EWLM_OUTBUFFER_BELOW_V1SIZE
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -222    EWLM_SUPPORT_NOT_ENABLED

    Optional Return codes:
    -101    EWLM_BAD_CONNECT_HANDLE
    -213    EWLM_BAD_OUTBUFFER
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
 */ 

typedef struct ewlm_generic_header
{
    ewlm_uint16_t                   type;    /* Record type */
    ewlm_uint16_t                   length;  /* Length of record in bytes */
    ewlm_uint16_t                   version; /* within type, increment with each 
                                            compatible change */
    ewlm_uint16_t                   _reserved1;  /* 8 byte size & alignment */
/* THIS RECORD MAY *NEVER* BE EXPANDED
 * Doing so would cause an incompatible change (new offsets) in all records
 */
} ewlm_generic_header_t;


typedef struct ewlm_get_activedata_inflight_process_output
{
    ewlm_generic_header_t      header;
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PROCESSES_TYPE         (001)
    ewlm_process_id_t          pid;
    ewlm_cpu_time_t            cpu_time; /* metric */
/* Generic in-flight data */
    ewlm_timestamp_t           classify_time;
/* Generic transaction/process data */
    ewlm_duration_t            queue_time;
/* Metrics */
    ewlm_num_samples_t         times_sampled;
    ewlm_state_sample_t        cpu_using;
    ewlm_state_sample_t        cpu_delay;
    ewlm_state_sample_t        page_delay;
    ewlm_state_sample_t        io_delay;
    ewlm_state_sample_t        idle;
    ewlm_state_sample_t        other;
/* Generic in-flight data */
    ewlm_get_activedata_flags_t  flags;
/* Reporting aggregation data - all work types */
    ewlm_classification_id_t   reporting_id;
    ewlm_period_t              period_number;
    /* ------- end of data present in version 1 */
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PROCESSES_VERSION001     (1)
/* microsecond transaction/process data */
    ewlm_micro_duration_t      queue_time_microsec;
    /* ------- end of data present in version 2 */
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PROCESSES_VERSION002     (2)
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PROCESSES_V002SIZE_USED \
     (offsetof(ewlm_get_activedata_inflight_process_output_t, \
     queue_time_microsec) + sizeof(ewlm_micro_duration_t))
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PROCESSES_V002SIZE \
        EWLM_MAX(EWLM_GET_ACTIVEDATA_INFLIGHT_PROCESSES_V001SIZE, \
            EWLM_GET_ACTIVEDATA_INFLIGHT_PROCESSES_V002SIZE_USED)

    ewlm_int64_t    management_id;        /*  Represents the class ID of the
                                              local WLM class created for
                                              EWLM service class and DISP. */
 
    ewlm_cpu_time_t              scaled_cpu_time; /* F32148 DCR24
                                                     Scaled microseconds 
                                                     of CPU time consumed
                                                     by the work being measured. */
    ewlm_get_activedata_flags_t  flagsv3;  /* v3 flags field               */  	
    /* ------- end of data present in version 3 */
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PROCESSES_VERSION003         (3)
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PROCESSES_V003SIZE_USED \
    (offsetof(ewlm_get_activedata_inflight_process_output_t, \
      flagsv3) + sizeof(ewlm_get_activedata_flags_t))
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PROCESSES_V003SIZE \
        EWLM_MAX(EWLM_GET_ACTIVEDATA_INFLIGHT_PROCESSES_V002SIZE, \
            EWLM_GET_ACTIVEDATA_INFLIGHT_PROCESSES_V003SIZE_USED)
} ewlm_get_activedata_inflight_process_output_t;

/*
 * Get Active Data Inflight ARM partially Instrumented Output
 */
typedef struct ewlm_get_activedata_inflight_ARM_partially_instrumented_output
{
/* header.length contains the length of all embedded
   ewlm_ARM_message_correlation_output sections that are potentially
   included in this record, so header.length is basically
   EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_V00xSIZE +
     (message_correlation_length * messages_correlation_count)
   and messages_correlation_offset will be usually (except alignment)
   be equal to EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_V00xSIZE
*/
    ewlm_generic_header_t      header;
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_TYPE         (003)
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_TYPE_ASYNC   (005)
/* ARM transaction identity */
    ewlm_applinst_id_t         appl_inst_id;    /* application instance ID */
/* Parent ARM transaction identity */
    ewlm_applenv_id_t          parent_applenv_id;   /* AEID */
    ewlm_applinst_id_t         parent_applinst_id;  /* AIID */
/* Generic in-flight data */
    ewlm_timestamp_t           classify_time;
/* Generic transaction/process data */
    ewlm_duration_t            queue_time;
/* Generic ARM transaction data */
    ewlm_duration_t            blocked_time;
/* Generic in-flight data */
    ewlm_get_activedata_flags_t  flags;
/* Parent ARM transaction identity */
    ewlm_local_server_id_t     parent_sys_id;       /* System ID */
/* Reporting aggregation data - ARM work only */
    ewlm_hopcount_t                 hop_count;
/* Reporting aggregation data - all work types */
    ewlm_classification_id_t   reporting_id;
    ewlm_period_t              period_number;
    /* ------- end of data present in version 1 */
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_VERSION001     (1)
/* microsecond transaction/process data */
    ewlm_micro_duration_t      queue_time_microsec;
/* microsecond ARM transaction data */
    ewlm_micro_duration_t      blocked_time_microsec;
    /* ------- end of data present in version 2 */
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_VERSION002     (2)
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_V002SIZE_USED \
     (offsetof(ewlm_get_activedata_inflight_ARM_partially_instrumented_output_t, \
      blocked_time_microsec) + sizeof(ewlm_micro_duration_t))
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_V002SIZE \
	    (EWLM_MAX(EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_V001SIZE, \
		EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_V002SIZE_USED))

/* Arrival delay time.  This is the number of microseconds that have elapsed
    from the E2E transaction's edge arrival time until the captured arrival
    time at this reported hop.  This field is valid only if the
    EWLM_GET_ACTIVEDATA_ARRIVAL_DELAY flag is true. */
    ewlm_arrival_delay_duration_t   arrival_delay_time;
/* Number of messages sent */
    ewlm_tranevent_count_t      messages_sent_count;
/* Messages received count */
    ewlm_tranevent_count_t      messages_received_count;
/* Blocked instances due to awaiting message or message response */
    ewlm_tranevent_count_t      blocked_msgwait_count;
/* Total blocked instances count */
    ewlm_tranevent_count_t      total_blocked_instance_count;
/* Messages received correlation count */
    ewlm_tranevent_count_t      messages_correlation_count;
/* Offset to post-start messages received correlation information.
   This offset is defined to be the number of bytes from the beginning
   of this active transaction record.
   Received message correlation information for an active transaction
   instance is provided in the record buffer included in its associated
   active transaction record.
   This field is ignored if messages_correlation_count is zero*/
    ewlm_int16_t      messages_correlation_offset;
/* Length of one message received correlation information. This length
   is defined to be the number of bytes consumed by one received
   message.  This field is ignored by data collection if
   messages_correlation_count is zero. */
    ewlm_int16_t      messages_correlation_length;
    ewlm_get_activedata_flags_t  flagsv3;  /* v3 flags field     */
/* ------- end of data present in version 3 */
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_VERSION003 (3)
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_V003SIZE_USED \
      (offsetof(ewlm_get_activedata_inflight_ARM_partially_instrumented_output_t, \
      flagsv3) + sizeof(ewlm_get_activedata_flags_t))
    #define EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_V003SIZE \
      MAXVERSIONSIZE(EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_V002SIZE, \
      EWLM_GET_ACTIVEDATA_INFLIGHT_PARTIALINSTARM_V003SIZE_USED)

} ewlm_get_activedata_inflight_ARM_partially_instrumented_output_t;

/*
 * Get Active Data End of Data Output
 */

typedef struct ewlm_get_activedata_endofdata_output
{
    ewlm_generic_header_t        header;
    #define EWLM_GET_ACTIVEDATA_ENDOFDATA_TYPE                        (99)
    ewlm_get_activedata_cursor_t cursor;    /* Opaque value used to continue 
                                            an earlier request when the buffer 
                                            is too small to hold all of the 
                                            data.  */ 
    
    /* ------- end of data present in version 1 */
    #define EWLM_GET_ACTIVEDATA_ENDOFDATA_VERSION001                   (1)
    #define EWLM_GET_ACTIVEDATA_ENDOFDATA_V001SIZE \
        offsetof(ewlm_get_activedata_endofdata_output_t,flags)

    ewlm_int32_t                    flags;
            /* A time change occurred which the underlying implementation
             * believes might impact reported elapsed time values or data
             * based on elapsed times.  Platforms which can detect this
             * communicate it to the caller for diagnostic purposes, i.e. to
             * allow the caller to propagate the suspicious nature of the 
             * data along with a likely cause.  No specificity is provided as
             * to which values might be suspect at run time, because in 
             * aggregate they are unpredictable.  In cases where elapsed times
             * are returned to the caller, the platform may choose any 
             * combination of using defined overflow bits to flag specific
             * fields, returning a maximum value as the elapsed time, and
             * returning zero as the elapsed time.
             * Detection of this condition is optional, and not all possible 
             * cases are necessarily detected on any given platform for 
             * performance reasons.
             * If version 1 of this struct is returned, 
             * this bit is assumed to be off. */
    #define EWLM_GET_ACTIVEDATA_ELAPSED_TIMES_SUSPECT             (0x40000000)

    /* ------- end of data present in version 2 */
    #define EWLM_GET_ACTIVEDATA_ENDOFDATA_VERSION002                   (2)
    #define EWLM_GET_ACTIVEDATA_ENDOFDATA_V002SIZE \
        sizeof(ewlm_get_activedata_endofdata_output_t)
} ewlm_get_activedata_endofdata_output_t;

/*
ewlm_get_completions() extracts statistics for ARM transactions and processes 
that have completed since the last time it was called.

If the output buffer is not sufficiently large to contain all of the data, 
only the portion which will fit is returned and a return code signals
the caller to re-invoke the service to collect more of the data.
An end of data record is returned for each call to signal the last record
which fit in the output buffer; only the return code may be used by the caller
to decide whether or not more data is immediately available.

Supported Commands

SYNCHRONOUS
    Synchronously return as much of the data as fits in the buffer provided.
WAIT
    Return to the caller when the first of the following conditions is true:
    1.    the caller-specified timeout expires (see timeout parameter)
    2.    enough transactions have completed to fill the caller's buffer
    3.    the platform’s completion buffer has reached an internal threshold 
        (e.g. 50% full)
    4.    the wait is cancelled by using the CANCEL_WAIT command
    Only a single caller can be waiting at any given time.  If a caller is
    waiting and a second WAIT call arrives, the second call is rejected with
    return code EWLM_GETCOMPLETIONS_SECOND_WAITER.
CANCEL_WAIT
    If any callers are suspended in a WAIT request, they should be immediately
    resumed.  The platform returns all completion records accumulated so far
    to the canceller (not the waiter).  The waiter, if any exists, receives 
    a normal completion code and an end_of_buffer record.  Since only the 
    called API can guarantee sufficient serialization, it is not an error to
    attempt to cancel a wait when no waiters exist.
    For example the EWLM agent will use this form of the invocation in the 
    policy management component to finish its bookkeeping before switching 
    to a new active service policy.
    
Lost record counts: 
the EWLM agent depends upon seeing all completion records
in order to keep the bookkeeping data correct.  In particular, if AEID/AIID
invalidation records are lost the agent might have to restart bookkeeping in
order to solve all the potential problems.  Total_lost-(ARM_lost+process_lost)
tells the agent whether or not any such records might have been lost; the 
overall total gives the agent a quick way to check that all the data is fine.
*/ 

/*
 * Completed transactions and processes Input
 */


typedef struct ewlm_get_completions_input
{
    ewlm_APIversion_t          version;
    ewlm_int32_t                    timeout;/* 
                               Maximum amount of time the caller is willing to 
                               be suspended,in millisecond units. The value 
                               specified must be between 1 (1 ms) and 600,000 
                               (10 minutes) inclusive */
    ewlm_int32_t                    request_type;
    #define EWLM_GET_COMPLETIONS_REQUEST_SYNCHRONOUS        (1)
    #define EWLM_GET_COMPLETIONS_REQUEST_WAIT               (2)
    #define EWLM_GET_COMPLETIONS_REQUEST_CANCEL_WAIT        (3)
    
    ewlm_connect_handle_t      connect_handle;
    /* ------- end of data present in version 1 */
    #define EWLM_GET_COMPLETIONS_IN_VERSION001              (1)
    #define EWLM_GET_COMPLETIONS_IN_V001SIZE \
        sizeof(ewlm_get_completions_input_t)
} ewlm_get_completions_input_t;

ewlm_status_t ewlm_get_completions(
    /* [in]  */ ewlm_get_completions_input_t *input_buffer,
    /* [in]  */ ewlm_bytelength_t            input__buffer_size,
    /* [i/o] */ ewlm_char_t                         *output_buffer, 
    /* [in]  */ ewlm_bytelength_t            output_buffer_size
);

/* 
    Required Return codes:
       0    EWLM_SUCCESS
       1    EWLM_MORE_DATA
    -100    EWLM_NO_CONNECTION
    -202    EWLM_BAD_TIMEOUT
    -204    EWLM_GETCOMPLETIONS_SECOND_WAITER
    -214    EWLM_UNSUPPORTED_REQUEST_TYPE
    -215    EWLM_OUTBUFFER_BELOW_V1SIZE
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -222    EWLM_SUPPORT_NOT_ENABLED

    Optional Return codes:
    -101    EWLM_BAD_CONNECT_HANDLE
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
    -213    EWLM_BAD_OUTBUFFER
*/ 


typedef struct ewlm_get_completions_process_output
{
/* header.length contains the length of all embedded
   ewlm_ARM_message_correlation_output sections that are potentially
   included in this record, so header.length is basically
   EWLM_GET_COMPLETIONS_PARTIALINSTARM_V00xSIZE +
     (message_correlation_length * messages_correlation_count)
   and messages_correlation_offset will be usually (except alignment)
   be equal to EWLM_GET_COMPLETIONS_PARTIALINSTARM_V00xSIZE
*/
    ewlm_generic_header_t      header;
    #define EWLM_GET_COMPLETIONS_PROCESSES_TYPE                  (101)
    ewlm_process_id_t          pid;
    ewlm_cpu_time_t            cpu_time; /* Metric */
/* Generic transaction/process data */
    ewlm_duration_t            queue_time;
/* Generic completion transaction/process data */
    ewlm_duration_t            response_time;
/* Metrics */
    ewlm_num_samples_t         times_sampled;
    ewlm_state_sample_t        cpu_using;
    ewlm_state_sample_t        cpu_delay;
    ewlm_state_sample_t        page_delay;
    ewlm_state_sample_t        io_delay;
    ewlm_state_sample_t        idle;
    ewlm_state_sample_t        other;
/* Generic transaction completion data */
    ewlm_get_completions_flags_t flags;
/* Reporting aggregation data - all work types */
    ewlm_classification_id_t   reporting_id;
    ewlm_period_t              period_number;

    /* ------- end of data present in version 1 */
    #define EWLM_GET_COMPLETIONS_PROCESSES_VERSION001              (1)
/* microsecond transaction/process data */
    ewlm_micro_duration_t       queue_time_microsec;
/* microsecond completion transaction/process data */
    ewlm_micro_duration_t       response_time_microsec;

    /* ------- end of data present in version 2 */
    #define EWLM_GET_COMPLETIONS_PROCESSES_VERSION002              (2)
    #define EWLM_GET_COMPLETIONS_PROCESSES_V002SIZE_USED \
    (offsetof(ewlm_get_completions_process_completion_output_t, \
     response_time_microsec) + sizeof(ewlm_micro_duration_t))
    #define EWLM_GET_COMPLETIONS_PROCESSES_V002SIZE \
	EWLM_MAX(EWLM_GET_COMPLETIONS_PROCESSES_V001SIZE, \
             EWLM_GET_COMPLETIONS_PROCESSES_V002SIZE_USED)

    ewlm_int64_t    management_id;        /*  Represents the class ID of the
                                              local WLM class created for
                                              EWLM */
                                                  
    ewlm_cpu_time_t               scaled_cpu_time ;/* F32148 DCR24
                                                     Scaled microseconds 
                                                     of CPU time consumed
                                                     by the work being measured. */ 
    ewlm_get_completions_flags_t  flagsv3;  /* v3 flags field        */
    /* ------- end of data present in version 3 */
    #define EWLM_GET_COMPLETIONS_PROCESSES_VERSION003              (3)
    #define EWLM_GET_COMPLETIONS_PROCESSES_V003SIZE_USED \
    (offsetof(ewlm_get_completions_process_completion_output_t, \
      flagsv3) + sizeof(ewlm_get_completions_flags_t))
    #define EWLM_GET_COMPLETIONS_PROCESSES_V003SIZE \
        EWLM_MAX(EWLM_GET_COMPLETIONS_PROCESSES_V002SIZE, \
	    EWLM_GET_COMPLETIONS_PROCESSES_V003SIZE_USED)
} ewlm_get_completions_process_completion_output_t;

typedef struct ewlm_get_completions_ARM_partially_instrumented_output
{
    ewlm_generic_header_t      header;
    #define EWLM_GET_COMPLETIONS_PARTIALINSTARM_TYPE                (103)
    #define EWLM_GET_COMPLETIONS_PARTIALINSTARM_TYPE_ASYNC          (105)
/* ARM transaction identity */
    ewlm_applinst_id_t         appl_inst_id;    /* application instance ID */
/* Parent ARM transaction identity */
    ewlm_applenv_id_t          parent_applenv_id;   /* AEID */
    ewlm_applinst_id_t         parent_applinst_id;  /* AIID */
/* Generic transaction/process data */
    ewlm_duration_t            queue_time;
/* Generic ARM transaction data */
    ewlm_duration_t            blocked_time;
/* Generic completion data */
    ewlm_duration_t            response_time;
/* Generic ARM transaction completion data */
    ewlm_ARM_completion_status_t completion_status;
/* Generic transaction completion data */
    ewlm_get_completions_flags_t flags;
/* Parent ARM transaction identity */
    ewlm_local_server_id_t     parent_sys_id;       /* System ID */
/* Reporting aggregation data - ARM work only */
    ewlm_hopcount_t                 hop_count;
/* Reporting aggregation data - all work types */
    ewlm_classification_id_t   reporting_id;
    ewlm_period_t              period_number;
    /* ------- end of data present in version 1 */
    #define EWLM_GET_COMPLETIONS_PARTIALINSTARM_VERSION001            (1)
/* microsecond transaction/process data */
    ewlm_micro_duration_t      queue_time_microsec;
/* microsecond ARM transaction data */
    ewlm_micro_duration_t      blocked_time_microsec;
/*microsecond completion data */
    ewlm_micro_duration_t      response_time_microsec;
    /* ------- end of data present in version 2 */
    #define EWLM_GET_COMPLETIONS_PARTIALINSTARM_VERSION002            (2)
    #define EWLM_GET_COMPLETIONS_PARTIALINSTARM_V002SIZE_USED \
    (offsetof(ewlm_get_completions_ARM_partially_instrumented_output_t, \
     response_time_microsec) + sizeof(ewlm_micro_duration_t))
    #define EWLM_GET_COMPLETIONS_PARTIALINSTARM_V002SIZE \
	    (EWLM_MAX(EWLM_GET_COMPLETIONS_PARTIALINSTARM_V001SIZE, \
		EWLM_GET_COMPLETIONS_PARTIALINSTARM_V002SIZE_USED))

/* Arrival delay time.  This is the number of microseconds that have elapsed
    from the E2E transaction's edge arrival time until the captured arrival
    time at this reported hop.  This field is valid only if the
    EWLM_GET_COMPLETIONS_ARRIVAL_DELAY flag is true. */
    ewlm_arrival_delay_duration_t   arrival_delay_time;
/* Number of messages sent */
    ewlm_tranevent_count_t      messages_sent_count;
/* Messages received count */
    ewlm_tranevent_count_t      messages_received_count;
/* Blocked instances due to awaiting message or message response */
    ewlm_tranevent_count_t      blocked_msgwait_count;
/* Total blocked instances count */
    ewlm_tranevent_count_t      total_blocked_instance_count;
/* Post-start messages received correlation count */
    ewlm_tranevent_count_t      messages_correlation_count;
/* Offset to post-start messages received correlation information.
   This offset is defined to be the number of bytes from the beginning
   of this transaction completion record.
   Received message correlation information for an completed transaction
   instance is provided in the record buffer included in its associated
   transaction completion record.
   This field is ignored if messages_correlation_count is zero*/
    ewlm_int16_t      messages_correlation_offset;
/* Length of one message received correlation information. This length
   is defined to be the number of bytes consumed by one received
   message.  This field is ignored by data collection if
   messages_correlation_count is zero. */
    ewlm_int16_t      messages_correlation_length;
    ewlm_get_completions_flags_t  flagsv3;  /* v3 flags field         */
/* ------- end of data present in version 3 */
    #define EWLM_GET_COMPLETIONS_PARTIALINSTARM_VERSION003  (3)
    #define EWLM_GET_COMPLETIONS_PARTIALINSTARM_V003SIZE_USED \
      (offsetof(ewlm_get_completions_ARM_partially_instrumented_output_t, \
      flagsv3) + sizeof(ewlm_get_completions_flags_t))
    #define EWLM_GET_COMPLETIONS_PARTIALINSTARM_V003SIZE \
      MAXVERSIONSIZE(EWLM_GET_COMPLETIONS_PARTIALINSTARM_V002SIZE, \
      EWLM_GET_COMPLETIONS_PARTIALINSTARM_V003SIZE_USED)

} ewlm_get_completions_ARM_partially_instrumented_output_t;

typedef struct ewlm_get_completions_appl_instance_id_termination_output
{
    ewlm_generic_header_t      hdr;
    #define EWLM_GET_COMPLETIONS_AIID_INVALID_TYPE                  (201)
    ewlm_applinst_id_t         appl_inst_id;
    /* ------- end of data present in version 1 */
    #define EWLM_GET_COMPLETIONS_AIID_VERSION001                      (1)
    #define EWLM_GET_COMPLETIONS_AIID_V001SIZE \
        offsetof(ewlm_get_completions_appl_instance_id_termination_output_t,\
flags)

    ewlm_int32_t                   flags; 
    #define EWLM_GET_COMPLETIONS_AIID_INVALID_APPLDATA        (0x40000000) /*
                                          Version 2 data is present.  If this\
                                          flag is on, the version 2 data \
                                          from AEID forward contains no\
                                          predictable content and should \
                                          not be used by the EWLM agent */
    ewlm_applenv_id_t          application_environment_id;/* ARM
                                implementation assigned AEID */                    
    ewlm_process_id_t          process_id;/* Opaque platform dependent
                                process identifier */            
    ewlm_encodedbytestream_t   process_name;/* Printable version of a
                                platform dependent process identifier
                                that would be recognized by humans */
    ewlm_encodedbytestream_t   application_name;/* specified on 
                                arm_register_application API */
    ewlm_encodedbytestream_t   application_group_name;/* specified on 
                                arm_start_application API */
    ewlm_encodedbytestream_t   application_instance_name;/* specified on 
                                arm_start_application API */
    /* ------- end of data present in version 2 */
    #define EWLM_GET_COMPLETIONS_AIID_VERSION002                      (2)
    #define EWLM_GET_COMPLETIONS_AIID_V002SIZE \
        sizeof(ewlm_get_completions_appl_instance_id_termination_output_t)
    } ewlm_get_completions_appl_instance_id_termination_output_t;

typedef struct ewlm_get_completions_appl_environment_id_termination_output
{
    ewlm_generic_header_t      hdr;
    #define EWLM_GET_COMPLETIONS_AEID_INVALID_TYPE                 (301)
    ewlm_applenv_id_t          appl_env_id;
    
    /* ------- end of data present in version 1 */
    #define EWLM_GET_COMPLETIONS_AEID_VERSION001                      (1)
    #define EWLM_GET_COMPLETIONS_AEID_V001SIZE \
        sizeof(ewlm_get_completions_appl_environment_id_termination_output_t)
} ewlm_get_completions_appl_environment_id_termination_output_t;

typedef struct ewlm_get_completions_endofdata_output
{
    ewlm_generic_header_t      header;
    #define EWLM_GET_COMPLETIONS_ENDOFDATA_TYPE                     (999)

    ewlm_int32_t                    lost_tran_count; /*
                                Total mode count of the number of transaction 
                                completion records lost for any reason, 
                                including wrap of the OS buffer */
    ewlm_int32_t                    lost_process_count; /* 
                                Total mode count of the number of process 
                                completion records lost for any reason, 
                                including wrap of the OS buffer */
    ewlm_int32_t                    lost_total_count;/* 
                                Total mode count of the total number of 
                                completion records (all types) lost for any
                                reason, including wrap of the OS buffer. This 
                                total INCLUDES the values in the two counts 
                                above.  total-(process+trxn) = count of other
                                record types, like AIID/AEID termination,
                                which have been lost.  */
    /* ------- end of data present in version 1 */
    #define EWLM_GET_COMPLETIONS_ENDOFDATA_VERSION001                 (1)
    #define EWLM_GET_COMPLETIONS_ENDOFDATA_V001SIZE \
        sizeof(ewlm_get_completions_endofdata_output_t)
}    ewlm_get_completions_endofdata_output_t;

/* ------------------------------------------------------------------------- */
/* ------------------------- policy management services -------------------- */
/* ------------------------------------------------------------------------- */

/*
 *    Normal flow: policy activation
 *        -    prepare
 *        -    commit or abort
 *    Verify policy flow
 *        -    verify
 */

/*
ewlm_prepare_policy() 
-    Signals the start of a policy activation sequence.  
-    is passed a contiguous, self-describing policy data structure.  
-    allows the platform to validate the policy structure is usable.  
    It also allows the platform to build its own platform-specific 
    policy-related data structures (though at present no such structures are 
    required).  
-    does NOT make the new policy structures active.
    The platform should continue to classify work according to the 
    currently active policy if there is one.  The EWLM agent calls another 
    function, ewlm_commit_policy(), when it is ready for the prepared policy 
    to replace the active policy.  If ewlm_prepare_policy() is successful 
    but an error occurs later in the policy activation sequence, the EWLM 
    agent calls ewlm_abort_policy() to discard the prepared policy.

If for some reason the platform already has a prepared policy in storage when 
the EWLM agent calls ewlm_prepare_policy(), the platform should simply discard
the previous prepared policy.  This can happen if:
-    ewlm_commit_policy() fails on the policy cross-check 
    (see the description of ewlm_commit_policy()).  
-    if the EWLM agent fails after preparing a policy, is 
    subsequently restarted, and the platform’s disconnect/reconnect logic does 
    not purge the prepared policy as normally expected.

*/

typedef struct ewlm_prepare_policy_input
{
    ewlm_APIversion_t          version;
    ewlm_policytype_t          policy_type;
    #define EWLM_PREPARE_POLICY_SERVICE           (1)
    
    ewlm_unencodedbytestream_t policy;/* Policy to be operated upon */
    ewlm_connect_handle_t       connect_handle;
    
    /* ------- end of data present in version 1 */
    #define EWLM_PREPARE_POLICY_IN_VERSION001        (1)
    #define EWLM_PREPARE_POLICY_INPUT_V001SIZE \
        sizeof(ewlm_prepare_policy_input_t)
} ewlm_prepare_policy_input_t;

typedef struct ewlm_prepare_policy_output
{
    ewlm_APIversion_t          version;
    ewlm_bytelength_t          sizeneeded;
    /* ------- end of data present in version 1 */
    #define EWLM_PREPARE_POLICY_OUTVERSION001        (1)
    #define EWLM_PREPARE_POLICY_OUTPUT_V001SIZE \
        sizeof(ewlm_prepare_policy_output_t)
} ewlm_prepare_policy_output_t;

ewlm_status_t ewlm_prepare_policy(
    /* [in]  */ ewlm_char_t                        *input_buffer,
    /* [in]  */ ewlm_bytelength_t                  input__buffer_size,
    /* [i/o] */ ewlm_char_t                        *output_buffer, 
    /* [in]  */ ewlm_bytelength_t                  output_buffer_size
);

/* 
    Required Return codes:
       0    EWLM_SUCCESS
    -100    EWLM_NO_CONNECTION
    -117    EWLM_BAD_POLICY_TYPE
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -222    EWLM_SUPPORT_NOT_ENABLED
    various EWLM_BAD_POLICY_xxxxx

    Optional Return codes:
    -101    EWLM_BAD_CONNECT_HANDLE
*/ 



/* --------------------------------------------------------------------------
ewlm_commit_policy() 
-    causes the platform to make the prepared policy previously passed by 
    ewlm_prepare_policy() be the active service policy.  The platform 
    classifies new work according to this new policy.  Existing active ARM 
    transactions remain classified according to the former policy and are 
    not reclassified; platform processes are reclassified atomically using 
    the new service policy.
-    deletes the platform’s copy of the former service policy.  The platform is 
    responsible for serializing the deletion with all the services which may 
    be trying to classify work using those policy data structures.

The policy structure is passed to ewlm_commit_policy() to allow verification
that it is the same policy previously passed to ewlm_prepare_policy().  This
is most easily implemented as a bitwise comparison.
If it is not the same policy, ewlm_commit_policy() does not make the prepared 
policy active and it returns a negative status code.  The prepared policy 
structures remain in storage.  The caller can abort the policy activation 
sequence by calling ewlm_abort_policy(), or start the policy activation 
sequence over by calling ewlm_prepare_policy() again.
*/

typedef struct ewlm_commit_policy_input
{
      
    ewlm_APIversion_t          version; 
    ewlm_policytype_t          policy_type;
    #define EWLM_COMMIT__POLICY_SERVICE           (EWLM_PREPARE_POLICY_SERVICE)

    ewlm_unencodedbytestream_t policy;/* Policy to be operated upon */
    ewlm_connect_handle_t      connect_handle;
    /* ------- end of data present in version 1 */
    #define EWLM_COMMIT_POLICY_IN_VERSION001             (1)
    #define EWLM_COMMIT_POLICY_INPUT_V001SIZE sizeof(ewlm_commit_policy_input_t)
} ewlm_commit_policy_input_t;

typedef struct ewlm_commit_policy_output
{
    ewlm_APIversion_t        version;
    ewlm_bytelength_t        sizeneeded;
    /* ------- end of data present in version 1 */
    #define EWLM_COMMIT_POLICY_OUTVERSION001        (1)
    #define EWLM_COMMIT_POLICY_OUTPUT_V001SIZE \
        sizeof(ewlm_commit_policy_output_t)
} ewlm_commit_policy_output_t;

ewlm_status_t ewlm_commit_policy(
    /* [in]  */ ewlm_char_t                         *input_buffer,
    /* [in]  */ ewlm_bytelength_t            input__buffer_size,         
    /* [i/o] */ ewlm_char_t                         *output_buffer, 
    /* [in]  */ ewlm_bytelength_t            output_buffer_size
);

/* 
    Required Return codes:
       0    EWLM_SUCCESS
    -100    EWLM_NO_CONNECTION
    -101    EWLM_BAD_CONNECT_HANDLE
    -102    EWLM_BAD_POLICY
    -103    EWLM_NO_PREPARED_POLICY
    -104    EWLM_WRONG_POLICY
    -117    EWLM_BAD_POLICY_TYPE
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -222    EWLM_SUPPORT_NOT_ENABLED

    Optional Return codes:
    various EWLM_BAD_POLICY_xxxxx
*/ 

/* 
 * Abort Policy Inputs  
 */

typedef struct ewlm_abort_policy_input
{
    ewlm_APIversion_t          version;
    ewlm_policytype_t          policy_type;
    #define EWLM_ABORT___POLICY_SERVICE           (EWLM_PREPARE_POLICY_SERVICE)

    ewlm_unencodedbytestream_t policy;
    ewlm_connect_handle_t      connect_handle;
        /* ------- end of data present in version 1 */
    #define EWLM_ABORT_POLICY_IN_VERSION001             (1)
    #define EWLM_ABORT_POLICY_INPUT_V001SIZE sizeof(ewlm_abort_policy_input_t)
} ewlm_abort_policy_input_t;

typedef struct ewlm_abort_policy_output
{
    ewlm_APIversion_t          version; 
    ewlm_bytelength_t          sizeneeded;
    /* ------- end of data present in version 1 */
    #define EWLM_ABORT_POLICY_OUTVERSION001       (1)
    #define EWLM_ABORT_POLICY_OUTPUT_V001SIZE sizeof(ewlm_abort_policy_output_t)
} ewlm_abort_policy_output_t;

/* --------------------------------------------------------------------------
ewlm_abort_policy() causes the platform to delete its copy of the prepared 
service policy.  The EWLM agent calls this function if it encounters some 
error during the policy activation sequence after having called 
ewlm_prepare_policy().
*/
ewlm_status_t ewlm_abort_policy(
    /* [in]  */ ewlm_char_t                         *input_buffer,
    /* [in]  */ ewlm_bytelength_t            input__buffer_size, 
    /* [i/o] */ ewlm_char_t                         *output_buffer, 
    /* [in]  */ ewlm_bytelength_t            output_buffer_size
);

/* 
    Required Return codes:
       0    EWLM_SUCCESS
    -100    EWLM_NO_CONNECTION
    -117    EWLM_BAD_POLICY_TYPE
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -222    EWLM_SUPPORT_NOT_ENABLED

    Optional Return codes:
    -101    EWLM_BAD_CONNECT_HANDLE
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
 */ 



/* --------------------------------------------------------------------------
ewlm_verify_policy() is identical to ewlm_prepare_policy() with two exceptions:
-    If there is an existing prepared service policy, ewlm_verify_policy() does 
    not delete it.
-    ewlm_verify_policy() does not retain the service policy in storage for a 
    subsequent commit or abort call.
    
The EWLM agent calls ewlm_verify_policy() to simulate as much of a policy 
activation sequence as possible, to verify that an actual policy activation is 
likely to be successful.  The EWLM agent can call ewlm_verify_policy() in 
parallel to an actual end to end policy activation sequence, which is why the 
EWLM agent cannot accomplish this function by reusing the ewlm_prepare_policy()
and ewlm_abort_policy() calls.  ewlm_verify_policy() must not affect the 
operation of ewlm_prepare_policy(), ewlm_commit_policy(), or 
ewlm_abort_policy().
*/

typedef struct ewlm_verify_policy_input
{
    ewlm_APIversion_t          version;
    ewlm_policytype_t          policy_type;
    #define EWLM_VERIFY__POLICY_SERVICE           (EWLM_PREPARE_POLICY_SERVICE)

    ewlm_unencodedbytestream_t policy;/* Policy to be operated upon */
    ewlm_connect_handle_t      connect_handle;
    /* ------- end of data present in version 1 */
    #define EWLM_VERIFY_POLICY_IN_VERSION001             (1)
    #define EWLM_VERIFY_POLICY_INPUT_V001SIZE sizeof(ewlm_verify_policy_input_t)
} ewlm_verify_policy_input_t;

typedef struct ewlm_verify_policy_output
{
    ewlm_APIversion_t          version;
    ewlm_bytelength_t          sizeneeded;
    /* ------- end of data present in version 1 */
    #define EWLM_VERIFY_POLICY_OUTVERSION001        (1)
    #define EWLM_VERIFY_POLICY_OUTPUT_V001SIZE \
        sizeof(ewlm_verify_policy_output_t)
} ewlm_verify_policy_output_t;

ewlm_status_t ewlm_verify_policy(
    /* [in]  */ ewlm_char_t                         *input_buffer,
    /* [in]  */ ewlm_bytelength_t            input__buffer_size,
    /* [i/o] */ ewlm_char_t                         *output_buffer, 
    /* [in]  */ ewlm_bytelength_t            output_buffer_size
);

/* 
    Required Return codes:
       0    EWLM_SUCCESS
    -100    EWLM_NO_CONNECTION
    -101    EWLM_BAD_CONNECT_HANDLE
    -117    EWLM_BAD_POLICY_TYPE
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    various EWLM_BAD_POLICY_xxxxx
    -222    EWLM_SUPPORT_NOT_ENABLED

    Optional Return codes:
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
 */ 

/* This is an additional value for transaction status.
 * The other possible transaction status values can
 * be found in arm4.h. They are prefixed with: 
 * ARM_STATUS. Found in this file because it's not 
 * part of the std.
 */
#define EWLM_ARM_STATUS_ABANDONED (-1)

/* ------------------------------------------------------------------------- */
/* ------------------------- local cpu management       -------------------- */
/* ------------------------------------------------------------------------- */

typedef struct ewlm_create_mgmtclass_output
{
    ewlm_APIversion_t          version;
    ewlm_bytelength_t          sizeneeded;
    ewlm_int64_t               management_id;
    /* ------- end of data present in version 1 */
    #define EWLM_CREATE_MGMTCLASS_OUTVERSION001  (1)
    #define EWLM_CREATE_MGMTCLASS_OUTPUT_V001SIZE  \
             sizeof(ewlm_create_mgmtclass_output_t)
} ewlm_create_mgmtclass_output_t;

typedef struct ewlm_create_mgmtclass_input
{
    ewlm_APIversion_t           version;
    ewlm_connect_handle_t       connect_handle;
    ewlm_encodedbytestream_t    service_class_name;
    ewlm_classification_id_t    service_class_id;
    ewlm_int32_t                tier;   /* Tier value for management class. 0
                                           when tier management is not
                                           available or does not fit with EWLM
                                           requirement. Not currently
                                           supported, should be set to 0. */
    ewlm_int32_t                cpu_shares;     /* CPU shares - ranges from
                                                   1 - 65535 */
    /* ------- end of data present in version 1 */
    #define EWLM_CREATE_MGMTCLASS_INVERSION001  (1)
    #define EWLM_CREATE_MGMTCLASS_INPUT_V001SIZE  \
             sizeof(ewlm_create_mgmtclass_input_t)
} ewlm_create_mgmtclass_input_t;

/*
     Required Return codes:

       0    EWLM_SUCCESS
    -100    EWLM_NO_CONNECTION
    -215    EWLM_OUTBUFFER_BELOW_V1SIZE
    -216    EWLM_OUTBUFFER_TOO_SMALL
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -222    EWLM_SUPPORT_NOT_ENABLED
    -224    EWLM_LOCAL_WLM_NOT_ACTIVE
    -225    EWLM_LOCAL_WLM_PASSIVE
    -226    EWLM_MAX_MGMTCLASSES

    Optional Return codes:
    -101    EWLM_BAD_CONNECT_HANDLE
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
    -213    EWLM_BAD_OUTBUFFER
*/
ewlm_status_t ewlm_create_mgmtclass(
    /* [in]  */ ewlm_create_mgmtclass_input_t   *input_buffer,
    /* [in]  */ ewlm_bytelength_t               input_buffer_size,
    /* [i/o] */ ewlm_create_mgmtclass_output_t  *output_buffer,
    /* [in]  */ ewlm_bytelength_t               output_buffer_size);


typedef struct ewlm_change_mgmtclass_attribute_output
{
    ewlm_APIversion_t          version;
    ewlm_bytelength_t          sizeneeded;
    /* ------- end of data present in version 1 */
    #define EWLM_CHANGE_MGMTCLASS_ATTRIBUTE_OUTVERSION001  (1)
    #define EWLM_CHANGE_MGMTCLASS_ATTRIBUTE_OUTPUT_V001SIZE  \
             sizeof(ewlm_change_mgmtclass_attribute_output_t)
} ewlm_change_mgmtclass_attribute_output_t;

typedef struct ewlm_mgmtclass_attribute_list
{
    ewlm_int32_t               offset_first_entry;
    ewlm_int32_t               number_of_entries;
    ewlm_int32_t               length_of_entry;
} ewlm_mgmtclass_attribute_list_t;

typedef struct ewlm_change_mgmtclass_attribute_input
{
    ewlm_APIversion_t          version;
    ewlm_connect_handle_t      connect_handle;
    ewlm_int32_t               resource_type;

    #define EWLM_LOCAL_CPU_RESOURCES    (0x80000000)

    ewlm_mgmtclass_attribute_list_t     class_attribute_list;

    /* ------- end of data present in version 1 */
    #define EWLM_CHANGE_MGMTCLASS_ATTRIBUTE_INVERSION001  (1)
    #define EWLM_CHANGE_MGMTCLASS_ATTRIBUTE_INPUT_V001SIZE  \
             sizeof(ewlm_change_mgmtclass_attribute_input_t)
} ewlm_change_mgmtclass_attribute_input_t;

typedef struct ewlm_change_mgmtclass_attribute_entry
{
    ewlm_classification_id_t   service_class_id;
    ewlm_int32_t               shares;           /* Resource shares ranges
                                                    from 1 to 65535 */
}ewlm_change_mgmtclass_attribute_entry_t;

/*
    Required Return codes:
       0    EWLM_SUCCESS
    -100    EWLM_NO_CONNECTION
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -222    EWLM_SUPPORT_NOT_ENABLED
    -224    EWLM_LOCAL_WLM_NOT_ACTIVE
    -225    EWLM_LOCAL_WLM_PASSIVE
    -228    EWLM_BAD_MANAGEMENT_ID


    Optional Return codes:
    -101    EWLM_BAD_CONNECT_HANDLE
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
*/
ewlm_status_t ewlm_change_mgmtclass_attribute(
    /* [in]  */ ewlm_change_mgmtclass_attribute_input_t  *input_buffer,
    /* [in]  */ ewlm_bytelength_t                        input_buffer_size,
    /* [i/o] */ ewlm_change_mgmtclass_attribute_output_t *output_buffer,
    /* [in]  */ ewlm_bytelength_t                        output_buffer_size);

typedef struct ewlm_reassign_mgmtclass_output
{
    ewlm_APIversion_t          version;
    ewlm_bytelength_t          sizeneeded;
    /* ------- end of data present in version 1 */
    #define EWLM_REASSIGN_MGMTCLASS_OUTVERSION001  (1)
    #define EWLM_REASSIGN_MGMTCLASS_OUTPUT_V001SIZE  \
             sizeof(ewlm_reassign_mgmtclass_output_t)
} ewlm_reassign_mgmtclass_output_t;


typedef struct ewlm_reassign_mgmtclass_input
{
    ewlm_APIversion_t          version;
    ewlm_connect_handle_t      connect_handle;
    ewlm_classification_id_t   service_class_id;
    ewlm_process_id_t          pid;
    /* ------- end of data present in version 1 */
    #define EWLM_REASSIGN_MGMTCLASS_INVERSION001  (1)
    #define EWLM_REASSIGN_MGMTCLASS_INPUT_V001SIZE  \
             sizeof(ewlm_reassign_mgmtclass_input_t)
} ewlm_reassign_mgmtclass_input_t;


/*
    Required Return codes:
       0    EWLM_SUCCESS
    -100    EWLM_NO_CONNECTION
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -222    EWLM_SUPPORT_NOT_ENABLED
    -224    EWLM_LOCAL_WLM_NOT_ACTIVE
    -225    EWLM_LOCAL_WLM_PASSIVE
    -227    EWLM_PROCESS_LOCAL_WLM_MANAGED
    -228    EWLM_BAD_MANAGEMENT_ID

    Optional Return codes:
    -101    EWLM_BAD_CONNECT_HANDLE
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
*/

ewlm_status_t ewlm_reassign_mgmtclass(
    /* [in]  */ ewlm_reassign_mgmtclass_input_t         *input_buffer,
    /* [in]  */ ewlm_bytelength_t                       input_buffer_size,
    /* [i/o] */ ewlm_reassign_mgmtclass_output_t        *output_buffer,
    /* [in]  */ ewlm_bytelength_t                       output_buffer_size);

typedef struct ewlm_delete_mgmtclass_output
{
    ewlm_APIversion_t          version;
    ewlm_bytelength_t          sizeneeded;
    /* ------- end of data present in version 1 */
    #define EWLM_DELETE_MGMTCLASS_OUTVERSION001  (1)
    #define EWLM_DELETE_MGMTCLASS_OUTPUT_V001SIZE  \
             sizeof(ewlm_delete_mgmtclass_output_t)
} ewlm_delete_mgmtclass_output_t;


typedef struct ewlm_delete_mgmtclass_input
{
    ewlm_APIversion_t          version;
    ewlm_connect_handle_t      connect_handle;
    ewlm_classification_id_t   service_class_id;
    /* ------- end of data present in version 1 */
    #define EWLM_DELETE_MGMTCLASS_INVERSION001  (1)
    #define EWLM_DELETE_MGMTCLASS_INPUT_V001SIZE  \
             sizeof(ewlm_delete_mgmtclass_input_t)
} ewlm_delete_mgmtclass_input_t;


/*
    Required Return codes:
       0    EWLM_SUCCESS
    -100    EWLM_NO_CONNECTION
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -222    EWLM_SUPPORT_NOT_ENABLED
    -224    EWLM_LOCAL_WLM_NOT_ACTIVE
    -225    EWLM_LOCAL_WLM_PASSIVE

    Optional Return codes:
    -101    EWLM_BAD_CONNECT_HANDLE
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
*/
ewlm_status_t ewlm_delete_mgmtclass(
    /* [in]  */ ewlm_delete_mgmtclass_input_t   *input_buffer,
    /* [in]  */ ewlm_bytelength_t               input_buffer_size,
    /* [i/o] */ ewlm_delete_mgmtclass_output_t  *output_buffer,
    /* [in]  */ ewlm_bytelength_t               output_buffer_size);

typedef struct ewlm_activate_localresourcemgmt_output
{
    ewlm_APIversion_t          version;
    ewlm_bytelength_t          sizeneeded;
    /* ------- end of data present in version 1 */
    #define EWLM_ACTIVATE_LOCALRESOURCEMGMT_OUTVERSION001  (1)
    #define EWLM_ACTIVATE_LOCALRESOURCEMGMT_OUTPUT_V001SIZE  \
             sizeof(ewlm_activate_localresourcemgmt_output_t)
} ewlm_activate_localresourcemgmt_output_t;


typedef struct ewlm_activate_localresourcemgmt_input
{
    ewlm_APIversion_t          version;
    ewlm_connect_handle_t      connect_handle;
    ewlm_int32_t               resource_types;

    /* Following are four resources that EWLM is expected
       to manage over time. */

    #define EWLM_LOCAL_CPU_RESOURCES         (0x80000000)
    #define EWLM_LOCAL_MEMORY_RESOURCES      (0x40000000)
    #define EWLM_LOCAL_DISKIO_RESOURCES      (0x20000000)
    #define EWLM_LOCAL_NETWORK_RESOURCES     (0x10000000)

    /* ------- end of data present in version 1 */
    #define EWLM_ACTIVATE_LOCALRESOURCEMGMT_INVERSION001  (1)
    #define EWLM_ACTIVATE_LOCALRESOURCEMGMT_INPUT_V001SIZE  \
             sizeof(ewlm_activate_localresourcemgmt_input_t)
} ewlm_activate_localresourcemgmt_input_t;


/*
    Required Return codes:
       0    EWLM_SUCCESS
    -100    EWLM_NO_CONNECTION
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -222    EWLM_SUPPORT_NOT_ENABLED
    -224    EWLM_LOCAL_WLM_NOT_ACTIVE
    -229    EWLM_UNSUPPORTED_RESOURCE_TYPE

    Optional Return codes:
    -101    EWLM_BAD_CONNECT_HANDLE
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
*/
ewlm_status_t ewlm_activate_localresourcemgmt(
    /* [in]  */ ewlm_activate_localresourcemgmt_input_t *input_buffer,
    /* [in]  */ ewlm_bytelength_t                       input_buffer_size,
    /* [i/o] */ ewlm_activate_localresourcemgmt_output_t        *output_buffer,
    /* [in]  */ ewlm_bytelength_t                       output_buffer_size);


typedef struct ewlm_deactivate_localresourcemgmt_output
{
    ewlm_APIversion_t          version;
    ewlm_bytelength_t          sizeneeded;
    /* ------- end of data present in version 1 */
    #define EWLM_DEACTIVATE_LOCALRESOURCEMGMT_OUTVERSION001  (1)
    #define EWLM_DEACTIVATE_LOCALRESOURCEMGMT_OUTPUT_V001SIZE  \
             sizeof(ewlm_deactivate_localresourcemgmt_output_t)
} ewlm_deactivate_localresourcemgmt_output_t;


typedef struct ewlm_deactivate_localresourcemgmt_input
{
    ewlm_APIversion_t          version;
    ewlm_connect_handle_t      connect_handle;
    ewlm_int32_t               resource_types;

    /* Following are four primary resources that EWLM is expected
       to manage over time. */

    #define EWLM_LOCAL_CPU_RESOURCES            (0x80000000)
    #define EWLM_LOCAL_MEMORY_RESOURCES         (0x40000000)
    #define EWLM_LOCAL_DISKIO_RESOURCES         (0x20000000)
    #define EWLM_LOCAL_NETWORK_RESOURCES        (0x10000000)

    /* ------- end of data present in version 1 */
    #define EWLM_DEACTIVATE_LOCALRESOURCEMGMT_INVERSION001  (1)
    #define EWLM_DEACTIVATE_LOCALRESOURCEMGMT_INPUT_V001SIZE  \
             sizeof(ewlm_deactivate_localresourcemgmt_input_t)
} ewlm_deactivate_localresourcemgmt_input_t;


/*
    Required Return codes:
       0    EWLM_SUCCESS
    -100    EWLM_NO_CONNECTION
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL
    -222    EWLM_SUPPORT_NOT_ENABLED
    -224    EWLM_LOCAL_WLM_NOT_ACTIVE
    -225    EWLM_LOCAL_WLM_PASSIVE
    -229    EWLM_UNSUPPORTED_RESOURCE_TYPE

    Optional Return codes:
    -101    EWLM_BAD_CONNECT_HANDLE
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
*/
ewlm_status_t ewlm_deactivate_localresourcemgmt(
    /* [in]  */ ewlm_deactivate_localresourcemgmt_input_t    *input_buffer,
    /* [in]  */ ewlm_bytelength_t               input__buffer_size,
    /* [i/o] */ ewlm_deactivate_localresourcemgmt_output_t   *output_buffer,
    /* [in]  */ ewlm_bytelength_t               output_buffer_size);
/* ------------------------------------------------------------------------- */
/* --------------------Global Performance Data API-------------------------- */
/* ------------------------------------------------------------------------- */

typedef struct ewlm_global_perf_data_input
{
    ewlm_APIversion_t          version;
    ewlm_policytype_t          policy_type;

    ewlm_unencodedbytestream_t reportData;/* Global Performance
                                             data */
    ewlm_connect_handle_t      connect_handle;

    /* ------- end of data present in version 1 */
    #define EWLM_GLOBAL_PERF_DATA_IN_VERSION001        (1)
    #define EWLM_GLOBAL_PERF_DATA_INPUT_V001SIZE \
        sizeof(ewlm_global_perf_data_input_t)
} ewlm_global_perf_data_input_t;


typedef struct ewlm_global_perf_data_output
{
    ewlm_APIversion_t          version;
    ewlm_bytelength_t          sizeneeded;
    /* ------- end of data present in version 1 */
    #define EWLM_GLOBAL_PERF_DATA_OUTVERSION001        (1)
    #define EWLM_GLOBAL_PERF_DATA_OUTPUT_V001SIZE \
        sizeof(ewlm_global_perf_data_output_t)
} ewlm_global_perf_data_output_t;



ewlm_status_t ewlm_global_perf_data(
    /* [in]  */ ewlm_char_t         *input_buffer,
    /* [in]  */ ewlm_bytelength_t   input__buffer_size,
    /* [i/o] */ ewlm_char_t         *output_buffer,
    /* [in]  */ ewlm_bytelength_t   output_buffer_size
);

/*
    Required Return codes:
       0    EWLM_SUCCESS
    -100    EWLM_NO_CONNECTION
    -205    EWLM_MISSING_PARM
    -212    EWLM_BAD_IN_BUFFER
    -218    EWLM_INBUFFER_BELOW_V1SIZE
    -219    EWLM_INBUFFER_TOO_SMALL

    Optional Return codes:
    -101    EWLM_BAD_CONNECT_HANDLE
*/
/* --------------------------------------------------------------------------
    net_ prefixed services: see netwlm.h
   ------------------------------------------------------------------------- */ 
#ifdef __cplusplus
}
#endif /* __cplusplus */


#endif /* _H_EWLM_EWLMPLAT */