et_private.h

Go to the documentation of this file.

/*----------------------------------------------------------------------------*
 *  Copyright (c) 1998        Southeastern Universities Research Association, *
 *                            Thomas Jefferson National Accelerator Facility  *
 *                                                                            *
 *    This software was developed under a United States Government license    *
 *    described in the NOTICE file included as part of this distribution.     *
 *                                                                            *
 *    Author:  Carl Timmer                                                    *
 *             timmer@jlab.org                   Jefferson Lab, MS-12H        *
 *             Phone: (757) 269-5130             12000 Jefferson Ave.         *
 *             Fax:   (757) 269-5800             Newport News, VA 23606       *
 *                                                                            *
 *----------------------------------------------------------------------------*
 *
 * Description:
 *      Header file for ET system
 *
 *----------------------------------------------------------------------------*/

#ifndef __et_private_h
#define __et_private_h

#if  !(defined VXWORKS || defined sun)
#include <stdint.h>
#endif

#include <stdlib.h>
#include <stdarg.h>
#include <stddef.h>
#include <limits.h>
#include <pthread.h>

#include "etCommonNetwork.h"

#ifdef __cplusplus
extern "C" {
#endif

/* The data-type model for this architecture is set
 * by solaris to _LP64 or _ILP32. Linux defines 
 * __WORDSIZE to be 64 or 32. vxworks seems to do
 * nothing so define that as ILP32.
 */
#ifdef linux
  #if __WORDSIZE == 64
    #define _LP64 1
  #else
    #define _ILP32 1
  #endif
#elif defined VXWORKS
  #define _ILP32 1
#endif

#define ET_VERSION 15           
#define ET_VERSION_MINOR 1      
#define ET_LANG_C     0         
#define ET_LANG_CPP   1         
#define ET_LANG_JAVA  2         
#define ET_SYSTEM_TYPE_C     1  
#define ET_SYSTEM_TYPE_JAVA  2  
#define ET_IPADDRSTRLEN 16      
#define ET_MAXHOSTNAMELEN 256

#define ET_MAXADDRESSES 10

/* ***************************************
 * times for heart beating & monitoring *
 * ***************************************/
/* 1.6 sec */
#define ET_MON_SEC    1             
#define ET_MON_NSEC   600000000     
/* 0.5 sec */
#define ET_BEAT_SEC   0             
#define ET_BEAT_NSEC  500000000     
#define ET_HBMODULO UINT_MAX

#define ET_EXTRA_THREADS 2

/*
 * Maximum # of user attachments/processes on the system.
 * This is used only to allocate space in the system structure
 * for attachment/process housekeeping. The actual maximum #s of
 * attachments & processes are passed in a et_sys_config structure
 * to et_system_start.
 *
 * The number of attachments is the number of "et_station_attach"
 * calls successfully returned - each providing an access to events
 * from a certain station. A unix process may make several attachments
 * to one or more stations on one or more ET systems.
 *
 * The number of processes is just the number of "et_open" calls
 * successfully returned on the same host as the ET system. The
 * system must be one which can allow many processes to share the
 * ET mutexes, thus allowing full access to the shared memory. On
 * Linux this is not possible, meaning that the local user does NOT
 * have the proper access to the shared memory.
 * 
 * Since a unix process may only call et_open once, as things now stand,
 * the number of processes is a count of the number of unix processes
 * on Solaris opened locally.
 */
#define ET_ATTACHMENTS_MAX 100                 
#define ET_PROCESSES_MAX   ET_ATTACHMENTS_MAX  
/* status of an attachment to an ET system */
#define ET_ATT_UNUSED 0         
#define ET_ATT_ACTIVE 1         
/* values to tell attachment to return prematurely from ET routine */
#define ET_ATT_CONTINUE 0       
#define ET_ATT_QUIT     1       
/* values telling whether an attachment is blocked in a read or not */
#define ET_ATT_UNBLOCKED 0      
#define ET_ATT_BLOCKED   1      
/* values telling whether an attachment is in simulated sleep mode or not */
#define ET_ATT_NOSLEEP 0        
#define ET_ATT_SLEEP   1        
/* status of a process in regards to an ET system */
#define ET_PROC_CLOSED 0        
#define ET_PROC_OPEN   1        
/* what a process thinks of its ET system's status */
#define ET_PROC_ETDEAD 0        
#define ET_PROC_ETOK   1        
/* certain structures need to be initialized before use */
#define ET_STRUCT_NEW 0         
#define ET_STRUCT_OK  1         
/* values to tell thread to self-destruct or to stick around */
#define ET_THREAD_KEEP 0        
#define ET_THREAD_KILL 1        
/* tells if operating sys can share pthread mutexes between processes */
#define ET_MUTEX_SHARE   0      
#define ET_MUTEX_NOSHARE 1      
/* is pthread mutex locked or not */
#define ET_MUTEX_UNLOCKED 0    
#define ET_MUTEX_LOCKED   1    
#define ET_INITIAL_SHARED_MEM_DATA_BYTES 64


/*
 * STRUCTURES for the STATIONs:
 * --------------------------
 *  structures          purpose
 * ____________        ________________
 *  et_stat_config      station behavior parameters
 *  et_stat_data        station information
 *  et_event            single event
 *  et_list             list of events
 *  et_station          processes can "attach" to station
 *                      to get and put events
 */


typedef int (*ET_SELECT_FUNCPTR) (void *, et_stat_id, et_event *);


typedef struct et_stat_config_t {
  int  init;           
  int  flow_mode;      
  int  user_mode;      
  int  restore_mode;   
  int  block_mode;     
  int  prescale;       
  int  cue;            
  int  select_mode;    
  int  select[ET_STATION_SELECT_INTS]; 
  char fname[ET_FUNCNAME_LENGTH];      
  char lib[ET_FILENAME_LENGTH];        
  char classs[ET_FILENAME_LENGTH];     
} et_stat_config;


typedef struct et_stat_data_t {
  int   status;                    
  int   pid_create;                
  int   nattachments;              
  int   att[ET_ATTACHMENTS_MAX];   
  void *lib_handle;                
  ET_SELECT_FUNCPTR func;          
} et_stat_data;


typedef struct et_list_t {
  int              cnt;          
  int              lasthigh;     
  uint64_t         events_try;   
  uint64_t         events_in;    
  uint64_t         events_out;   
  et_event        *firstevent;   
  et_event        *lastevent;    
  pthread_mutex_t  mutex;        
  pthread_cond_t   cread;        
} et_list;


#define ET_FIX_READ 0  
#define ET_FIX_DUMP 1  
struct et_fixin {
  et_event   *first;       
  uint64_t    eventsin;    
  int         start;       
  int         cnt;         
  int         num;         
  int         call;        
};


struct et_fixout {
    int         start;       
    int         cnt;         
    int         num;         
};


struct et_fix {
  struct et_fixin  in;  
  struct et_fixout out; 
};


typedef struct et_station_t {
  et_stat_id            num;              
  int                   conductor;        
  et_stat_id            next;             
  et_stat_id            prev;             
  et_stat_id            nextparallel;     
  et_stat_id            prevparallel;     
  int                   waslast;          
  char                  name[ET_STATNAME_LENGTH];  
  pthread_mutex_t       mutex;            
  struct et_fix         fix;              
  et_stat_data          data;             
  et_stat_config        config;           
  et_list               list_in;          
  et_list               list_out;         
} et_station;


struct et_proc {
  et_proc_id    num;                      
  et_att_id     att[ET_ATTACHMENTS_MAX];  
  int           nattachments;             
  int           status;                   
  int           et_status;                
  unsigned int  heartbeat;                
  pid_t         pid;                      
  pthread_t     hbeat_thd_id;             
  pthread_t     hmon_thd_id;              
};


struct et_attach {
  et_att_id   num;          
  et_proc_id  proc;         
  et_stat_id  stat;         
  int         status;       
  int         blocked;      
  int         quit;         
  int         sleep;        
  uint64_t    events_put;   
  uint64_t    events_get;   
  uint64_t    events_dump;  
  uint64_t    events_make;  
  pid_t       pid;          
  char        host[ET_MAXHOSTNAMELEN];      
  char        interface[ET_IPADDRSTRLEN];   
};


typedef struct  et_sys_config_t {
  uint64_t          event_size;       
  int               init;             
  int               nevents;          
  int               ntemps;           
  int               nstations;        
  int               nprocesses;       
  int               nattachments;     
  int               groupCount;       
  int               groups[ET_EVENT_GROUPS_MAX];  
  char              filename[ET_FILENAME_LENGTH]; 
  /* for remote use */
  int               port;             
  int               serverport;       
  int               tcpSendBufSize;   
  int               tcpRecvBufSize;   
  int               tcpNoDelay;       
  codaNetInfo       netinfo;          
  codaDotDecIpAddrs bcastaddrs;       
  codaDotDecIpAddrs mcastaddrs;       
} et_sys_config;


/* Macros to handle the bitInfo word in et_system structure following. */
#define ET_BIT64_MASK 0x1  
#define ET_KILL_MASK  0x2  
#define ET_GET_BIT64(x)  ((x) & ET_BIT64_MASK)  
#define ET_GET_KILL(x)   ((x) & ET_KILL_MASK)   
#define ET_SET_BIT64(x)  ((x) | ET_BIT64_MASK)  
#define ET_SET_KILL(x)   ((x) | ET_KILL_MASK)   
typedef struct et_system_t {
  int              version;        
  int              nselects;       
  int              bitInfo;        
  int              asthread;       
  unsigned int     heartbeat;      
  int              hz;             
  int              nstations;      
  int              ntemps;         
  int              nprocesses;     
  int              nattachments;   
  int              port;           
  et_stat_id       stat_head;      
  et_stat_id       stat_tail;      
  pid_t            mainpid;        
#ifdef sun
  int              con_add;        
#endif
  void            *pmap;           
  pthread_mutex_t  mutex;          
  pthread_mutex_t  stat_mutex;     
  pthread_mutex_t  statadd_mutex;  
  pthread_cond_t   statadd;        
  pthread_cond_t   statdone;       
  pthread_t        tid_hb;         
  pthread_t        tid_hm;         
  pthread_t        tid_as;         
  pthread_t        tid_srv;        
  pthread_t        tid_mul;        
  char             host[ET_MAXHOSTNAMELEN];     
  struct et_proc   proc[ET_PROCESSES_MAX];      
  struct et_attach attach[ET_ATTACHMENTS_MAX];  
  et_sys_config    config;        
} et_system;


typedef struct et_open_config_t {
    int             init;            
    int             wait;            
    int             cast;            
    int             ttl;             
    int             mode;            
    int             debug_default;   
    int             udpport;         
    int             multiport;       
    int             serverport;      
    int             policy;          
    int             tcpSendBufSize;  
    int             tcpRecvBufSize;  
    int             tcpNoDelay;      
    struct timespec timeout;         
    char            host[ET_MAXHOSTNAMELEN];    
    char            interface[ET_IPADDRSTRLEN]; 
    codaIpAddr       *netinfo;       
    codaIpList       *bcastaddrs;    
    codaDotDecIpAddrs mcastaddrs;    
} et_open_config;


typedef struct  et_id_t {
    int              init;          
    int              lang;          
    int              alive;         
    int              closed;        
    int              bit64;         
    et_proc_id       proc;          
    int              race;          
    int              cleanup;       
    int              debug;         
    int              nevents;       
    int              group;         
    int              version;       
    int              nselects;      
    int              share;         
    size_t           memsize;       
    uint64_t         esize;         
    ptrdiff_t        offset;        
    /* for REMOTE use */
    int              locality;      
    int              sockfd;        
    int              endian;        
    int              systemendian;  
    int              iov_max;       
    int              port;          
    char             ethost[ET_MAXHOSTNAMELEN];  
    /******************/

    void            *pmap;          
    et_system       *sys;           
    et_station      *stats;         
    int             *histogram;     
    et_event        *events;        
    char            *data;          
    et_station      *grandcentral;  
    pthread_mutex_t  mutex;         
#ifndef NO_RW_LOCK
    pthread_rwlock_t sharedMemlock; 
#endif
} et_id;


typedef struct  et_mem_t {
    uint32_t  byteOrder;       
    uint32_t  systemType;      
    uint32_t  majorVersion;    
    uint32_t  minorVersion;    
    uint32_t  numSelectInts;   
    uint32_t  headerByteSize;  
    uint64_t  eventByteSize;   
    uint64_t  headerPosition;  
    uint64_t  dataPosition;    
    uint64_t  totalSize;       
    uint64_t  usedSize;        
} et_mem;


typedef struct et_response_t {
    int   port;                     
    int   castType;                 
    int   addrCount;                
    char  uname[ET_MAXHOSTNAMELEN]; 
    char  canon[ET_MAXHOSTNAMELEN]; 
    char  castIP[ET_IPADDRSTRLEN];  
    uint32_t *addrs;                
    char  **ipaddrs;                
    char  **bcastaddrs;             
    struct et_response_t *next;     
} et_response;


/****************************
 *       REMOTE STUFF       *
 ****************************/

/* "table" of values representing ET commands for tcp/ip */

/* for operating systems that cannot share mutexes (Linux) */
#define  ET_NET_EV_GET_L        0        
#define  ET_NET_EVS_GET_L       1        
#define  ET_NET_EV_PUT_L        2        
#define  ET_NET_EVS_PUT_L       3        
#define  ET_NET_EV_NEW_L        4        
#define  ET_NET_EVS_NEW_L       5        
#define  ET_NET_EV_DUMP_L       6        
#define  ET_NET_EVS_DUMP_L      7        
#define  ET_NET_EVS_NEW_GRP_L   8        
/* for fully remote systems */
#define  ET_NET_EV_GET         20        
#define  ET_NET_EVS_GET        21        
#define  ET_NET_EV_PUT         22        
#define  ET_NET_EVS_PUT        23        
#define  ET_NET_EV_NEW         24        
#define  ET_NET_EVS_NEW        25        
#define  ET_NET_EV_DUMP        26        
#define  ET_NET_EVS_DUMP       27        
#define  ET_NET_EVS_NEW_GRP    28        
#define  ET_NET_EVS_NEW_GRP_JAVA 29
      
#define  ET_NET_ALIVE          40        
#define  ET_NET_WAIT           41        
#define  ET_NET_CLOSE          42        
#define  ET_NET_FCLOSE         43        
#define  ET_NET_WAKE_ATT       44        
#define  ET_NET_WAKE_ALL       45        
#define  ET_NET_KILL           46        
#define  ET_NET_STAT_ATT       60        
#define  ET_NET_STAT_DET       61        
#define  ET_NET_STAT_CRAT      62        
#define  ET_NET_STAT_RM        63        
#define  ET_NET_STAT_SPOS      64        
#define  ET_NET_STAT_GPOS      65        
#define  ET_NET_STAT_ISAT      80        
#define  ET_NET_STAT_EX        81        
#define  ET_NET_STAT_SSW       82        
#define  ET_NET_STAT_GSW       83        
#define  ET_NET_STAT_LIB       84        
#define  ET_NET_STAT_FUNC      85        
#define  ET_NET_STAT_CLASS     86        
#define  ET_NET_STAT_GATTS    100        
#define  ET_NET_STAT_STATUS   101        
#define  ET_NET_STAT_INCNT    102        
#define  ET_NET_STAT_OUTCNT   103        
#define  ET_NET_STAT_GBLOCK   104        
#define  ET_NET_STAT_GUSER    105        
#define  ET_NET_STAT_GRESTORE 106        
#define  ET_NET_STAT_GPRE     107        
#define  ET_NET_STAT_GCUE     108        
#define  ET_NET_STAT_GSELECT  109        
#define  ET_NET_STAT_SBLOCK   115        
#define  ET_NET_STAT_SUSER    116        
#define  ET_NET_STAT_SRESTORE 117        
#define  ET_NET_STAT_SPRE     118        
#define  ET_NET_STAT_SCUE     119        
#define  ET_NET_ATT_PUT       130        
#define  ET_NET_ATT_GET       131        
#define  ET_NET_ATT_DUMP      132        
#define  ET_NET_ATT_MAKE      133        
#define  ET_NET_SYS_TMP       150        
#define  ET_NET_SYS_TMPMAX    151        
#define  ET_NET_SYS_STAT      152        
#define  ET_NET_SYS_STATMAX   153        
#define  ET_NET_SYS_PROC      154        
#define  ET_NET_SYS_PROCMAX   155        
#define  ET_NET_SYS_ATT       156        
#define  ET_NET_SYS_ATTMAX    157        
#define  ET_NET_SYS_HBEAT     158        
#define  ET_NET_SYS_PID       159        
#define  ET_NET_SYS_GRP       160        
#define  ET_NET_SYS_DATA      170        
#define  ET_NET_SYS_HIST      171        
#define  ET_NET_SYS_GRPS      172        
typedef struct et_netthread_t {
    int   cast;                     
    et_id *id;                      
    et_sys_config *config;          
    char *listenaddr;               
    char uname[ET_MAXHOSTNAMELEN];  
} et_netthread;


/****************************
 *       BRIDGE STUFF       *
 ****************************/
 
typedef struct et_bridge_config_t {
    int             init;          
    int             mode_from;     
    int             mode_to;       
    int             chunk_from;    
    int             chunk_to;      
    struct timespec timeout_from;  
    struct timespec timeout_to;    
    ET_SWAP_FUNCPTR func;          
} et_bridge_config;


/****************************
 *    END BRIDGE STUFF      *
 ****************************/

#define ET_P2EVENT(etid, place) ((et_event *)((et_event *)(etid->events) + (place)))

/* Macros to switch ptrs from ET space to user space & vice versa. */

#define ET_PEVENT2USR(p, offset) ((et_event *)((char *)(p) + (offset)))

#define ET_PEVENT2ET(p, offset)  ((et_event *)((char *)(p) - (offset)))

#define ET_PSTAT2USR(p, offset)  ((et_station *)((char *)(p) + (offset)))

#define ET_PSTAT2ET(p, offset)   ((et_station *)((char *)(p) - (offset)))

#define ET_PDATA2USR(p, offset)  ((void *)((char *)(p) + (offset)))

#define ET_PDATA2ET(p, offset)   ((void *)((char *)(p) - (offset)))

/* Macros to break a 64 int into 2, 32 bit ints & the reverse. */

#define ET_64BIT_UINT(hi,lo)       (((uint64_t)(hi) << 32) | ((uint64_t)(lo) & 0x00000000FFFFFFFF))

#define ET_64BIT_INT(hi,lo)         (((int64_t)(hi) << 32) | ((int64_t)(lo)  & 0x00000000FFFFFFFF))

#define ET_64BIT_P(hi,lo) ((void *)(((uint64_t)(hi) << 32) | ((uint64_t)(lo) & 0x00000000FFFFFFFF)))

#define ET_HIGHINT(i)         ((uint32_t)(((uint64_t)(i) >> 32) & 0x00000000FFFFFFFF))

#define ET_LOWINT(i)           ((uint32_t)((uint64_t)(i) & 0x00000000FFFFFFFF))

/***********************/
/* Extern declarations */
/***********************/

/* mutex related */
extern void et_station_lock(et_system *sys);
extern void et_station_unlock(et_system *sys);

extern void et_llist_lock(et_list *pl);
extern void et_llist_unlock(et_list *pl);

extern void et_system_lock(et_system *sys);
extern void et_system_unlock(et_system *sys);

extern void et_transfer_lock(et_station *ps);
extern void et_transfer_unlock(et_station *ps);
extern void et_transfer_lock_all(et_id *id);
extern void et_transfer_unlock_all(et_id *id);

extern void et_tcp_lock(et_id *id);
extern void et_tcp_unlock(et_id *id);

extern void et_memRead_lock(et_id *id);
extern void et_memWrite_lock(et_id *id);
extern void et_mem_unlock(et_id *id);

extern int  et_mutex_locked(pthread_mutex_t *pmutex);

extern int  et_repair_station(et_id *id, et_stat_id stat_id);
extern int  et_repair_gc(et_id *id);

/* initialization */
extern void et_init_station(et_station *ps);
extern void et_init_llist(et_list *pl);

extern void et_init_event(et_event *pe);
extern void et_init_event_(et_event *pe);

extern void et_init_process(et_system *sys, et_proc_id id);
extern void et_init_attachment(et_system *sys, et_att_id id);

extern void et_init_histogram(et_id *id);
extern void et_init_stats_att(et_system *sys, et_att_id id);
extern void et_init_stats_allatts(et_system *sys);
extern void et_init_stats_station(et_station *ps);
extern void et_init_stats_allstations(et_id *id);
extern void et_init_stats_all(et_id *id);

extern int  et_id_init(et_sys_id* id);
extern void et_id_destroy(et_sys_id id);

/* read and write */
extern int  et_station_write(et_id *id,  et_stat_id stat_id, et_event  *pe);
extern int  et_station_nwrite(et_id *id, et_stat_id stat_id, et_event *pe[], int num);

extern int  et_station_read(et_id *id,  et_stat_id stat_id, et_event **pe, 
                            int _mode, et_att_id att, struct timespec *time);
extern int  et_station_nread(et_id *id, et_stat_id stat_id, et_event *pe[], int mode,
                             et_att_id att, struct timespec *time, int num, int *nread);
extern int  et_station_nread_group(et_id *id, et_stat_id stat_id, et_event *pe[], int mode,
                 et_att_id att, struct timespec *time, int num, int group, int *nread);
extern int  et_station_dump(et_id *id, et_event *pe);
extern int  et_station_ndump(et_id *id, et_event *pe[], int num);

extern int  et_llist_read(et_list *pl, et_event **pe);
extern int  et_llist_write(et_id *id, et_list *pl, et_event **pe, int num);
extern int  et_llist_write_gc(et_id *id, et_event **pe, int num);

extern int  et_restore_events(et_id *id, et_att_id att, et_stat_id stat_id);
extern void et_flush_events(et_id *id, et_att_id att, et_stat_id stat_id);

/* mmap/memory functions */
extern int   et_mem_create(const char *name, size_t memsize, void **pmemory, size_t *totalSize);
extern void *et_mem_write_first_block(char *ptr,
                                      uint32_t headerByteSize, uint64_t eventByteSize,
                                      uint64_t headerPosition, uint64_t dataPosition,
                                      uint64_t totalByteSize,  uint64_t usedByteSize);
extern int   et_mem_attach(const char *name, void **pmemory, et_mem *pInfo);
extern int   et_mem_unmap(const char *name, void *pmem);
extern int   et_mem_remove(const char *name, void *pmem);
extern int   et_mem_size(const char *name, size_t *totalsize, size_t *usedsize);

extern void *et_temp_create(const char *name, size_t size);
extern void *et_temp_attach(const char *name, size_t size);
extern int   et_temp_remove(const char *name, void *pmem, size_t size);

/* remote routines */
extern int  etr_event_new(et_sys_id id, et_att_id att, et_event **ev,
                int mode, struct timespec *deltatime, size_t size);
extern int  etr_events_new(et_sys_id id, et_att_id att, et_event *evs[],
                int mode, struct timespec *deltatime, size_t size, int num, int *nread);
extern int  etr_events_new_group(et_sys_id id, et_att_id att, et_event *evs[],
                   int mode, struct timespec *deltatime,
                   size_t size, int num, int group, int *nread);
extern int  etr_event_get(et_sys_id id, et_att_id att, et_event **ev,
                int wait, struct timespec *deltatime);
extern int  etr_events_get(et_sys_id id, et_att_id att, et_event *evs[],
                int wait, struct timespec *deltatime, int num, int *nread);
extern int  etr_event_put(et_sys_id id, et_att_id att, et_event *ev);
extern int  etr_events_put(et_sys_id id, et_att_id att, et_event *evs[], int num);
extern int  etr_event_dump(et_sys_id id, et_att_id att, et_event *ev);
extern int  etr_events_dump(et_sys_id id, et_att_id att, et_event *evs[], int num);

extern int  etr_open(et_sys_id *id, const char *et_filename, et_openconfig openconfig);
extern int  etr_close(et_sys_id id);
extern int  etr_forcedclose(et_sys_id id);
extern int  etr_kill(et_sys_id id);
extern int  etr_alive(et_sys_id id);
extern int  etr_wait_for_alive(et_sys_id id);
extern int  etr_wakeup_attachment(et_sys_id id, et_att_id att);
extern int  etr_wakeup_all(et_sys_id id, et_stat_id stat_id);

extern int  etr_station_create_at(et_sys_id id, et_stat_id *stat_id,
                 const char *stat_name, et_statconfig sconfig,
                 int position, int parallelposition);
extern int  etr_station_create(et_sys_id id, et_stat_id *stat_id,
                 const char *stat_name, et_statconfig sconfig);
extern int  etr_station_remove(et_sys_id id, et_stat_id stat_id);
extern int  etr_station_attach(et_sys_id id, et_stat_id stat_id, et_att_id *att);
extern int  etr_station_detach(et_sys_id id, et_att_id att);
extern int  etr_station_setposition(et_sys_id id, et_stat_id stat_id, int position,
                                    int parallelposition);
extern int  etr_station_getposition(et_sys_id id, et_stat_id stat_id, int *position,
                                    int *parallelposition);
extern int  etr_station_isattached(et_sys_id id, et_stat_id stat_id, et_att_id att);
extern int  etr_station_exists(et_sys_id id, et_stat_id *stat_id, const char *stat_name);

extern int  etr_station_getattachments(et_sys_id id, et_stat_id stat_id, int *numatts);
extern int  etr_station_getstatus(et_sys_id id, et_stat_id stat_id, int *status);
extern int  etr_station_getstatus(et_sys_id id, et_stat_id stat_id, int *status);
extern int  etr_station_getinputcount(et_sys_id id, et_stat_id stat_id, int *cnt);
extern int  etr_station_getoutputcount(et_sys_id id, et_stat_id stat_id, int *cnt);
extern int  etr_station_getselect(et_sys_id id, et_stat_id stat_id, int *select);
extern int  etr_station_getlib(et_sys_id id, et_stat_id stat_id, char *lib);
extern int  etr_station_getclass(et_sys_id id, et_stat_id stat_id, char *classs);
extern int  etr_station_getfunction(et_sys_id id, et_stat_id stat_id, char *function);

extern int  etr_station_getblock(et_sys_id id, et_stat_id stat_id, int *block);
extern int  etr_station_setblock(et_sys_id id, et_stat_id stat_id, int  block);
extern int  etr_station_getuser(et_sys_id id, et_stat_id stat_id, int *user);
extern int  etr_station_setuser(et_sys_id id, et_stat_id stat_id, int  user);
extern int  etr_station_getrestore(et_sys_id id, et_stat_id stat_id, int *restore);
extern int  etr_station_setrestore(et_sys_id id, et_stat_id stat_id, int  restore);
extern int  etr_station_getprescale(et_sys_id id, et_stat_id stat_id, int *prescale);
extern int  etr_station_setprescale(et_sys_id id, et_stat_id stat_id, int  prescale);
extern int  etr_station_getcue(et_sys_id id, et_stat_id stat_id, int *cue);
extern int  etr_station_setcue(et_sys_id id, et_stat_id stat_id, int  cue);
extern int  etr_station_getselectwords(et_sys_id id, et_stat_id stat_id, int select[]);
extern int  etr_station_setselectwords(et_sys_id id, et_stat_id stat_id, int select[]);

extern int  etr_system_gettemps (et_sys_id id, int *temps);
extern int  etr_system_gettempsmax (et_sys_id id, int *tempsmax);
extern int  etr_system_getstations (et_sys_id id, int *stations);
extern int  etr_system_getstationsmax (et_sys_id id, int *stationsmax);
extern int  etr_system_getprocs (et_sys_id id, int *procs);
extern int  etr_system_getprocsmax (et_sys_id id, int *procsmax);
extern int  etr_system_getattachments (et_sys_id id, int *atts);
extern int  etr_system_getattsmax (et_sys_id id, int *attsmax);
extern int  etr_system_getheartbeat (et_sys_id id, int *heartbeat);
extern int  etr_system_getpid (et_sys_id id, int *pid);
extern int  etr_system_getgroupcount (et_sys_id id, int *groupCnt);
/* end remote routines */

/* attachment rountines */
extern int etr_attach_geteventsput(et_sys_id id, et_att_id att_id,
                                   uint64_t *events);
extern int etr_attach_geteventsget(et_sys_id id, et_att_id att_id,
                                   uint64_t *events);
extern int etr_attach_geteventsdump(et_sys_id id, et_att_id att_id,
                                    uint64_t *events);
extern int etr_attach_geteventsmake(et_sys_id id, et_att_id att_id,
                                    uint64_t *events);
/* end of attachment routines */

/* local no-share (linux) routines */
extern int  etn_open(et_sys_id *id, const char *filename, et_openconfig openconfig);
extern int  etn_close(et_sys_id id);
extern int  etn_forcedclose(et_sys_id id);
extern int  etn_kill(et_sys_id id);
extern int  etn_alive(et_sys_id id);
extern int  etn_wait_for_alive(et_sys_id id);
extern int  etn_event_new(et_sys_id id, et_att_id att, et_event **ev,
                 int mode, struct timespec *deltatime, size_t size);
extern int  etn_events_new(et_sys_id id, et_att_id att, et_event *evs[],
                 int mode, struct timespec *deltatime, size_t size, int num, int *nread);
extern int  etn_events_new_group(et_sys_id id, et_att_id att, et_event *evs[],
                 int mode, struct timespec *deltatime,
                 size_t size, int num, int group, int *nread);
extern int  etn_event_get(et_sys_id id, et_att_id att, et_event **ev,
                 int mode, struct timespec *deltatime);
extern int  etn_events_get(et_sys_id id, et_att_id att, et_event *evs[],
                 int mode, struct timespec *deltatime, int num, int *nread);
extern int  etn_event_put(et_sys_id id, et_att_id att, et_event *ev);
extern int  etn_events_put(et_sys_id id, et_att_id att, et_event *evs[], int num);
extern int  etn_event_dump(et_sys_id id, et_att_id att, et_event *ev);
extern int  etn_events_dump(et_sys_id id, et_att_id att, et_event *evs[], int num);
/* end of local linux routines */

/* local routines (Sun) */
extern int  etl_open(et_sys_id *id, const char *filename, et_openconfig openconfig);
extern int  etl_close(et_sys_id id);
extern int  etl_forcedclose(et_sys_id id);
extern int  etl_kill(et_sys_id id);
extern int  etl_alive(et_sys_id id);
extern int  etl_wait_for_alive(et_sys_id id);
extern int  et_wait_for_system(et_sys_id id, struct timespec *timeout,
                                const char *etname);
extern int  et_look(et_sys_id *id, const char *filename);
extern int  et_unlook(et_sys_id id);
/* end local routines */

/* server/network routines */
extern void *et_cast_thread(void *arg);
extern void *et_netserver(void *arg);
extern int   et_findserver(const char *etname, char *ethost, int *port,
                           uint32_t *inetaddr, et_open_config *config, et_response **allETinfo);
extern int   et_responds(const char *etname);
extern int   et_sharedmutex(void);
extern int   et_findlocality(const char *filename, et_openconfig openconfig);
/* end server/network routines */
 
/* station configuration checks */
extern int  et_station_config_check(et_id *id, et_stat_config *sc);
extern int  et_station_compare_parallel(et_id *id, et_stat_config *group,
            et_stat_config *config);
/* end station configuration checks */

/* error logging */
extern void et_logmsg (char *sev, char *fmt, ...);

#ifdef __cplusplus
}
#endif

#endif