diff options
Diffstat (limited to 'gdb/29k-share/udi')
| -rw-r--r-- | gdb/29k-share/udi/udi2go32.c | 607 | ||||
| -rw-r--r-- | gdb/29k-share/udi/udiids.h | 48 | ||||
| -rw-r--r-- | gdb/29k-share/udi/udip2soc.c | 1250 | ||||
| -rw-r--r-- | gdb/29k-share/udi/udiphcfg.h | 44 | ||||
| -rw-r--r-- | gdb/29k-share/udi/udiphunix.h | 81 | ||||
| -rw-r--r-- | gdb/29k-share/udi/udiproc.h | 308 | ||||
| -rw-r--r-- | gdb/29k-share/udi/udipt29k.h | 87 | ||||
| -rw-r--r-- | gdb/29k-share/udi/udiptcfg.h | 19 | ||||
| -rw-r--r-- | gdb/29k-share/udi/udisoc.h | 184 | ||||
| -rw-r--r-- | gdb/29k-share/udi/udr.c | 427 |
10 files changed, 3055 insertions, 0 deletions
diff --git a/gdb/29k-share/udi/udi2go32.c b/gdb/29k-share/udi/udi2go32.c new file mode 100644 index 00000000000..63d98ae4017 --- /dev/null +++ b/gdb/29k-share/udi/udi2go32.c @@ -0,0 +1,607 @@ +/* + +Interface from UDI calls in 32-bit mode to go32 in 16-bit mode. +Communication is done through a single interrupt vector, which passes +data through two linear buffers. + +Call: + AH = 0xfe + AL = UDI function number + ECX = IN length + ESI = pointer to IN buffer + EDI = pointer to OUT buffer + +Return: + EAX = return value of UDI function + +Vector: + 0x21 + +*/ +#ifdef __GO32__ + +#include <stdlib.h> +#include "udiproc.h" +#include "udisoc.h" + +char dfe_errmsg[500]; + +static char in_buffer[4096]; +static char out_buffer[4096]; +static char *in_ptr; +static char *out_ptr; + +#define IN_INIT() in_ptr = in_buffer +#define IN_VAL(t,v) *((t *)in_ptr)++ = v +#define IN_DATA(ptr, cnt) memcpy(in_ptr, ptr, cnt), in_ptr += cnt + +#define OUT_INIT() out_ptr = out_buffer +#define OUT_VAL(t) (*((t *)out_ptr)++) +#define OUT_DATA(ptr, cnt) memcpy(ptr, out_ptr, cnt), out_ptr += cnt + +static int DO_CALL(int function) +{ + asm("pushl %esi"); + asm("pushl %edi"); + asm("movb %0, %%al" : : "g" (function)); + asm("movl _in_ptr, %ecx"); + asm("movl $_in_buffer, %esi"); + asm("subl %esi, %ecx"); + asm("movl $_out_buffer, %edi"); + asm("movb $0xfe, %ah"); + asm("int $0x21"); + asm("popl %edi"); + asm("popl %esi"); +} + +/*----------------------------------------------------------------------*/ + +#ifdef TEST_UDI +int main() +{ + int r; + long p2; + short p1; + IN_INIT(); + IN_VAL(long, 11111111); + IN_VAL(short, 2222); + IN_DATA("Hello, world\n", 17); + + r = DO_CALL(42); + + OUT_INIT(); + p1 = OUT_VAL(short); + p2 = OUT_VAL(long); + printf("main: p1=%d p2=%d rv=%d\n", p1, p2, r); + return r; +} +#endif + +/*----------------------------------------------------------------------*/ + +unsupported(char *s) +{ + printf("unsupported UDI host call %s\n", s); + abort(); +} + +UDIError UDIConnect ( + char *Configuration, /* In */ + UDISessionId *Session /* Out */ + ) +{ + int r; + out_buffer[0] = 0; /* DJ - test */ + IN_INIT(); + IN_DATA(Configuration, strlen(Configuration)+1); + + r = DO_CALL(UDIConnect_c); + + OUT_INIT(); + *Session = OUT_VAL(UDISessionId); + return r; +} + +UDIError UDIDisconnect ( + UDISessionId Session, /* In */ + UDIBool Terminate /* In */ + ) +{ + int r; + IN_INIT(); + IN_VAL(UDISessionId, Session); + IN_VAL(UDIBool, Terminate); + + return DO_CALL(UDIDisconnect_c); +} + +UDIError UDISetCurrentConnection ( + UDISessionId Session /* In */ + ) +{ + IN_INIT(); + IN_VAL(UDISessionId, Session); + + return DO_CALL(UDISetCurrentConnection_c); +} + +UDIError UDICapabilities ( + UDIUInt32 *TIPId, /* Out */ + UDIUInt32 *TargetId, /* Out */ + UDIUInt32 DFEId, /* In */ + UDIUInt32 DFE, /* In */ + UDIUInt32 *TIP, /* Out */ + UDIUInt32 *DFEIPCId, /* Out */ + UDIUInt32 *TIPIPCId, /* Out */ + char *TIPString /* Out */ + ) +{ + int r; + IN_INIT(); + IN_VAL(UDIUInt32, DFEId); + IN_VAL(UDIUInt32, DFE); + r = DO_CALL(UDICapabilities_c); + OUT_INIT(); + *TIPId = OUT_VAL(UDIUInt32); + *TargetId = OUT_VAL(UDIUInt32); + *TIP = OUT_VAL(UDIUInt32); + *DFEIPCId = OUT_VAL(UDIUInt32); + *TIPIPCId = OUT_VAL(UDIUInt32); + strcpy(TIPString, out_ptr); + return r; +} + +UDIError UDIEnumerateTIPs ( + UDIInt (*UDIETCallback) /* In */ + ( char *Configuration ) /* In to callback() */ + ) +{ + UDIETCallback("montip.exe"); +} + +UDIError UDIGetErrorMsg ( + UDIError ErrorCode, /* In */ + UDISizeT MsgSize, /* In */ + char *Msg, /* Out */ + UDISizeT *CountDone /* Out */ + ) +{ + int r; + if (MsgSize > 4000) + MsgSize = 4000; + IN_INIT(); + IN_VAL(UDIError, ErrorCode); + IN_VAL(UDISizeT, MsgSize); + + r = DO_CALL(UDIGetErrorMsg_c); + + OUT_INIT(); + *CountDone = OUT_VAL(UDISizeT); + OUT_DATA(Msg, *CountDone); + return r; +} + +UDIError UDIGetTargetConfig ( + UDIMemoryRange KnownMemory[], /* Out */ + UDIInt *NumberOfRanges, /* In/Out */ + UDIUInt32 ChipVersions[], /* Out */ + UDIInt *NumberOfChips /* In/Out */ + ) +{ + int r, i; + int nr = *NumberOfRanges; + int nc = *NumberOfChips; + IN_INIT(); + IN_VAL(UDIInt, *NumberOfRanges); + IN_VAL(UDIInt, *NumberOfChips); + r = DO_CALL(UDIGetTargetConfig_c); + if (r == UDIErrorIncomplete) + return r; + OUT_INIT(); + *NumberOfRanges = OUT_VAL(UDIInt); + *NumberOfChips = OUT_VAL(UDIInt); + for (i=0; i<nr; i++) + { + KnownMemory[i].Space = OUT_VAL(short); + KnownMemory[i].Offset = OUT_VAL(CPUOffset); + KnownMemory[i].Size = OUT_VAL(CPUSizeT); + } + for (i=0; i<nc; i++) + { + ChipVersions[i] = OUT_VAL(UDIUInt32); + } + return r; +} + +UDIError UDICreateProcess ( + UDIPId *PId /* Out */ + ) +{ + int r = DO_CALL(UDICreateProcess_c); + + OUT_INIT(); + *PId = OUT_VAL(UDIPId); + + return r; +} + +UDIError UDISetCurrentProcess ( + UDIPId PId /* In */ + ) +{ + IN_INIT(); + IN_VAL(UDIPId, PId); + + return DO_CALL(UDISetCurrentProcess_c); +} + +UDIError UDIDestroyProcess ( + UDIPId PId /* In */ + ) +{ + IN_INIT(); + IN_VAL(UDIPId, PId); + + return DO_CALL(UDIDestroyProcess_c); +} + +UDIError UDIInitializeProcess ( + UDIMemoryRange ProcessMemory[], /* In */ + UDIInt NumberOfRanges, /* In */ + UDIResource EntryPoint, /* In */ + CPUSizeT StackSizes[], /* In */ + UDIInt NumberOfStacks, /* In */ + char *ArgString /* In */ + ) +{ + int i, r; + IN_INIT(); + IN_VAL(UDIInt, NumberOfRanges); + for (i=0; i<NumberOfRanges; i++) + { + IN_VAL(short, ProcessMemory[i].Space); + IN_VAL(CPUOffset, ProcessMemory[i].Offset); + IN_VAL(CPUSizeT, ProcessMemory[i].Size); + } + IN_VAL(short, EntryPoint.Space); + IN_VAL(CPUOffset, EntryPoint.Offset); + IN_VAL(UDIInt, NumberOfStacks); + for (i=0; i<NumberOfStacks; i++) + IN_VAL(CPUSizeT, StackSizes[i]); + IN_DATA(ArgString, strlen(ArgString)+1); + + return DO_CALL(UDIInitializeProcess_c); +} + +UDIError UDIRead ( + UDIResource From, /* In */ + UDIHostMemPtr To, /* Out */ + UDICount Count, /* In */ + UDISizeT Size, /* In */ + UDICount *CountDone, /* Out */ + UDIBool HostEndian /* In */ + ) +{ + int cleft = Count, cthis, dthis; + int cdone = 0, r, bsize=2048/Size; + + while (cleft) + { + cthis = (cleft<bsize) ? cleft : bsize; + IN_INIT(); + IN_VAL(short, From.Space); + IN_VAL(CPUOffset, From.Offset); + IN_VAL(UDICount, cthis); + IN_VAL(UDISizeT, Size); + IN_VAL(UDIBool, HostEndian); + + r = DO_CALL(UDIRead_c); + + OUT_INIT(); + dthis = OUT_VAL(UDICount); + OUT_DATA(To, dthis*Size); + cdone += dthis; + To += dthis*Size; + + if (r != UDINoError) + { + *CountDone = cdone; + return r; + } + cleft -= cthis; + } + *CountDone = cdone; + return UDINoError; +} + +UDIError UDIWrite ( + UDIHostMemPtr From, /* In */ + UDIResource To, /* In */ + UDICount Count, /* In */ + UDISizeT Size, /* In */ + UDICount *CountDone, /* Out */ + UDIBool HostEndian /* In */ + ) +{ + int cleft = Count, cthis, dthis; + int cdone = 0, r, bsize=2048/Size; + + while (cleft) + { + cthis = (cleft<bsize) ? cleft : bsize; + IN_INIT(); + IN_VAL(short, To.Space); + IN_VAL(CPUOffset, To.Offset); + IN_VAL(UDICount, cthis); + IN_VAL(UDISizeT, Size); + IN_VAL(UDIBool, HostEndian); + IN_DATA(From, cthis*Size); + From += cthis*Size; + + r = DO_CALL(UDIWrite_c); + + OUT_INIT(); + cdone += OUT_VAL(UDICount); + + if (r != UDINoError) + { + *CountDone = cdone; + return r; + } + cleft -= cthis; + } + *CountDone = cdone; + return UDINoError; +} + +UDIError UDICopy ( + UDIResource From, /* In */ + UDIResource To, /* In */ + UDICount Count, /* In */ + UDISizeT Size, /* In */ + UDICount *CountDone, /* Out */ + UDIBool Direction /* In */ + ) +{ + int r; + IN_INIT(); + IN_VAL(short, From.Space); + IN_VAL(CPUOffset, From.Offset); + IN_VAL(short, To.Space); + IN_VAL(CPUOffset, To.Offset); + IN_VAL(UDICount, Count); + IN_VAL(UDISizeT, Size); + IN_VAL(UDIBool, Direction); + + r = DO_CALL(UDICopy_c); + + OUT_INIT(); + *CountDone = OUT_VAL(UDICount); + + return r; +} + +UDIError UDIExecute ( + void + ) +{ + return DO_CALL(UDIExecute_c); +} + +UDIError UDIStep ( + UDIUInt32 Steps, /* In */ + UDIStepType StepType, /* In */ + UDIRange Range /* In */ + ) +{ + IN_INIT(); + IN_VAL(UDIUInt32, Steps); + IN_VAL(UDIStepType, StepType); + IN_VAL(UDIRange, Range); + + return DO_CALL(UDIStep_c); +} + +UDIVoid UDIStop ( + void + ) +{ + DO_CALL(UDIStop_c); +} + +UDIError UDIWait ( + UDIInt32 MaxTime, /* In */ + UDIPId *PId, /* Out */ + UDIUInt32 *StopReason /* Out */ + ) +{ + int r; + IN_INIT(); + IN_VAL(UDIInt32, MaxTime); + r = DO_CALL(UDIWait_c); + OUT_INIT(); + *PId = OUT_VAL(UDIPId); + *StopReason = OUT_VAL(UDIUInt32); + return r; +} + +UDIError UDISetBreakpoint ( + UDIResource Addr, /* In */ + UDIInt32 PassCount, /* In */ + UDIBreakType Type, /* In */ + UDIBreakId *BreakId /* Out */ + ) +{ + int r; + IN_INIT(); + IN_VAL(short, Addr.Space); + IN_VAL(CPUOffset, Addr.Offset); + IN_VAL(UDIInt32, PassCount); + IN_VAL(UDIBreakType, Type); + + r = DO_CALL(UDISetBreakpoint_c); + + OUT_INIT(); + *BreakId = OUT_VAL(UDIBreakId); + return r; +} + +UDIError UDIQueryBreakpoint ( + UDIBreakId BreakId, /* In */ + UDIResource *Addr, /* Out */ + UDIInt32 *PassCount, /* Out */ + UDIBreakType *Type, /* Out */ + UDIInt32 *CurrentCount /* Out */ + ) +{ + int r; + IN_INIT(); + IN_VAL(UDIBreakId, BreakId); + + r = DO_CALL(UDIQueryBreakpoint_c); + + OUT_INIT(); + Addr->Space = OUT_VAL(short); + Addr->Offset = OUT_VAL(CPUOffset); + *PassCount = OUT_VAL(UDIInt32); + *Type = OUT_VAL(UDIBreakType); + *CurrentCount = OUT_VAL(UDIInt32); + + return r; +} + +UDIError UDIClearBreakpoint ( + UDIBreakId BreakId /* In */ + ) +{ + IN_INIT(); + IN_VAL(UDIBreakId, BreakId); + + return DO_CALL(UDIClearBreakpoint_c); +} + +UDIError UDIGetStdout ( + UDIHostMemPtr Buf, /* Out */ + UDISizeT BufSize, /* In */ + UDISizeT *CountDone /* Out */ + ) +{ + int r; + IN_INIT(); + if (BufSize > 4000) + BufSize = 4000; + IN_VAL(UDISizeT,BufSize); + r = DO_CALL(UDIGetStdout_c); + OUT_INIT(); + *CountDone = OUT_VAL(UDISizeT); + if (*CountDone <= BufSize) + OUT_DATA(Buf, *CountDone); + return r; +} + +UDIError UDIGetStderr ( + UDIHostMemPtr Buf, /* Out */ + UDISizeT BufSize, /* In */ + UDISizeT *CountDone /* Out */ + ) +{ + int r; + IN_INIT(); + if (BufSize > 4000) + BufSize = 4000; + IN_VAL(UDISizeT,BufSize); + r = DO_CALL(UDIGetStderr_c); + OUT_INIT(); + *CountDone = OUT_VAL(UDISizeT); + OUT_DATA(Buf, *CountDone); + return r; +} + +UDIError UDIPutStdin ( + UDIHostMemPtr Buf, /* In */ + UDISizeT Count, /* In */ + UDISizeT *CountDone /* Out */ + ) +{ + int r; + IN_INIT(); + if (Count > 4000) + Count = 4000; + IN_VAL(UDISizeT,Count); + IN_DATA(Buf, Count); + r = DO_CALL(UDIPutStdin_c); + OUT_INIT(); + *CountDone = OUT_VAL(UDISizeT); + return r; +} + +UDIError UDIStdinMode ( + UDIMode *Mode /* Out */ + ) +{ + int r; + IN_INIT(); + r = DO_CALL(UDIStdinMode_c); + OUT_INIT(); + *Mode = OUT_VAL(UDIMode); + return r; +} + +UDIError UDIPutTrans ( + UDIHostMemPtr Buf, /* In */ + UDISizeT Count, /* In */ + UDISizeT *CountDone /* Out */ + ) +{ + int r; + IN_INIT(); + if (Count > 4000) + Count = 4000; + IN_VAL(UDISizeT,Count); + IN_DATA(Buf, Count); + r = DO_CALL(UDIPutTrans_c); + OUT_INIT(); + *CountDone = OUT_VAL(UDISizeT); + return r; +} + +UDIError UDIGetTrans ( + UDIHostMemPtr Buf, /* Out */ + UDISizeT BufSize, /* In */ + UDISizeT *CountDone /* Out */ + ) +{ + int r; + IN_INIT(); + if (BufSize > 4000) + BufSize = 4000; + IN_VAL(UDISizeT,BufSize); + r = DO_CALL(UDIGetTrans_c); + OUT_INIT(); + *CountDone = OUT_VAL(UDISizeT); + OUT_DATA(Buf, *CountDone); + return r; +} + +UDIError UDITransMode ( + UDIMode *Mode /* Out */ + ) +{ + int r; + IN_INIT(); + r = DO_CALL(UDITransMode_c); + OUT_INIT(); + *Mode = OUT_VAL(UDIMode); + return r; +} + +#define DFEIPCIdCompany 0x0001 /* Company ID AMD */ +#define DFEIPCIdProduct 0x1 /* Product ID 0 */ +#define DFEIPCIdVersion 0x125 /* 1.2.5 */ + +unsigned UDIGetDFEIPCId () +{ + return((((UDIUInt32)DFEIPCIdCompany) << 16) |(DFEIPCIdProduct << 12) | DFEIPCIdVersion); +} + +#endif /* __GO32__ */ diff --git a/gdb/29k-share/udi/udiids.h b/gdb/29k-share/udi/udiids.h new file mode 100644 index 00000000000..5f805e46905 --- /dev/null +++ b/gdb/29k-share/udi/udiids.h @@ -0,0 +1,48 @@ +/* This file contains the DFE and TIP IDs to be used by AMD products for + the UDICapabilities call. + + Copyright 1993 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + + /* Company Codes -- AMD assigns these */ +#define UDICompanyCode_AMD 1 + + /* Build a UDIID given a CompanyProdCode and 3 version pieces */ +#define UDIID(CompanyProdCode, v1,v2,v3) ((((CompanyProdCode) & 0xfffff)<<12)+\ + (((v1)&0xf)<<8) + (((v2)&0xf)<<4) + ((v3)&0xf)) + + + /* Extract a CompanyProdCode or a Version from a UDIID */ +#define UDIID_CompanyProdCode(id) (((id)>>12) & 0xfffff) +#define UDIID_Version(id) ((id)&0xfff) + + +#define UDIAMDProduct(ProdCode) ((UDICompanyCode_AMD<<4) + (ProdCode&0xf)) + + /* AMD DFE Product Codes */ +#define UDIProductCode_Mondfe UDIAMDProduct(0) +#define UDIProductCode_XRAY UDIAMDProduct(1) +#define UDIProductCode_TIPTester UDIAMDProduct(2) + + /* AMD TIP Product Codes (need not be distinct from DFE Product Codes) */ +#define UDIProductCode_Montip UDIAMDProduct(0) +#define UDIProductCode_Isstip UDIAMDProduct(1) + + +#define UDILatestVersion 0x120 /* UDI 1.2.0, can be used in DFE and TIP desired UDI params */ + diff --git a/gdb/29k-share/udi/udip2soc.c b/gdb/29k-share/udi/udip2soc.c new file mode 100644 index 00000000000..969e8502eb4 --- /dev/null +++ b/gdb/29k-share/udi/udip2soc.c @@ -0,0 +1,1250 @@ +/* Copyright 1993 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +static char udip2soc_c[]="@(#)udip2soc.c 2.11 Daniel Mann"; +static char udip2soc_c_AMD[]="@(#)udip2soc.c 2.8, AMD"; +/* +* This module converts UDI Procedural calls into +* UDI socket messages for UNIX. +* It is used by DFE client processes +********************************************************************** HISTORY +*/ +/* This is all unneeded on DOS machines. */ +#ifndef __GO32__ + +#include <stdio.h> +#include <string.h> + +/* Before sys/file.h for Unixware. */ +#include <sys/types.h> + +#include <sys/file.h> + +/* This used to say sys/fcntl.h, but the only systems I know of that + require that are old (pre-4.3, at least) BSD systems, which we + probably don't need to worry about. */ +#include <fcntl.h> + +#include <sys/wait.h> +#include <sys/time.h> +#include <sys/resource.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netdb.h> +#include <signal.h> +#include <sys/errno.h> +#include "udiproc.h" +#include "udisoc.h" + +extern int errno; +extern int sys_nerr; +extern int udr_errno; +extern char* getenv(); + +/* local type decs. and macro defs. not in a .h file ************* MACRO/TYPE +*/ +#define version_c 0x121 /* DFE-IPC version id */ +#define TRUE -1 +#define FALSE 0 +#define PORT_NUM 7000 +#define MAX_SESSIONS 5 /* maximum DFE-TIP connections */ +#define SOC_BUF_SIZE 4* 1024 /* size of socket comms buffer */ +#define SBUF_SIZE 500 /* size of string buffer */ +#define ERRMSG_SIZE 500 /* size of error message buffer */ + +typedef struct connection_str /* record of connect session */ +{ + int in_use; + char connect_id[20]; /* connection identifier */ + char domain_string[20]; /* dommaing for conection */ + char tip_string[30]; /* TIP host name for AF_INET */ + char tip_exe[80]; /* TIP exe name */ + int dfe_sd; /* associated DFE socket */ + int tip_pid; /* pid of TIP process */ + struct sockaddr_in dfe_sockaddr; + struct sockaddr_in tip_sockaddr_in; + struct sockaddr tip_sockaddr; +} connection_t; + +typedef struct session_str +{ + int in_use; + connection_t* soc_con_p; /* associated connection */ + UDISessionId tip_id; /* associated TIP session ID */ +} session_t; + +/* global dec/defs. which are not in a .h file ************* EXPORT DEC/DEFS +*/ +UDIError dfe_errno; +char dfe_errmsg[ERRMSG_SIZE];/* error string */ + +/* local dec/defs. which are not in a .h file *************** LOCAL DEC/DEFS +*/ +LOCAL connection_t soc_con[MAX_SESSIONS]; +LOCAL session_t session[MAX_SESSIONS]; +LOCAL UDR udr; +LOCAL UDR* udrs = &udr; /* UDR for current session */ +LOCAL int current; /* int-id for current session */ +LOCAL char sbuf[SBUF_SIZE]; /* String handler buffer */ +LOCAL char config_file[80]; /* path/name for config file */ + +/***************************************************************** UDI_CONNECT +* Establish a new FDE to TIP conection. The file "./udi_soc" or +* "/etc/udi_soc" may be examined to obtain the conection information +* if the "Config" parameter is not a completd "line entry". +* +* NOTE: the Session string must not start whith white-space characters. +* Format of string is: +* <session> <domain> <soc_name|host_name> <tip_exe|port> <pass to UDIconnect> +* soc2cayman AF_INET cayman 7000 <not supported> +* soc2tip AF_UNIX astring tip.exe ... +*/ +UDIError +UDIConnect(Config, Session) + char *Config; /* in -- identification string */ + UDISessionId *Session; /* out -- session ID */ +{ + UDIInt32 service_id = UDIConnect_c; + int domain; + int cnt=0; + int rcnt, pos, params_pos=0; + char *tip_main_string; + char *env_p; + struct hostent *tip_info_p; + FILE *fd; +#if 0 + FILE *f_p; +#endif + UDIUInt32 TIPIPCId; + UDIUInt32 DFEIPCId; + +#if 0 /* This is crap. It assumes that udi_soc is executable! */ + sprintf(sbuf, "which udi_soc"); + f_p = popen(sbuf, "r"); + if(f_p) + { while( (sbuf[cnt++]=getc(f_p)) != EOF); + sbuf[cnt-2]=0; + } + pclose(f_p); +#endif + + for (rcnt=0; + rcnt < MAX_SESSIONS && session[rcnt].in_use; + rcnt++); + + if (rcnt >= MAX_SESSIONS) + { + sprintf(dfe_errmsg, "DFE-ipc ERROR: Too many sessions already open"); + return UDIErrorIPCLimitation; + } + + /* One connection can be multiplexed between several sessions. */ + + for (cnt=0; + cnt < MAX_SESSIONS && soc_con[cnt].in_use; + cnt++); + + if (cnt >= MAX_SESSIONS) + { + sprintf(dfe_errmsg, + "DFE-ipc ERROR: Too many connections already open"); + return UDIErrorIPCLimitation; + } + + *Session = rcnt; + session[rcnt].soc_con_p = &soc_con[cnt]; + + if (strchr(Config, ' ')) /* test if file entry given */ + { + soc_con[cnt].in_use = TRUE; + sscanf(Config, "%s %s %s %s %n", + soc_con[cnt].connect_id, + soc_con[cnt].domain_string, + soc_con[cnt].tip_string, + soc_con[cnt].tip_exe, + ¶ms_pos); + tip_main_string = Config + params_pos; + } + else /* here if need to read udi_soc file */ + { + strcpy(config_file, "udi_soc"); + env_p = getenv("UDICONF"); + if (env_p) + strcpy(config_file, env_p); + + fd = fopen(config_file, "r"); + + if (!fd) + { + sprintf(dfe_errmsg, "UDIConnect, can't open udi_soc file:\n%s ", + strerror(errno)); + dfe_errno = UDIErrorCantOpenConfigFile; + goto tip_failure; + } + + while (1) + { + if (fscanf(fd, "%s %s %s %s %[^\n]\n", + soc_con[cnt].connect_id, + soc_con[cnt].domain_string, + soc_con[cnt].tip_string, + soc_con[cnt].tip_exe, + sbuf) == EOF) + break; + + if (strcmp(Config, soc_con[cnt].connect_id) != 0) + continue; + + soc_con[cnt].in_use = TRUE; /* here if entry found */ + + tip_main_string = sbuf; + break; + } + + fclose(fd); + if (!soc_con[cnt].in_use) + { + sprintf(dfe_errmsg, + "UDIConnect, can't find `%s' entry in udi_soc file", + Config); + dfe_errno = UDIErrorNoSuchConfiguration; + goto tip_failure; + } + } +/*----------------------------------------------------------- SELECT DOMAIN */ + if (strcmp(soc_con[cnt].domain_string, "AF_UNIX") == 0) + domain = AF_UNIX; + else if (strcmp(soc_con[cnt].domain_string, "AF_INET") == 0) + domain = AF_INET; + else + { + sprintf(dfe_errmsg, "DFE-ipc ERROR: socket address family not known"); + dfe_errno = UDIErrorBadConfigFileEntry; + goto tip_failure; + } + +/*---------------------------------------------------- MULTIPLEXED SOCKET ? */ +/* If the requested session requires communication with + a TIP which already has a socket connection established, + then we do not create a new socket but multiplex the + existing one. A TIP is said to use the same socket if + socket-name/host-name and the domain are the same. + */ + for (rcnt=0; rcnt < MAX_SESSIONS; rcnt++) + { + if (soc_con[rcnt].in_use + && rcnt != cnt + && strcmp(soc_con[cnt].domain_string, + soc_con[rcnt].domain_string) == 0 + && strcmp(soc_con[cnt].tip_string, + soc_con[rcnt].tip_string) == 0) + { + session[*Session].soc_con_p = &soc_con[rcnt]; + soc_con[cnt].in_use = FALSE; /* don't need new connect */ + goto tip_connect; + } + } +/*------------------------------------------------------------------ SOCKET */ + soc_con[cnt].dfe_sd = socket(domain, SOCK_STREAM, 0); + if (soc_con[cnt].dfe_sd == -1) + { + sprintf(dfe_errmsg, "DFE-ipc ERROR, socket() call failed %s ", + strerror (errno)); + dfe_errno = UDIErrorUnknownError; + goto tip_failure; + } + +/*--------------------------------------------------------- AF_UNIX CONNECT */ + if (domain == AF_UNIX) + { + if (strcmp(soc_con[cnt].tip_string, "*") == 0) + { + for (pos = 0; pos < 20; pos++) + { + int f; + + sprintf(soc_con[cnt].tip_string,"/tmp/U%d", getpid() + pos); + f = open(soc_con[cnt].tip_string, O_CREAT); + if (f == -1) + continue; + + close(f); + unlink(soc_con[cnt].tip_string); + break; + } + + if (pos >= 20) + { + sprintf(dfe_errmsg, + "DFE-ipc ERROR, can't create random socket name"); + dfe_errno = UDIErrorCantConnect; + goto tip_failure; + } + } + + soc_con[cnt].tip_sockaddr.sa_family = domain; + memcpy(soc_con[cnt].tip_sockaddr.sa_data, + soc_con[cnt].tip_string, + sizeof(soc_con[cnt].tip_sockaddr.sa_data)); + if (connect(soc_con[cnt].dfe_sd, + &soc_con[cnt].tip_sockaddr, + sizeof(soc_con[cnt].tip_sockaddr))) + { /* if connect() fails assume TIP not yet started */ +/*------------------------------------------------------------ AF_UNIX EXEC */ + int pid; + int statusp; + char *arg0; + + arg0 = strrchr(soc_con[cnt].tip_exe,'/'); + + if (arg0) + arg0++; + else + arg0 = soc_con[cnt].tip_exe; + + pid = vfork(); + + if (pid == 0) /* Child */ + { + execlp(soc_con[cnt].tip_exe, + arg0, + soc_con[cnt].domain_string, + soc_con[cnt].tip_string, + NULL); + _exit(1); + } + + if (waitpid(pid, &statusp, WNOHANG)) + { + sprintf(dfe_errmsg, "DFE-ipc ERROR: can't exec the TIP"); + dfe_errno = UDIErrorCantStartTIP; + goto tip_failure; + } + + pos = 3; + for (pos = 3; pos > 0; pos--) + { + if (!connect(soc_con[cnt].dfe_sd, + &soc_con[cnt].tip_sockaddr, + sizeof(soc_con[cnt].tip_sockaddr))) + break; + sleep(1); + } + + if (pos == 0) + { + sprintf(dfe_errmsg, "DFE-ipc ERROR, connect() call failed: %s", + strerror (errno)); + dfe_errno = UDIErrorCantConnect; + goto tip_failure; + } + } + } +/*--------------------------------------------------------- AF_INET CONNECT */ + else if (domain == AF_INET) + { + fprintf(stderr, + "DFE-ipc WARNING, need to have first started remote TIP"); + + soc_con[cnt].tip_sockaddr_in.sin_family = domain; + soc_con[cnt].tip_sockaddr_in.sin_addr.s_addr = + inet_addr(soc_con[cnt].tip_string); + if (soc_con[cnt].tip_sockaddr_in.sin_addr.s_addr == -1) + { + tip_info_p = gethostbyname(soc_con[cnt].tip_string); + if (tip_info_p == NULL) + { + sprintf(dfe_errmsg,"DFE-ipc ERROR, No such host %s", + soc_con[cnt].tip_string); + dfe_errno = UDIErrorNoSuchConnection; + goto tip_failure; + } + memcpy((char *)&soc_con[cnt].tip_sockaddr_in.sin_addr, + tip_info_p->h_addr, + tip_info_p->h_length); + } + soc_con[cnt].tip_sockaddr_in.sin_port + = htons(atoi(soc_con[cnt].tip_exe)); + + if (connect(soc_con[cnt].dfe_sd, + (struct sockaddr *) &soc_con[cnt].tip_sockaddr_in, + sizeof(soc_con[cnt].tip_sockaddr_in))) + { + sprintf(dfe_errmsg, "DFE-ipc ERROR, connect() call failed %s ", + strerror (errno)); + dfe_errno = UDIErrorCantConnect; + goto tip_failure; + } + } +/*------------------------------------------------------------- TIP CONNECT */ + if (cnt == 0) udr_create(udrs, soc_con[cnt].dfe_sd, SOC_BUF_SIZE); + +tip_connect: + current = cnt; + session[*Session].in_use = TRUE; /* session id is now in use */ + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + + DFEIPCId = (company_c << 16) + (product_c << 12) + version_c; + udr_UDIUInt32(udrs, &DFEIPCId); + + udr_string(udrs, tip_main_string); + + udr_sendnow(udrs); + + udrs->udr_op = UDR_DECODE; /* recv all "out" parameters */ + udr_UDIUInt32(udrs, &TIPIPCId); + if ((TIPIPCId & 0xfff) < version_c) + sprintf(dfe_errmsg, "DFE-ipc: Obsolete TIP Specified"); + + udr_UDIInt32(udrs, &soc_con[cnt].tip_pid); + + udr_UDISessionId(udrs, &session[*Session].tip_id); + + udr_UDIError(udrs, &dfe_errno); + if (dfe_errno > 0) UDIKill(*Session, 0); + + return dfe_errno; + +tip_failure: + + soc_con[cnt].in_use = FALSE; + session[*Session].in_use = FALSE; +/* XXX - Should also close dfe_sd, but not sure what to do if muxed */ + return dfe_errno; +} + +/************************************************************** UDI_Disconnect +* UDIDisconnect() should be called before exiting the +* DFE to ensure proper shut down of the TIP. +*/ +UDIError UDIDisconnect(Session, Terminate) +UDISessionId Session; +UDIBool Terminate; +{ + int cnt; + UDIInt32 service_id = UDIDisconnect_c; + if(Session < 0 || Session > MAX_SESSIONS) + { + sprintf(dfe_errmsg," SessionId not valid (%d)", Session); + return UDIErrorNoSuchConfiguration; + } + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDISessionId(udrs, &session[Session].tip_id); + udr_UDIBool(udrs, &Terminate); + udr_sendnow(udrs); + + session[Session].in_use = FALSE; /* session id is now free */ + for (cnt=0; cnt < MAX_SESSIONS; cnt++) + if(session[cnt].in_use + && session[cnt].soc_con_p == session[Session].soc_con_p + ) break; + if(cnt >= MAX_SESSIONS) /* test if socket not multiplexed */ + if(shutdown(session[Session].soc_con_p->dfe_sd, 2)) + { + sprintf(dfe_errmsg, "DFE-ipc WARNING: socket shutdown failed"); + return UDIErrorIPCInternal; + } + else + session[Session].soc_con_p->in_use = 0; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/******************************************************************** UDI_KILL +* UDIKill() is used to send a signal to the TIP. +* This is a private IPC call. +*/ +UDIError UDIKill(Session, Signal) +UDISessionId Session; +UDIInt32 Signal; +{ + int cnt; + UDIInt32 service_id = UDIKill_c; + if(Session < 0 || Session > MAX_SESSIONS) + { + sprintf(dfe_errmsg," SessionId not valid (%d)", Session); + return UDIErrorNoSuchConfiguration; + } + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDISessionId(udrs, &session[Session].tip_id); + udr_UDIInt32(udrs, &Signal); + udr_sendnow(udrs); + + session[Session].in_use = FALSE; /* session id is now free */ + for (cnt=0; cnt < MAX_SESSIONS; cnt++) + if(session[cnt].in_use + && session[cnt].soc_con_p == session[Session].soc_con_p + ) break; + if(cnt < MAX_SESSIONS) /* test if socket not multiplexed */ + if(shutdown(session[Session].soc_con_p->dfe_sd, 2)) + { + sprintf(dfe_errmsg, "DFE-ipc WARNING: socket shutdown failed"); + return UDIErrorIPCInternal; + } + else + session[Session].soc_con_p->in_use = 0; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/************************************************** UDI_Set_Current_Connection +* If you are connected to multiple TIPs, you can change +* TIPs using UDISetCurrentConnection(). +*/ +UDIError UDISetCurrentConnection(Session) +UDISessionId Session; +{ + UDIInt32 service_id = UDISetCurrentConnection_c; + + if(Session < 0 || Session > MAX_SESSIONS) + return UDIErrorNoSuchConfiguration; + if(!session[Session].in_use) /* test if not in use yet */ + return UDIErrorNoSuchConnection; + + current = Session; + /* change socket or multiplex the same socket */ + udrs->sd = session[Session].soc_con_p->dfe_sd; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDISessionId(udrs, &session[Session].tip_id); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/************************************************************ UDI_Capabilities +* The DFE uses UDICapabilities() to both inform the TIP +* of what services the DFE offers and to inquire of the +* TIP what services the TIP offers. +*/ +UDIError UDICapabilities(TIPId, TargetId, DFEId, DFE, TIP, DFEIPCId, + TIPIPCId, TIPString) +UDIUInt32 *TIPId; /* out */ +UDIUInt32 *TargetId; /* out */ +UDIUInt32 DFEId; /* in */ +UDIUInt32 DFE; /* in */ +UDIUInt32 *TIP; /* out */ +UDIUInt32 *DFEIPCId; /* out */ +UDIUInt32 *TIPIPCId; /* out */ +char *TIPString; /* out */ +{ + UDIInt32 service_id = UDICapabilities_c; + int size; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDIInt32(udrs, &DFEId); + udr_UDIInt32(udrs, &DFE); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */ + udr_UDIInt32(udrs, TIPId); + udr_UDIInt32(udrs, TargetId); + udr_UDIInt32(udrs, TIP); + udr_UDIInt32(udrs, DFEIPCId); + *DFEIPCId = (company_c << 16) + (product_c << 12) + version_c; + udr_UDIInt32(udrs, TIPIPCId); + udr_string(udrs, sbuf); + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + size = strlen(sbuf); + if(size +1 > 80) return -1; /* test if sufficient space */ + strcpy(TIPString, sbuf); + return dfe_errno; +} + +/********************************************************** UDI_Enumerate_TIPs +* Used by the DFE to enquire about available TIP +* connections. +*/ +UDIError UDIEnumerateTIPs(UDIETCallback) + int (*UDIETCallback)(); /* In -- function to callback */ +{ + FILE *fp; + + fp = fopen(config_file, "r"); + if(fp == NULL) + return UDIErrorCantOpenConfigFile; + while(fgets( sbuf, SBUF_SIZE, fp)) + if(UDIETCallback( sbuf) == UDITerminateEnumeration) + break; + fclose( fp); + return UDINoError; /* return success */ +} + +/*********************************************************** UDI_GET_ERROR_MSG +* Some errors are target specific. They are indicated +* by a negative error return value. The DFE uses +* UDIGetErrorMsg() to get the descriptive text for +* the error message which can then be displayed to +* the user. +*/ +UDIError UDIGetErrorMsg(error_code, msg_len, msg, CountDone) +UDIError error_code; /* In */ +UDISizeT msg_len; /* In -- allowed message space */ +char* msg; /* Out -- length of message*/ +UDISizeT *CountDone; /* Out -- number of characters */ +{ + UDIInt32 service_id = UDIGetErrorMsg_c; + int size; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDIError(udrs, &error_code); + udr_UDISizeT(udrs, &msg_len); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_string(udrs, sbuf); + udr_UDISizeT(udrs, CountDone); + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + size = strlen(sbuf); + if(size +1 > msg_len) return -1; /* test if sufficient space */ + strcpy(msg, sbuf); + return dfe_errno; +} + +/******************************************************* UDI_GET_TARGET_CONFIG +* UDIGetTargetConfig() gets information about the target. +*/ +UDIError UDIGetTargetConfig(KnownMemory, NumberOfRanges, ChipVersions, + NumberOfChips) +UDIMemoryRange KnownMemory[]; /* Out */ +UDIInt *NumberOfRanges; /* In and Out */ +UDIUInt32 ChipVersions[]; /* Out */ +UDIInt *NumberOfChips; /* In and Out */ +{ + UDIInt32 service_id = UDIGetTargetConfig_c; + int cnt; + int MaxOfRanges = *NumberOfRanges; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDIInt(udrs, NumberOfRanges); + udr_UDIInt(udrs, NumberOfChips); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */ + for(cnt=1; cnt <= MaxOfRanges; cnt++) + udr_UDIMemoryRange(udrs, &KnownMemory[cnt-1]); + udr_UDIInt(udrs, NumberOfRanges); + udr_UDIInt(udrs, NumberOfChips); + for(cnt=1; cnt <= *NumberOfChips; cnt++) + udr_UDIUInt32(udrs, &ChipVersions[cnt -1]); + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/********************************************************** UDI_CREATE_PRCOESS +* UDICreateProcess() tells the target OS that a +* process is to be created and gets a PID back unless +* there is some error. +*/ +UDIError UDICreateProcess(pid) +UDIPId *pid; /* out */ +{ + UDIInt32 service_id = UDICreateProcess_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDIPId(udrs, pid); + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/***************************************************** UDI_Set_Current_Process +* UDISetCurrentProcess uses a pid supplied by +* UDICreateProcess and sets it as the default for all +* udi calls until a new one is set. A user of a +*/ +UDIError UDISetCurrentProcess (pid) +UDIPId pid; /* In */ +{ + UDIInt32 service_id = UDISetCurrentProcess_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDIPId(udrs, &pid); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/****************************************************** UDI_INITIALISE_PROCESS +* UDIInitializeProcess() prepare process for +* execution. (Reset processor if process os processor). +*/ +UDIError UDIInitializeProcess( ProcessMemory, NumberOfRanges, EntryPoint, + StackSizes, NumberOfStacks, ArgString) +UDIMemoryRange ProcessMemory[]; /* In */ +UDIInt NumberOfRanges; /* In */ +UDIResource EntryPoint; /* In */ +CPUSizeT *StackSizes; /* In */ +UDIInt NumberOfStacks; /* In */ +char *ArgString; /* In */ +{ + UDIInt32 service_id = UDIInitializeProcess_c; + int cnt; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDIInt(udrs, &NumberOfRanges); + for(cnt = 0; cnt < NumberOfRanges; cnt++) + udr_UDIMemoryRange(udrs, &ProcessMemory[cnt] ); + udr_UDIResource(udrs, &EntryPoint); + udr_UDIInt(udrs, &NumberOfStacks); + for(cnt = 0; cnt < NumberOfStacks; cnt++) + udr_CPUSizeT(udrs, &StackSizes[cnt]); + udr_string(udrs, ArgString); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/********************************************************* UDI_DESTROY_PROCESS +* UDIDestroyProcess() frees a process resource +* previously created by UDICreateProcess(). +*/ +UDIError UDIDestroyProcess(pid) +UDIPId pid; /* in */ +{ + UDIInt32 service_id = UDIDestroyProcess_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDIPId(udrs, &pid); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/****************************************************************** UDI_READ +* UDIRead() reads a block of objects from a target +* address space to host space. +*/ + +UDIError UDIRead (from, to, count, size, count_done, host_endian) +UDIResource from; /* in - source address on target */ +UDIHostMemPtr to; /* out - destination address on host */ +UDICount count; /* in -- count of objects to be transferred */ +UDISizeT size; /* in -- size of each object */ +UDICount *count_done; /* out - count actually transferred */ +UDIBool host_endian; /* in -- flag for endian information */ +{ + UDIInt32 service_id = UDIRead_c; + int byte_count; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDIResource(udrs, &from); + udr_UDICount(udrs, &count); + udr_UDISizeT(udrs, &size); + udr_UDIBool(udrs, &host_endian); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */ + udr_UDICount(udrs, count_done); + byte_count = (*count_done) * size; + if(*count_done > 0 && *count_done <= count) + udr_bytes(udrs, to, byte_count); + if(udr_errno) return udr_errno; + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/****************************************************************** UDI_WRITE +* UDIWrite() writes a block of objects from host +* space to a target address+space. +*/ +UDIError UDIWrite( from, to, count, size, count_done, host_endian ) +UDIHostMemPtr from; /* in -- source address on host */ +UDIResource to; /* in -- destination address on target */ +UDICount count; /* in -- count of objects to be transferred */ +UDISizeT size; /* in -- size of each object */ +UDICount *count_done; /* out - count actually transferred */ +UDIBool host_endian; /* in -- flag for endian information */ +{ + UDIInt32 service_id = UDIWrite_c; + int byte_count = count * size; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDIResource(udrs, &to); + udr_UDICount(udrs, &count); + udr_UDISizeT(udrs, &size); + udr_UDIBool(udrs, &host_endian); + udr_bytes(udrs, from, byte_count); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */ + udr_UDICount(udrs, count_done); + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/******************************************************************** UDI_COPY +* UDICopy() copies a block of objects from one target +* get address/space to another target address/space. +*/ +UDIError UDICopy(from, to, count, size, count_done, direction ) +UDIResource from; /* in -- destination address on target */ +UDIResource to; /* in -- source address on target */ +UDICount count; /* in -- count of objects to be transferred */ +UDISizeT size; /* in -- size of each object */ +UDICount *count_done; /* out - count actually transferred */ +UDIBool direction; /* in -- high-to-low or reverse */ +{ + UDIInt32 service_id = UDICopy_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDIResource(udrs, &from); + udr_UDIResource(udrs, &to); + udr_UDICount(udrs, &count); + udr_UDISizeT(udrs, &size); + udr_UDIBool(udrs, &direction); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDICount(udrs, count_done); + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/***************************************************************** UDI_EXECUTE +* UDIExecute() continues execution of the default +* process from the current PC. +*/ +UDIError UDIExecute() +{ + UDIInt32 service_id = UDIExecute_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/******************************************************************** UDI_STEP +* UDIStep() specifies a number of "instruction" +* steps to make. +*/ +UDIError UDIStep(steps, steptype, range) +UDIUInt32 steps; /* in -- number of steps */ +UDIStepType steptype; /* in -- type of stepping to be done */ +UDIRange range; /* in -- range if StepInRange is TRUE */ +{ + UDIInt32 service_id = UDIStep_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDIInt32(udrs, &steps); + udr_UDIStepType(udrs, &steptype); + udr_UDIRange(udrs, &range); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/******************************************************************** UDI_STOP +* UDIStop() stops the default process +*/ +UDIVoid UDIStop() +{ + if (strcmp(session[current].soc_con_p->domain_string, "AF_UNIX") == 0) + kill(session[current].soc_con_p->tip_pid, SIGINT); + else + udr_signal(udrs); + +/* XXX - should clean up session[] and soc_con[] structs here as well... */ + + return; +} + +/******************************************************************** UDI_WAIT +* UDIWait() returns the state of the target procesor. +*/ +UDIError UDIWait(maxtime, pid, stop_reason) +UDIInt32 maxtime; /* in -- maximum time to wait for completion */ +UDIPId *pid; /* out -- pid of process which stopped if any */ +UDIUInt32 *stop_reason; /* out -- PC where process stopped */ +{ + UDIInt32 service_id = UDIWait_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDIInt32(udrs, &maxtime); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDIPId(udrs, pid); + udr_UDIUInt32(udrs, stop_reason); + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/********************************************************** UDI_SET_BREAKPOINT +* UDISetBreakpoint() sets a breakpoint at an adress +* and uses the passcount to state how many +* times that instruction should be hit before the +* break occurs. +*/ +UDIError UDISetBreakpoint (addr, passcount, type, break_id) +UDIResource addr; /* in -- where breakpoint gets set */ +UDIInt32 passcount; /* in -- passcount for breakpoint */ +UDIBreakType type; /* in -- breakpoint type */ +UDIBreakId *break_id; /* out - assigned break id */ +{ + UDIInt32 service_id = UDISetBreakpoint_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDIResource(udrs, &addr); + udr_UDIInt32(udrs, &passcount); + udr_UDIBreakType(udrs, &type); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDIBreakId(udrs, break_id); + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/******************************************************** UDI_QUERY_BREAKPOINT +*/ +UDIError UDIQueryBreakpoint (break_id, addr, passcount, type, current_count) +UDIBreakId break_id; /* in -- assigned break id */ +UDIResource *addr; /* out - where breakpoint was set */ +UDIInt32 *passcount; /* out - trigger passcount for breakpoint */ +UDIBreakType *type; /* out - breakpoint type */ +UDIInt32 *current_count; /* out - current count for breakpoint */ +{ + UDIInt32 service_id = UDIQueryBreakpoint_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDIBreakId(udrs, &break_id); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDIResource(udrs, addr); + udr_UDIInt32(udrs, passcount); + udr_UDIBreakType(udrs, type); + udr_UDIInt32(udrs, current_count); + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/******************************************************** UDI_CLEAR_BREAKPOINT +* UDIClearBreakpoint() is used to clear a breakpoint. +*/ +UDIError UDIClearBreakpoint (break_id) +UDIBreakId break_id; /* in -- assigned break id */ +{ + UDIInt32 service_id = UDIClearBreakpoint_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDIBreakId(udrs, &break_id); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/************************************************************** UDI_GET_STDOUT +* UDIGetStdout() is called when a call to +* UDIWait() indicates there is STD output data ready. +*/ +UDIError UDIGetStdout(buf, bufsize, count_done) +UDIHostMemPtr buf; /* out -- buffer to be filled */ +UDISizeT bufsize; /* in -- buffer size in bytes */ +UDISizeT *count_done; /* out -- number of bytes written to buf */ +{ + UDIInt32 service_id = UDIGetStdout_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDISizeT(udrs, &bufsize); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDISizeT(udrs, count_done); + udr_bytes(udrs, buf, *count_done); + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/************************************************************** UDI_GET_STDERR +* UDIGetStderr() is called when a call to +* UDIWait() indicates there is STDERR output data ready +*/ +UDIError UDIGetStderr(buf, bufsize, count_done) +UDIHostMemPtr buf; /* out -- buffer to be filled */ +UDISizeT bufsize; /* in -- buffer size in bytes */ +UDISizeT *count_done; /* out -- number of bytes written to buf */ +{ + UDIInt32 service_id = UDIGetStderr_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDISizeT(udrs, &bufsize); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDISizeT(udrs, count_done); + udr_bytes(udrs, buf, *count_done); + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/*************************************************************** UDI_PUT_STDIN +* UDIPutStdin() is called whenever the DFE wants to +* deliver an input character to the TIP. +*/ +UDIError UDIPutStdin (buf, count, count_done) +UDIHostMemPtr buf; /* in -- buffer to be filled */ +UDISizeT count; /* in -- buffer size in bytes */ +UDISizeT *count_done; /* out - number of bytes written to buf */ +{ + UDIInt32 service_id = UDIPutStdin_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDISizeT(udrs, &count); + udr_bytes(udrs, buf, count); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDISizeT(udrs, count_done); + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/************************************************************** UDI_STDIN_MODE +* UDIStdinMode() is used to change the mode that chazcters +* are fetched from the user. +*/ +UDIError UDIStdinMode(mode) +UDIMode *mode; /* out - */ +{ + UDIInt32 service_id = UDIStdinMode_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDIMode(udrs, mode); + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/*************************************************************** UDI_PUT_TRANS +* UDIPutTrans() is used to feed input to the passthru mode. +*/ +UDIError UDIPutTrans (buf, count, count_done) +UDIHostMemPtr buf; /* in -- buffer address containing input data */ +UDISizeT count; /* in -- number of bytes in buf */ +UDISizeT *count_done; /* out-- number of bytes transfered */ +{ + UDIInt32 service_id = UDIPutTrans_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDISizeT(udrs, &count); + udr_bytes(udrs, buf, count); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDISizeT(udrs, count_done); + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/*************************************************************** UDI_GET_TRANS +* UDIGetTrans() is used to get output lines from the +* passthru mode. +*/ +UDIError UDIGetTrans (buf, bufsize, count_done) +UDIHostMemPtr buf; /* out -- buffer to be filled */ +UDISizeT bufsize; /* in -- size of buf */ +UDISizeT *count_done; /* out -- number of bytes in buf */ +{ + UDIInt32 service_id = UDIGetTrans_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDISizeT(udrs, &bufsize); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDISizeT(udrs, count_done); + udr_bytes(udrs, buf, *count_done); + udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ + return dfe_errno; +} + +/************************************************************** UDI_Trans_Mode +* UDITransMode() is used to change the mode that the +* transparent routines operate in. +*/ +UDIError UDITransMode(mode) +UDIMode *mode; /* out -- selected mode */ +{ + UDIInt32 service_id = UDITransMode_c; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + udr_UDIMode(udrs, mode); + udr_sendnow(udrs); + if(udr_errno) return udr_errno; + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + udr_UDIError(udrs, &dfe_errno); + return dfe_errno; +} + +/******************************************************************** UDI_TEST +*/ +UDIError UDITest( cnt, str_p, array) +UDISizeT cnt; +UDIHostMemPtr str_p; +UDIInt32 array[]; +{ + UDIInt32 service_id = UDITest_c; + UDIInt16 scnt = cnt; + UDISizeT r_cnt; + char buf[256]; + + udr_errno = 0; + udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ + udr_UDIInt32(udrs, &service_id); + + printf("send cnt=%d scnt=%d\n", cnt, scnt); + udr_UDISizeT(udrs, &cnt); + udr_UDIInt16(udrs, &scnt); + printf(" array[0]=0x%x array[1]=0x%x array[2]=0x%x array[3]=0x%x\n", + array[0], array[1], array[2], array[3]); + udr_bytes(udrs, (char*)array, 4*sizeof(UDIInt32)); + printf(" string=%s\n", str_p); + udr_string(udrs, str_p); + udr_sendnow(udrs); + if(udr_errno) + { fprintf(stderr, " DFE-ipc Send ERROR\n"); + return udr_errno; + } + + udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ + printf("recv "); + udr_UDISizeT(udrs, &r_cnt); + udr_UDIInt16(udrs, &scnt); + printf(" rcnt=%d scnt=%d\n", r_cnt, scnt); + udr_bytes(udrs, (char*)array, 4*sizeof(UDIInt32)); + + printf(" array[0]=0x%x array[1]=0x%x array[2]=0x%x array[3]=0x%x\n", + array[0], array[1], array[2], array[3]); + udr_string(udrs, str_p); + printf(" string=%s\n", str_p); + + udr_UDIError(udrs, &dfe_errno); + return dfe_errno; +} + + + +UDIUInt32 UDIGetDFEIPCId() +{ + return ((company_c << 16) + (product_c << 12) + version_c); +} +#endif /* __GO32__ */ diff --git a/gdb/29k-share/udi/udiphcfg.h b/gdb/29k-share/udi/udiphcfg.h new file mode 100644 index 00000000000..e9eff0a3c86 --- /dev/null +++ b/gdb/29k-share/udi/udiphcfg.h @@ -0,0 +1,44 @@ +/* This file just picks the correct udiphxxx.h depending on the host. + The two hosts that are now defined are UNIX and MSDOS. + + Copyright 1993 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +/* + * For the moment, we will default to BSD_IPC; this might change if/when + * another type of IPC (Mach? SysV?) is implemented. + */ + +#if 0 + +/* We don't seem to have a copy of udiphdos.h. Furthermore, all the + things in udiphunix.h are pretty much generic 32-bit machine defines + which don't have anything to do with IPC. */ + +#ifdef DOS_IPC +#include "udiphdos.h" +#else +/*#ifdef BSD_IPC */ +#include "udiphunix.h" +#endif + +#else + +#include "udiphunix.h" + +#endif diff --git a/gdb/29k-share/udi/udiphunix.h b/gdb/29k-share/udi/udiphunix.h new file mode 100644 index 00000000000..172fbbfd85b --- /dev/null +++ b/gdb/29k-share/udi/udiphunix.h @@ -0,0 +1,81 @@ +/* Originally called "udiphsun.h", however it was not very + Sun-specific; now it is used for generic-unix-with-bsd-ipc. + + Copyright 1993 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +/* This file is to be used to reconfigure the UDI Procedural interface + for a given host. This file should be placed so that it will be + included from udiproc.h. Everything in here may need to be changed + when you change either the host CPU or its compiler. Nothing in + here should change to support different targets. There are multiple + versions of this file, one for each of the different host/compiler + combinations in use. +*/ + +#define UDIStruct struct /* _packed not needed on unix */ +/* First, we need some types */ +/* Types with at least the specified number of bits */ +typedef double UDIReal64; /* 64-bit real value */ +typedef float UDIReal32; /* 32-bit real value */ + +typedef unsigned long UDIUInt32; /* unsigned integers */ +typedef unsigned short UDIUInt16; +typedef unsigned char UDIUInt8; + +typedef long UDIInt32; /* 32-bit integer */ +typedef short UDIInt16; /* 16-bit integer */ +typedef char UDIInt8; /* unreliable signedness */ + +/* To aid in supporting environments where the DFE and TIP use +different compilers or hosts (like DOS 386 on one side, 286 on the +other, or different Unix machines connected by sockets), we define +two abstract types - UDIInt and UDISizeT. +UDIInt should be defined to be int except for host/compiler combinations +that are intended to talk to existing UDI components that have a different +sized int. Similarly for UDISizeT. +*/ +typedef int UDIInt; +typedef unsigned int UDIUInt; + +typedef unsigned int UDISizeT; + +/* Now two void types. The first is for function return types, +the other for pointers to no particular type. Since these types +are used solely for documentational clarity, if your host/compiler +doesn't support either one, replace them with int and char * +respectively. +*/ +typedef void UDIVoid; /* void type */ +typedef void * UDIVoidPtr; /* void pointer type */ +typedef void * UDIHostMemPtr; /* Arbitrary memory pointer */ + +/* Now we want a type optimized for boolean values. Normally this + would be int, but on some machines (Z80s, 8051s, etc) it might + be better to map it onto a char +*/ +typedef int UDIBool; + +/* Now indicate whether your compiler support full ANSI style + prototypes. If so, use #if 1. If not use #if 0. +*/ +#if 0 +#define UDIParams(x) x +#else +#define UDIParams(x) () +#endif diff --git a/gdb/29k-share/udi/udiproc.h b/gdb/29k-share/udi/udiproc.h new file mode 100644 index 00000000000..0cc1c2049c1 --- /dev/null +++ b/gdb/29k-share/udi/udiproc.h @@ -0,0 +1,308 @@ +/* local type decs. and macro defs. + + Copyright 1993 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#include "udiphcfg.h" /* Get host specific configuration */ +#include "udiptcfg.h" /* Get target specific configuration */ + +/* Here are all of the CPU Families for which UDI is currently defined */ +#define Am29K 1 /* AMD's Am290xx and Am292xx parts */ + +typedef UDIInt UDIError; +typedef UDIInt UDISessionId; +typedef UDIInt UDIPId; +typedef UDIInt UDIStepType; +typedef UDIInt UDIBreakType; +typedef UDIUInt UDIBreakId; +typedef UDIUInt UDIMode; + +typedef UDIStruct +{ + CPUSpace Space; + CPUOffset Offset; +} UDIResource; + +typedef UDIStruct +{ + CPUOffset Low; + CPUOffset High; +} UDIRange; + +typedef UDIStruct +{ + CPUSpace Space; + CPUOffset Offset; + CPUSizeT Size; + } UDIMemoryRange; + +/* Values for UDIStepType parameters */ +#define UDIStepNatural 0x0000 +#define UDIStepOverTraps 0x0001 +#define UDIStepOverCalls 0x0002 +#define UDIStepInRange 0x0004 +#define UDIStepNatural 0x0000 + +/* Values for UDIBreakType parameters */ +#define UDIBreakFlagExecute 0x0001 +#define UDIBreakFlagRead 0x0002 +#define UDIBreakFlagWrite 0x0004 +#define UDIBreakFlagFetch 0x0008 + +/* Special values for UDIWait MaxTime parameter */ +#define UDIWaitForever (UDIInt32) -1 /* Infinite time delay */ + +/* Special values for PId */ +#define UDIProcessProcessor -1 /* Raw Hardware, if possible */ + +/* Values for UDIWait StopReason */ +#define UDIGrossState 0xff +#define UDITrapped 0 /* Fine state - which trap */ +#define UDINotExecuting 1 +#define UDIRunning 2 +#define UDIStopped 3 +#define UDIWarned 4 +#define UDIStepped 5 +#define UDIWaiting 6 +#define UDIHalted 7 +#define UDIStdoutReady 8 /* fine state - size */ +#define UDIStderrReady 9 /* fine state - size */ +#define UDIStdinNeeded 10 /* fine state - size */ +#define UDIStdinModeX 11 /* fine state - mode */ +#define UDIBreak 12 /* Fine state - Breakpoint Id */ +#define UDIExited 13 /* Fine state - exit code */ + +/* Enumerate the return values from the callback function + for UDIEnumerateTIPs. +*/ +#define UDITerminateEnumeration 0 +#define UDIContinueEnumeration 1 + +/* Enumerate values for Terminate parameter to UDIDisconnect */ +#define UDITerminateSession 1 +#define UDIContinueSession 0 + +/* Error codes */ +#define UDINoError 0 /* No error occured */ +#define UDIErrorNoSuchConfiguration 1 +#define UDIErrorCantHappen 2 +#define UDIErrorCantConnect 3 +#define UDIErrorNoSuchConnection 4 +#define UDIErrorNoConnection 5 +#define UDIErrorCantOpenConfigFile 6 +#define UDIErrorCantStartTIP 7 +#define UDIErrorConnectionUnavailable 8 +#define UDIErrorTryAnotherTIP 9 +#define UDIErrorExecutableNotTIP 10 +#define UDIErrorInvalidTIPOption 11 +#define UDIErrorCantDisconnect 12 +#define UDIErrorUnknownError 13 +#define UDIErrorCantCreateProcess 14 +#define UDIErrorNoSuchProcess 15 +#define UDIErrorUnknownResourceSpace 16 +#define UDIErrorInvalidResource 17 +#define UDIErrorUnsupportedStepType 18 +#define UDIErrorCantSetBreakpoint 19 +#define UDIErrorTooManyBreakpoints 20 +#define UDIErrorInvalidBreakId 21 +#define UDIErrorNoMoreBreakIds 22 +#define UDIErrorUnsupportedService 23 +#define UDIErrorTryAgain 24 +#define UDIErrorIPCLimitation 25 +#define UDIErrorIncomplete 26 +#define UDIErrorAborted 27 +#define UDIErrorTransDone 28 +#define UDIErrorCantAccept 29 +#define UDIErrorTransInputNeeded 30 +#define UDIErrorTransModeX 31 +#define UDIErrorInvalidSize 32 +#define UDIErrorBadConfigFileEntry 33 +#define UDIErrorIPCInternal 34 +/* TBD */ + +/****************************************************************** PROCEDURES +*/ + +UDIError UDIConnect UDIParams(( + char *Configuration, /* In */ + UDISessionId *Session /* Out */ + )); + +UDIError UDIDisconnect UDIParams(( + UDISessionId Session, /* In */ + UDIBool Terminate /* In */ + )); + +UDIError UDISetCurrentConnection UDIParams(( + UDISessionId Session /* In */ + )); + +UDIError UDICapabilities UDIParams(( + UDIUInt32 *TIPId, /* Out */ + UDIUInt32 *TargetId, /* Out */ + UDIUInt32 DFEId, /* In */ + UDIUInt32 DFE, /* In */ + UDIUInt32 *TIP, /* Out */ + UDIUInt32 *DFEIPCId, /* Out */ + UDIUInt32 *TIPIPCId, /* Out */ + char *TIPString /* Out */ + )); + +UDIError UDIEnumerateTIPs UDIParams(( + UDIInt (*UDIETCallback) /* In */ + UDIParams(( char *Configuration )) /* In to callback() */ + )); + +UDIError UDIGetErrorMsg UDIParams(( + UDIError ErrorCode, /* In */ + UDISizeT MsgSize, /* In */ + char *Msg, /* Out */ + UDISizeT *CountDone /* Out */ + )); + +UDIError UDIGetTargetConfig UDIParams(( + UDIMemoryRange KnownMemory[], /* Out */ + UDIInt *NumberOfRanges, /* In/Out */ + UDIUInt32 ChipVersions[], /* Out */ + UDIInt *NumberOfChips /* In/Out */ + )); + +UDIError UDICreateProcess UDIParams(( + UDIPId *PId /* Out */ + )); + +UDIError UDISetCurrentProcess UDIParams(( + UDIPId PId /* In */ + )); + +UDIError UDIDestroyProcess UDIParams(( + UDIPId PId /* In */ + )); + +UDIError UDIInitializeProcess UDIParams(( + UDIMemoryRange ProcessMemory[], /* In */ + UDIInt NumberOfRanges, /* In */ + UDIResource EntryPoint, /* In */ + CPUSizeT StackSizes[], /* In */ + UDIInt NumberOfStacks, /* In */ + char *ArgString /* In */ + )); + +UDIError UDIRead UDIParams(( + UDIResource From, /* In */ + UDIHostMemPtr To, /* Out */ + UDICount Count, /* In */ + UDISizeT Size, /* In */ + UDICount *CountDone, /* Out */ + UDIBool HostEndian /* In */ + )); + +UDIError UDIWrite UDIParams(( + UDIHostMemPtr From, /* In */ + UDIResource To, /* In */ + UDICount Count, /* In */ + UDISizeT Size, /* In */ + UDICount *CountDone, /* Out */ + UDIBool HostEndian /* In */ + )); + +UDIError UDICopy UDIParams(( + UDIResource From, /* In */ + UDIResource To, /* In */ + UDICount Count, /* In */ + UDISizeT Size, /* In */ + UDICount *CountDone, /* Out */ + UDIBool Direction /* In */ + )); + +UDIError UDIExecute UDIParams(( + void + )); + +UDIError UDIStep UDIParams(( + UDIUInt32 Steps, /* In */ + UDIStepType StepType, /* In */ + UDIRange Range /* In */ + )); + +UDIVoid UDIStop UDIParams(( + void + )); + +UDIError UDIWait UDIParams(( + UDIInt32 MaxTime, /* In */ + UDIPId *PId, /* Out */ + UDIUInt32 *StopReason /* Out */ + )); + +UDIError UDISetBreakpoint UDIParams(( + UDIResource Addr, /* In */ + UDIInt32 PassCount, /* In */ + UDIBreakType Type, /* In */ + UDIBreakId *BreakId /* Out */ + )); + +UDIError UDIQueryBreakpoint UDIParams(( + UDIBreakId BreakId, /* In */ + UDIResource *Addr, /* Out */ + UDIInt32 *PassCount, /* Out */ + UDIBreakType *Type, /* Out */ + UDIInt32 *CurrentCount /* Out */ + )); + +UDIError UDIClearBreakpoint UDIParams(( + UDIBreakId BreakId /* In */ + )); + +UDIError UDIGetStdout UDIParams(( + UDIHostMemPtr Buf, /* Out */ + UDISizeT BufSize, /* In */ + UDISizeT *CountDone /* Out */ + )); + +UDIError UDIGetStderr UDIParams(( + UDIHostMemPtr Buf, /* Out */ + UDISizeT BufSize, /* In */ + UDISizeT *CountDone /* Out */ + )); + +UDIError UDIPutStdin UDIParams(( + UDIHostMemPtr Buf, /* In */ + UDISizeT Count, /* In */ + UDISizeT *CountDone /* Out */ + )); + +UDIError UDIStdinMode UDIParams(( + UDIMode *Mode /* Out */ + )); + +UDIError UDIPutTrans UDIParams(( + UDIHostMemPtr Buf, /* In */ + UDISizeT Count, /* In */ + UDISizeT *CountDone /* Out */ + )); + +UDIError UDIGetTrans UDIParams(( + UDIHostMemPtr Buf, /* Out */ + UDISizeT BufSize, /* In */ + UDISizeT *CountDone /* Out */ + )); + +UDIError UDITransMode UDIParams(( + UDIMode *Mode /* Out */ + )); diff --git a/gdb/29k-share/udi/udipt29k.h b/gdb/29k-share/udi/udipt29k.h new file mode 100644 index 00000000000..5de2f3ff860 --- /dev/null +++ b/gdb/29k-share/udi/udipt29k.h @@ -0,0 +1,87 @@ +/* This file is to be used to reconfigure the UDI Procedural interface + for a given target. + + Copyright 1993 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +/* This file should be placed so that it will be + included from udiproc.h. Everything in here will probably need to + be changed when you change the target processor. Nothing in here + should need to change when you change hosts or compilers. +*/ + +/* Select a target CPU Family */ +#define TargetCPUFamily Am29K + +/* Enumerate the processor specific values for Space in a resource */ +#define UDI29KDRAMSpace 0 +#define UDI29KIOSpace 1 +#define UDI29KCPSpace0 2 +#define UDI29KCPSpace1 3 +#define UDI29KIROMSpace 4 +#define UDI29KIRAMSpace 5 +#define UDI29KLocalRegs 8 +#define UDI29KGlobalRegs 9 +#define UDI29KRealRegs 10 +#define UDI29KSpecialRegs 11 +#define UDI29KTLBRegs 12 /* Not Am29005 */ +#define UDI29KACCRegs 13 /* Am29050 only */ +#define UDI29KICacheSpace 14 /* Am2903x only */ +#define UDI29KAm29027Regs 15 /* When available */ +#define UDI29KPC 16 +#define UDI29KDCacheSpace 17 /* When available */ + +/* Enumerate the Co-processor registers */ +#define UDI29KCP_F 0 +#define UDI29KCP_Flag 8 +#define UDI29KCP_I 12 +#define UDI29KCP_ITmp 16 +#define UDI29KCP_R 20 +#define UDI29KCP_S 28 +#define UDI29KCP_RTmp 36 +#define UDI29KCP_STmp 44 +#define UDI29KCP_Stat 52 +#define UDI29KCP_Prec 56 +#define UDI29KCP_Reg0 60 +#define UDI29KCP_Reg1 68 +#define UDI29KCP_Reg2 76 +#define UDI29KCP_Reg3 84 +#define UDI29KCP_Reg4 92 +#define UDI29KCP_Reg5 100 +#define UDI29KCP_Reg6 108 +#define UDI29KCP_Reg7 116 +#define UDI29KCP_Mode 124 + +/* Enumerate the stacks in StackSizes array */ +#define UDI29KMemoryStack 0 +#define UDI29KRegisterStack 1 + +/* Enumerate the chips for ChipVersions array */ +#define UDI29K29KVersion 0 +#define UDI29K29027Version 1 + +/* Define special value for elements of ChipVersions array for + * chips not present */ +#define UDI29KChipNotPresent -1 + +typedef UDIInt32 UDICount; +typedef UDIUInt32 UDISize; + +typedef UDIInt CPUSpace; +typedef UDIUInt32 CPUOffset; +typedef UDIUInt32 CPUSizeT; diff --git a/gdb/29k-share/udi/udiptcfg.h b/gdb/29k-share/udi/udiptcfg.h new file mode 100644 index 00000000000..1641a53bcd4 --- /dev/null +++ b/gdb/29k-share/udi/udiptcfg.h @@ -0,0 +1,19 @@ +/* Copyright 1993 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#include "udipt29k.h" diff --git a/gdb/29k-share/udi/udisoc.h b/gdb/29k-share/udi/udisoc.h new file mode 100644 index 00000000000..bc68b3944ec --- /dev/null +++ b/gdb/29k-share/udi/udisoc.h @@ -0,0 +1,184 @@ +/* This module defines constants used in the UDI IPC modules. + + Copyright 1993 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +static char udisoc_h[]="@(#)udisoc.h 2.6 Daniel Mann"; +static char udisoc_h_AMD[]="@(#)udisoc.h 2.4, AMD"; + +#define LOCAL static +#define company_c 1 /* AMD Company id */ +#define product_c 1 /* socket IPC id */ + +/* Enumerate the UDI procedure services +*/ +#define UDIConnect_c 0 +#define UDIDisconnect_c 1 +#define UDISetCurrentConnection_c 2 +#define UDICapabilities_c 3 +#define UDIEnumerateTIPs_c 4 +#define UDIGetErrorMsg_c 5 +#define UDIGetTargetConfig_c 6 +#define UDICreateProcess_c 7 +#define UDISetCurrentProcess_c 8 +#define UDIDestroyProcess_c 9 +#define UDIInitializeProcess_c 10 +#define UDIRead_c 11 +#define UDIWrite_c 12 +#define UDICopy_c 13 +#define UDIExecute_c 14 +#define UDIStep_c 15 +#define UDIStop_c 16 +#define UDIWait_c 17 +#define UDISetBreakpoint_c 18 +#define UDIQueryBreakpoint_c 19 +#define UDIClearBreakpoint_c 20 +#define UDIGetStdout_c 21 +#define UDIGetStderr_c 22 +#define UDIPutStdin_c 23 +#define UDIStdinMode_c 24 +#define UDIPutTrans_c 25 +#define UDIGetTrans_c 26 +#define UDITransMode_c 27 +#define UDITest_c 28 +#define UDIKill_c 29 + +#define udr_UDIInt8(udrs, obj) udr_work(udrs, obj, 1) +#define udr_UDIInt16(udrs, obj) udr_work(udrs, obj, 2) +#define udr_UDIInt32(udrs, obj) udr_work(udrs, obj, 4) +#define udr_UDIInt(udrs, obj) udr_work(udrs, obj, 4) + +#define udr_UDIUInt8(udrs, obj) udr_work(udrs, obj, 1) +#define udr_UDIUInt16(udrs, obj) udr_work(udrs, obj, 2) +#define udr_UDIUInt32(udrs, obj) udr_work(udrs, obj, 4) +#define udr_UDIUInt(udrs, obj) udr_work(udrs, obj, 4) + +#define udr_UDIBool(udrs, obj) udr_UDIInt32(udrs, obj) +#define udr_UDICount(udrs, obj) udr_UDIInt32(udrs, obj) +#define udr_UDISize(udrs, obj) udr_UDIUInt32(udrs, obj) +#define udr_CPUSpace(udrs, obj) udr_UDIInt32(udrs, obj) +#define udr_CPUOffset(udrs, obj) udr_UDIUInt32(udrs, obj) +#define udr_CPUSizeT(udrs, obj) udr_UDIUInt32(udrs, obj) +#define udr_UDIBreakId(udrs,obj) udr_UDIUInt(udrs, obj) +#define udr_UDISizeT(udrs, obj) udr_UDIUInt(udrs, obj) +#define udr_UDIMode(udrs, obj) udr_UDIUInt(udrs, obj) + +#define udr_UDIHostMemPtr(udrs, obj) udr_UDIUInt32(udrs, obj) +#define udr_UDIVoidPtr(udrs, obj) udr_UDIUInt32(udrs, obj) +#define udr_UDIPId(udrs, obj) udr_UDIUInt(udrs, obj) +#define udr_UDISessionId(udrs, obj) udr_UDIInt32(udrs, obj) +#define udr_UDIError(udrs, obj) udr_UDIInt32(udrs, obj) +#define udr_UDIStepType(udrs, obj) udr_UDIInt32(udrs, obj) +#define udr_UDIBreakType(udrs, obj) udr_UDIInt32(udrs, obj) + + +#define UDR_ENCODE 1 +#define UDR_DECODE 2 + +typedef struct UDR_str +{ + int udr_op; /* UDR operation */ + int previous_op; + int sd; + int bufsize; + char* buff; + char* getbytes; + char* putbytes; + char* putend; + int domain; + char* soc_name; +} UDR; + +/******************************************* Declare UDR suport functions */ +int udr_create UDIParams(( + UDR* udrs, + int sd, + int size + )); + +int udr_free UDIParams(( + UDR* udrs, + )); + +int udr_signal UDIParams(( + UDR* udrs, + )); + +int udr_sendnow UDIParams(( + UDR* udrs + )); + +int udr_work UDIParams(( + UDR* udrs, + void* object_p, + int size + )); + +int udr_UDIResource UDIParams(( + UDR* udrs, + UDIResource* object_p + )); + +int udr_UDIRange UDIParams(( + UDR* udrs, + UDIRange* object_p + )); + +int udr_UDIMemoryRange UDIParams(( + UDR* udrs, + UDIMemoryRange* object_p + )); + +int udr_UDIMemoryRange UDIParams(( + UDR* udrs, + UDIMemoryRange* object_p + )); + +int udr_int UDIParams(( + UDR* udrs, + int* int_p + )); + +int udr_bytes UDIParams(( + UDR* udrs, + char* ptr, + int len + )); + +char* udr_inline UDIParams(( + UDR* udrs, + int size + )); + +char* udr_getpos UDIParams(( + UDR* udrs + )); +int udr_setpos UDIParams(( + UDR* udrs, + char* pos + )); + +int udr_readnow UDIParams(( + UDR* udrs, + int size + )); + +int udr_align UDIParams(( + UDR* udrs, + int size, + )); diff --git a/gdb/29k-share/udi/udr.c b/gdb/29k-share/udi/udr.c new file mode 100644 index 00000000000..10a9f38c6ae --- /dev/null +++ b/gdb/29k-share/udi/udr.c @@ -0,0 +1,427 @@ +/* This module supports sending and receiving data objects over a + socket conection. + + Copyright 1993 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +static char udr_c[]="@(#)udr.c 2.8 Daniel Mann"; +static char udr_c_AMD[]="@(#)udr.c 2.3, AMD"; +/* +* All data is serialised into a character stream, +* and de-serialised back into the approproiate objects. +********************************************************************** HISTORY +*/ +/* This is all unneeded on DOS machines. */ +#ifndef __GO32__ + +#include <stdio.h> +#include <sys/types.h> + +/* This used to say sys/fcntl.h, but the only systems I know of that + require that are old (pre-4.3, at least) BSD systems, which we + probably don't need to worry about. */ +#include <fcntl.h> + +#include <sys/socket.h> +#include "udiproc.h" +#include "udisoc.h" + +extern int errno; +extern char* malloc(); + +/* local type decs. and macro defs. not in a .h file ************* MACRO/TYPE +*/ + +/* global dec/defs. which are not in a .h file ************* EXPORT DEC/DEFS +*/ +int udr_errno; /* error occurs during UDR service */ + +/* local dec/defs. which are not in a .h file *************** LOCAL DEC/DEFS +*/ + +/****************************************************************** UDR_CREATE +* Build UDR structure for character stream processing. +*/ +int udr_create(udrs, sd, size) +UDR* udrs; +int sd; +int size; +{ + udrs->sd = sd; + if(!udrs->buff) udrs->buff = malloc(size); + udrs->getbytes = udrs->buff; /* set the buffer to the start */ + udrs->putbytes = udrs->buff; + udrs->putend = udrs->buff; + udrs->udr_op = -1; /* don't know the direction */ + udrs->previous_op = -1; /* don't know the direction */ + udrs->bufsize = size; + return 0; +} + +/******************************************************************** UDR_FREE +* Free USR structure and close socket. +*/ +int udr_free(udrs) +UDR* udrs; +{ + close(udrs->sd); + free(udrs->buff); + return 0; +} + +/****************************************************************** UDR_SIGNAL +* Send a signal to the process at the other end of the socket, +* indicating that it should expect to recieve a new message shortly. +*/ +int udr_signal(udrs) +UDR* udrs; +{ + if(send(udrs->sd, "I", 1, MSG_OOB) == -1) + { perror("ERROR, udr_signal(), send(...MSG_OOB)"); + udr_errno = UDIErrorIPCInternal; + return -1; /* return error code */ + } + return 0; +} + +/***************************************************************** UDR_SENDNOW +* used to flush the current character stream buffer to +* the associated socket. */ +int udr_sendnow(udrs) +UDR* udrs; +{ + int size = (UDIUInt32)(udrs->putend) - (UDIUInt32)(udrs->buff); + if(udrs->previous_op == 0) + { udr_errno = UDIErrorIPCInternal; + return -1; + } + udrs->putbytes = udrs->buff; + udrs->putend = udrs->buff; + if (write(udrs->sd, udrs->buff, size) == -1) + { perror("ERROR, udr_sendnow(), write() call: "); + udr_errno = UDIErrorIPCInternal; + return -1; /* return error code */ + } + return 0; +} + +/******************************************************************** UDR_WORK +* Function to send or recieve data from the buffers supporting +* socket communication. The buffer contains serialised objects +* sent/recieved over a socket connection. +*/ +int udr_work(udrs, object_p, size) +UDR* udrs; +void* object_p; +int size; +{ + int cnt, remain; + + if(udrs->udr_op != udrs->previous_op) + { if(udrs->previous_op == 0) + { udr_errno = UDIErrorIPCInternal; + return -1; + } + udrs->previous_op= udrs->udr_op; + udrs->putbytes = udrs->buff; + udrs->getbytes = udrs->buff; + } + + if(udrs->udr_op == UDR_ENCODE) + { /* write data into character stream buffer */ + if( (UDIUInt32)(udrs->putbytes) + size > + (UDIUInt32)(udrs->buff) + (UDIUInt32)(udrs->bufsize) ) + { udr_errno = UDIErrorIPCInternal; + return -1; + } + memcpy(udrs->putbytes, (char*)object_p, size); + udrs->putbytes += size; + if(udrs->putbytes > udrs->putend) udrs->putend = udrs->putbytes; + } + else if(udrs->udr_op == UDR_DECODE) + { + if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size ) + { /* need more data in character stream buffer */ + remain = (UDIUInt32)(udrs->bufsize) - + ( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->buff) ); + if( ((UDIUInt32)(udrs->bufsize) + (UDIUInt32)(udrs->buff) + - (UDIUInt32)(udrs->getbytes)) < size) + { udr_errno = UDIErrorIPCInternal; + return -1; + } + cnt = read(udrs->sd, (char*)udrs->putbytes, remain); + if(cnt == -1) perror("ERROR udr_work(), read() failure: "); + udrs->putbytes += cnt; + if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size ) + { udr_errno = UDIErrorIPCInternal; + return -1; /* return error code */ + } + } /* read data from character stream buffer */ + memcpy((char*)object_p, udrs->getbytes, size); + udrs->getbytes += size; + } + else + { udr_errno = UDIErrorIPCInternal; + return -1; + } + return 0; +} + +/************************************************************* UDR_UDIResource +*/ +int udr_UDIResource(udrs, object_p) +UDR* udrs; +UDIResource* object_p; +{ + int retval; + + retval = udr_CPUSpace(udrs, &object_p->Space); + retval = retval | udr_CPUOffset(udrs, &object_p->Offset); + return retval; +} + +/**************************************************************** UDR_UDIRange +*/ +int udr_UDIRange(udrs, object_p) +UDR* udrs; +UDIRange* object_p; +{ + int retval; + + retval = udr_CPUOffset(udrs, &object_p->Low); + retval = retval | udr_CPUOffset(udrs, &object_p->High); + return retval; +} + +/********************************************************** UDR_UDIMemoryRange +*/ +int udr_UDIMemoryRange(udrs, object_p) +UDR* udrs; +UDIMemoryRange* object_p; +{ + int retval; + + retval = udr_CPUSpace(udrs, &object_p->Space); + retval = retval | udr_CPUOffset(udrs, &object_p->Offset); + retval = retval | udr_CPUSizeT(udrs, &object_p->Size); + return retval; +} + +/****************************************************************** UDR_string +*/ +int udr_string(udrs, sp) +UDR* udrs; +char* sp; +{ + int len, retval; + + if(udrs->udr_op == UDR_ENCODE) + { + if(sp) + { len = strlen(sp) + 1; + retval = udr_UDIInt32(udrs, &len); + retval = retval | udr_work(udrs, sp, len); + } + else /* deal with NULL pointer */ + { len = 0; + retval = udr_UDIInt32(udrs, &len); + } + } + else if(udrs->udr_op == UDR_DECODE) + { + retval = udr_UDIInt32(udrs, &len); + if(len) + retval = retval | udr_work(udrs, sp, len); + else *sp = '\0'; /* terminate string */ + } + else + { udr_errno = UDIErrorIPCInternal; + return -1; + } + return retval; +} + +/******************************************************************* UDR_BYTES +*/ +int udr_bytes(udrs, ptr, len) +UDR* udrs; +char* ptr; +int len; +{ + return udr_work(udrs, ptr, len); +} + +/********************************************************************* UDR_INT +*/ +int udr_int(udrs, int_p) +UDR* udrs; +int* int_p; +{ + int ret_val; + UDIInt32 udr_obj; /* object of know size */ + + if(udrs->udr_op == UDR_ENCODE) + { + udr_obj = *int_p; /* copy into know object size */ + return udr_UDIInt32(udrs, &udr_obj); + } + else if(udrs->udr_op == UDR_DECODE) + { + ret_val = udr_UDIInt32(udrs, &udr_obj); /* get object of known size */ + *int_p = udr_obj; + return ret_val; + } + else + { udr_errno = UDIErrorIPCInternal; + return -1; + } +} + +/****************************************************************** UDR_INLINE +*/ +char* udr_inline(udrs, size) +UDR* udrs; +int size; +{ + if(udrs->udr_op != udrs->previous_op) + { if(udrs->previous_op == 0) + { udr_errno = UDIErrorIPCInternal; + return 0; + } + udrs->previous_op= udrs->udr_op; + udrs->putbytes = udrs->buff; + udrs->getbytes = udrs->buff; + } + if(udrs->udr_op == UDR_ENCODE) + { + if(udrs->putbytes + size > udrs->bufsize + udrs->buff) + return 0; + udrs->putbytes += size; + return udrs->putbytes - size; + } + else if(udrs->udr_op == UDR_DECODE) + { + if(udrs->getbytes + size > udrs->bufsize + udrs->buff) + return 0; + udrs->getbytes += size; + return udrs->getbytes - size; + } + else + { udr_errno = UDIErrorIPCInternal; + return 0; + } +} + +/****************************************************************** UDR_GETPOS +*/ +char* udr_getpos(udrs) +UDR* udrs; +{ + if(udrs->udr_op == UDR_ENCODE) + { + return udrs->putbytes; + } + else if(udrs->udr_op == UDR_DECODE) + { + return udrs->getbytes; + } + else + { udr_errno = UDIErrorIPCInternal; + return 0; + } +} + +/****************************************************************** UDR_SETPOS +*/ +int udr_setpos(udrs, pos) +UDR* udrs; +char* pos; +{ + if( ((UDIUInt32)pos > (UDIUInt32)(udrs->buff) + (UDIUInt32)(udrs->bufsize)) + || ((UDIUInt32)pos < (UDIUInt32)(udrs->buff) ) ) + { udr_errno = UDIErrorIPCInternal; + return 0; + } + if(udrs->udr_op == UDR_ENCODE) + { + udrs->putbytes = pos; + return 1; + } + else if(udrs->udr_op == UDR_DECODE) + { + udrs->getbytes = pos; + return 1; + } + else + { udr_errno = UDIErrorIPCInternal; + return 0; + } +} + +/***************************************************************** UDR_READNOW +* Try and ensure "size" bytes are available in the +* receive buffer character stream. +*/ +int udr_readnow(udrs, size) +UDR* udrs; +int size; +{ + int cnt, remain; + + if(udrs->udr_op == UDR_ENCODE) + { + udr_errno = UDIErrorIPCInternal; + return -1; + } + else if(udrs->udr_op == UDR_DECODE) + { + if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size ) + { /* need more data in character stream buffer */ + remain = (UDIUInt32)(udrs->bufsize) - + ( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->buff) ); + cnt = read(udrs->sd, (char*)udrs->putbytes, remain); + if(cnt == -1) perror("ERROR udr_work(), read() failure: "); + udrs->putbytes += cnt; + if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size ) + { fprintf(stderr,"ERROR, udr_readnow() too few bytes in stream\n"); + return -1; /* return error code */ + } + } + } + else + { udr_errno = UDIErrorIPCInternal; + return -1; + } + return 0; +} + +/******************************************************************* UDR_ALIGN +*/ +int udr_align(udrs, size) +UDR* udrs; +int size; +{ + char* align; + int offset; + + align = udr_getpos(udrs); + offset = size - ((int)align & (size -1)); + offset = offset & (size -1); + if(offset) udr_setpos(udrs, align + offset); +} +#endif /* __GO32__ */ |