Changeset 97f6256 in rtems


Ignore:
Timestamp:
02/01/02 19:33:15 (22 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
6966421
Parents:
bdb86b4
Message:

2002-02-01 Eric Valette <valette@…>

  • So many patches have been posted recently on the mailing list and because we were unable to find correct solution to compile on various linux distros (due to rpcgen incompatibilities), and because the coding style of rdbg was rather inconsistant among various pieces of code, I decided to:

1) make some cleaning regarding global coding style (using

indent + manual edits),

2) incorporate/review the paches send by various people

(S. Holford, T. Strauman),

3) Fix the bug due to varying rpcgen code generation

in remdeb_svc.c,

4) Remove some dead code,
5) Apply a patches enabling to call enterRdbg imediately

after rdbg initialization is done,

NB : the paches is huge but it is mainly due to coding styke chnages.
Only few lines of codes have been really changed and they do not impact
rdbg functionnality (AFAIKT).

  • include/rdbg/servrpc.h, include/rdbg/i386/rdbg_f.h, include/rdbg/m68k/rdbg_f.h, include/rdbg/powerpc/rdbg_f.h, src/_servtgt.c, src/awk.svc, src/excep.c, src/ptrace.c, src/rdbg.c, src/remdeb.x, src/servbkpt.c, src/servcon.c, src/servrpc.c, src/servtgt.c, src/servtsp.c, src/servutil.c, src/i386/excep_f.c, src/i386/rdbg_f.c, src/i386/any/Makefile.am, src/i386/any/remdeb.h, src/i386/any/remdeb_svc.c, src/i386/any/remdeb_xdr.c, src/m68k/excep_f.c, src/m68k/rdbg_f.c, src/m68k/any/Makefile.am, src/m68k/any/remdeb.h, src/m68k/any/remdeb_svc.c, src/m68k/any/remdeb_xdr.c, src/powerpc/excep_f.c, src/powerpc/rdbg_f.c, src/powerpc/new_exception_processing/Makefile.am, src/powerpc/new_exception_processing/remdeb.h, src/powerpc/new_exception_processing/remdeb_svc.c, src/powerpc/new_exception_processing/remdeb_xdr.c: Modified.
Location:
c/src/librdbg
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • c/src/librdbg/ChangeLog

    rbdb86b4 r97f6256  
    3535        src/powerpc/new_exception_processing/remdeb_xdr.c: Modified.
    3636
    37 2002-01-18      Till Straumann <strauman@slac.stanford.edu>
    38 
    39         * src/powerpc/excep_f.c: This patch addresses the following issues:
    40             - exception handler needs to enable MSR_FP if the interrupted
    41               thread is FP enabled.
    42             - printk message for MSR fixed and added stacktrace
    43 
    44         NOTE: this requires the stacktrace patch to
    45         lib/libbsp/powerpc/shared/vectors/vector_init.c
    46         (#ifdef DDEBUG only, however)
    47 
    48 2001-01-18      Joel Sherrill <joel@OARcorp.com>
    49 
    50         * src/powerpc/new_exception_processing/remdeb_svc.c: Corrected
    51         macro using variable arguments.
    52        
    53 2001-01-18      Joel Sherrill <joel@OARcorp.com>
    54 
    55         * src/powerpc/new_exception_processing/remdeb.h,
    56         src/powerpc/new_exception_processing/remdeb_xdr.c: Regenerated since
    57         I updated the main RTEMS development machine to RedHat 7.2 and
    58         apparently got a new version of rpcgen.
    59 
    60 2001-10-30      Victor V. Vengerov <vvv@oktet.ru>
    61 
    62         * src/m68k/rdbg_cpu_asm.S: Now compiles on ColdFire.
    63 
    64 2001-10-17      Ralf Corsepius <corsepiu@faw.uni-ulm.de>
    65 
    66         * configure.ac: Fix latent bug exposed by removal of config.cache's
    67         which prevented powerpc targets librdbg from building.
    68 
    69 2001-10-11      Ralf Corsepius <corsepiu@faw.uni-ulm.de>
    70 
    71         * .cvsignore: Add autom4te.cache for autoconf > 2.52.
    72         * configure.in: Remove.
    73         * configure.ac: New file, generated from configure.in by autoupdate.
    74 
    75 2001-09-23      Ralf Corsepius <corsepiu@faw.uni-ulm.de>
    76 
    77         * include/rdbg/i386/Makefile.am: Use 'PREINSTALL_FILES ='.
    78         * include/rdbg/m68k/Makefile.am: Use 'PREINSTALL_FILES ='.
    79         * include/rdbg/powerpc/Makefile.am: Use 'PREINSTALL_FILES ='.
    80         * include/rdbg/Makefile.am: Use 'PREINSTALL_FILES ='.
    81         * src/i386/any/Makefile.am: Use 'PREINSTALL_FILES ='.
    82         * src/m68k/any/Makefile.am: Use 'PREINSTALL_FILES ='.
    83         * src/powerpc/new_exception_processing/Makefile.am: Use 'PREINSTALL_FILES ='.
    84 
    85 2001-09-22      Ralf Corsepius <corsepiu@faw.uni-ulm.de>
    86 
    87         * src/i386/any/Makefile.am: Move MAINTAINERCLEANFILES before the
    88         includes and use MAINTAINERCLEANFILES = to make automake-1.5 happy.
    89         * src/m68k/any/Makefile.am: Ditto.
    90         * src/powerpc/new_exception_processing/Makefile.am: Ditto.
    91 
    92 2001-09-14      Eric Norum <eric.norum@usask.ca>
    93 
    94         * include/rdbg/rdbg.h, src/ptrace.c: Modifications to make gcc 3.x happy.
    95 
    96 2001-04-20      Eric Valette <valette@crf.canon.fr>
    97 
    98         * mcp750 directory renamed new_exception processing as it
    99         supports many more CPU models.
    100         * configure.in, src/powerpc/Makefile.am,
    101         src/powerpc/new_exception_processing/Makefile.am,
    102         src/powerpc/new_exception_processing/remdeb_f.x: New files
    103         formerly in mcp750 plus modifications.
    104         * src/powerpc/mcp750/.cvsignore, src/powerpc/mcp750/Makefile.am,
    105         src/powerpc/mcp750/remdeb.h, src/powerpc/mcp750/remdeb_f.x,
    106         src/powerpc/mcp750/remdeb_svc.c, src/powerpc/mcp750/remdeb_xdr.c:
    107         Removed when moved to new_exception_processing.
    108         * configure.in, src/powerpc/Makefile.am,
    109         src/powerpc/new_exception_processing/Makefile.am,
    110         src/powerpc/new_exception_processing/remdeb_f.x: Modified as
    111         part of this effort to add support for the MPC8xx.
    112 
    113 2001-02-04      Ralf Corsepius <corsepiu@faw.uni-ulm.de>
    114 
    115         * include/rdbg/Makefile.am, include/rdbg/i386/Makefile.am,
    116         include/rdbg/m68k/Makefile.am, include/rdbg/powerpc/Makefile.am:
    117         Cleanup including more proper style on include files.
    118 
    119 2000-11-09      Ralf Corsepius <corsepiu@faw.uni-ulm.de>
    120 
    121         * Makefile.am: Use ... instead of RTEMS_TOPdir in ACLOCAL_AMFLAGS.
    122 
    123 2000-11-02      Ralf Corsepius <corsepiu@faw.uni-ulm.de>
    124 
    125         * Makefile.am: Switch to ACLOCAL_AMFLAGS = -I $(RTEMS_TOPdir)/aclocal.
    126 
    127 2000-10-25      Ralf Corsepius <corsepiu@faw.uni-ulm.de>
    128 
    129         * Makefile.am: ACLOCAL_AMFLAGS= -I $(RTEMS_TOPdir)/macros.
    130         Switch to GNU canonicalization.
    131 
    132 2000-10-19  Antti P Miettinen  <anmietti@trshp.ntc.nokia.com>
    133 
    134         * src/m68k/any/remdeb.h, src/m68k/any/remdeb_xdr.c,
    135         src/m68k/any/remdeb_svc.c: New files missed in merger.
    136 
    137 2000-10-19  Antti P Miettinen  <anmietti@trshp.ntc.nokia.com>
    138 
    139         * configure.in: Add m68k support.
    140         * include/rdbg/m68k, src/m68k, src/m68k/any: New subdirectory.
    141         * src/_servtgt.c: add status text to prinf upon task creation failure.
    142         * src/rdbg.c: reconnect rdbg exception handlers upon RPC calls.
    143         * src/m68k/Makefile.am, src/m68k/any/Makefile.am,
    144         src/m68k/any/remdeb_f.x, src/m68k/any/.cvsignore,
    145         src/m68k/any/remdeb.h, src/m68k/any/remdeb_xdr.c,
    146         src/m68k/any/remdeb_svc.c, src/m68k/excep_f.c, src/m68k/rdbg_cpu_asm.S,
    147         src/m68k/rdbg_f.c, src/m68k/.cvsignore: New files.
    148 
    149 2000-09-04      Ralf Corsepius <corsepiu@faw.uni-ulm.de>
    150 
    151         * src/i386/any/Makefile.am, src/powerpc/mcp750/Makefile.am: Include
    152         compile.am
    153 
    154 2000-08-10      Joel Sherrill <joel@OARcorp.com>
    155 
    156         * ChangeLog: New file.

  • c/src/librdbg/src/i386/any/remdeb.h

    rbdb86b4 r97f6256  
    99#include <rpc/rpc.h>
    1010
     11
    1112#ifdef __cplusplus
    1213extern "C" {
    … …  
    1617#define RTEMS_BACK_PORT 2073
    1718#ifndef REMDEB_H
    18 #define RPCGENSRVNAME(a)     a
    19 
    20   enum rpc_type {
    21     SUNRPC = 0,
    22     BADRPCTYPE = 25,
    23   };
    24   typedef enum rpc_type rpc_type;
     19#define RPCGENSRVNAME(a) a
     20
     21enum rpc_type {
     22        SUNRPC = 0,
     23        BADRPCTYPE = 25,
     24};
     25typedef enum rpc_type rpc_type;
    2526#define NET_SAFE 1400
    2627
    27   struct UDP_MSG {
    28     u_char type;
    29     u_char msg_num;
    30     u_short spec;
    31     long pid;
    32     u_long context;
    33   };
    34   typedef struct UDP_MSG UDP_MSG;
     28struct UDP_MSG {
     29        u_char type;
     30        u_char msg_num;
     31        u_short spec;
     32        long pid;
     33        u_long context;
     34};
     35typedef struct UDP_MSG UDP_MSG;
    3536/*
    3637 * Sun request values for the remote ptrace system call
    3738 */
    3839
    39   enum ptracereq {
    40     RPT_TRACEME = 0,
    41     RPT_CHILDDONE = 0,
    42     RPT_PEEKTEXT = 0 + 1,
    43     RPT_PEEKDATA = 0 + 2,
    44     RPT_PEEKUSER = 0 + 3,
    45     RPT_POKETEXT = 0 + 4,
    46     RPT_POKEDATA = 0 + 5,
    47     RPT_POKEUSER = 0 + 6,
    48     RPT_CONT = 0 + 7,
    49     RPT_KILL = 0 + 8,
    50     RPT_SINGLESTEP = 0 + 9,
    51     RPT_ATTACH = 0 + 10,
    52     RPT_DETACH = 0 + 11,
    53     RPT_GETREGS = 0 + 12,
    54     RPT_SETREGS = 0 + 13,
    55     RPT_GETFPREGS = 0 + 14,
    56     RPT_SETFPREGS = 0 + 15,
    57     RPT_READDATA = 0 + 16,
    58     RPT_WRITEDATA = 0 + 17,
    59     RPT_READTEXT = 0 + 18,
    60     RPT_WRITETEXT = 0 + 19,
    61     RPT_GETFPAREGS = 0 + 20,
    62     RPT_SETFPAREGS = 0 + 21,
    63     RPT_22 = 0 + 22,
    64     RPT_23 = 0 + 23,
    65     RPT_SYSCALL = 0 + 24,
    66     RPT_DUMPCORE = 0 + 25,
    67     RPT_26 = 0 + 26,
    68     RPT_27 = 0 + 27,
    69     RPT_28 = 0 + 28,
    70     RPT_GETUCODE = 0 + 29,
    71     RPT_GETTARGETTHREAD = 50,
    72     RPT_SETTARGETTHREAD = 51,
    73     RPT_THREADSUSPEND = 52,
    74     RPT_THREADRESUME = 53,
    75     RPT_THREADLIST = 54,
    76     RPT_GETTHREADNAME = 55,
    77     RPT_SETTHREADNAME = 56,
    78     RPT_SETTHREADREGS = 57,
    79     RPT_GETTHREADREGS = 58,
    80     RPT_STEPRANGE = 75,
    81     RPT_CONTTO = 76,
    82     RPT_SETBREAK = 77,
    83     RPT_CLRBREAK = 78,
    84     RPT_GETBREAK = 79,
    85     RPT_GETNAME = 80,
    86     RPT_STOP = 81,
    87     RPT_PGETREGS = 82,
    88     RPT_PSETREGS = 83,
    89     RPT_PSETTHREADREGS = 84,
    90     RPT_PGETTHREADREGS = 85,
    91   };
    92   typedef enum ptracereq ptracereq;
    93 
    94   struct xdr_regs {
    95     u_int tabreg[19];
    96   };
    97   typedef struct xdr_regs xdr_regs;
     40
     41enum ptracereq {
     42        RPT_TRACEME = 0,
     43        RPT_CHILDDONE = 0,
     44        RPT_PEEKTEXT = 0 + 1,
     45        RPT_PEEKDATA = 0 + 2,
     46        RPT_PEEKUSER = 0 + 3,
     47        RPT_POKETEXT = 0 + 4,
     48        RPT_POKEDATA = 0 + 5,
     49        RPT_POKEUSER = 0 + 6,
     50        RPT_CONT = 0 + 7,
     51        RPT_KILL = 0 + 8,
     52        RPT_SINGLESTEP = 0 + 9,
     53        RPT_ATTACH = 0 + 10,
     54        RPT_DETACH = 0 + 11,
     55        RPT_GETREGS = 0 + 12,
     56        RPT_SETREGS = 0 + 13,
     57        RPT_GETFPREGS = 0 + 14,
     58        RPT_SETFPREGS = 0 + 15,
     59        RPT_READDATA = 0 + 16,
     60        RPT_WRITEDATA = 0 + 17,
     61        RPT_READTEXT = 0 + 18,
     62        RPT_WRITETEXT = 0 + 19,
     63        RPT_GETFPAREGS = 0 + 20,
     64        RPT_SETFPAREGS = 0 + 21,
     65        RPT_22 = 0 + 22,
     66        RPT_23 = 0 + 23,
     67        RPT_SYSCALL = 0 + 24,
     68        RPT_DUMPCORE = 0 + 25,
     69        RPT_26 = 0 + 26,
     70        RPT_27 = 0 + 27,
     71        RPT_28 = 0 + 28,
     72        RPT_GETUCODE = 0 + 29,
     73        RPT_GETTARGETTHREAD = 50,
     74        RPT_SETTARGETTHREAD = 51,
     75        RPT_THREADSUSPEND = 52,
     76        RPT_THREADRESUME = 53,
     77        RPT_THREADLIST = 54,
     78        RPT_GETTHREADNAME = 55,
     79        RPT_SETTHREADNAME = 56,
     80        RPT_SETTHREADREGS = 57,
     81        RPT_GETTHREADREGS = 58,
     82        RPT_STEPRANGE = 75,
     83        RPT_CONTTO = 76,
     84        RPT_SETBREAK = 77,
     85        RPT_CLRBREAK = 78,
     86        RPT_GETBREAK = 79,
     87        RPT_GETNAME = 80,
     88        RPT_STOP = 81,
     89        RPT_PGETREGS = 82,
     90        RPT_PSETREGS = 83,
     91        RPT_PSETTHREADREGS = 84,
     92        RPT_PGETTHREADREGS = 85,
     93};
     94typedef enum ptracereq ptracereq;
     95
     96struct xdr_regs {
     97        u_int tabreg[19];
     98};
     99typedef struct xdr_regs xdr_regs;
    98100/* now define register macros to apply to xdr_reg struct */
    99101
    100 #define GS     0
    101 #define FS     1
    102 #define ES     2
    103 #define DS     3
    104 #define EDI    4
    105 #define ESI    5
    106 #define EBP    6
    107 #define ESP    7
    108 #define EBX    8
    109 #define EDX    9
    110 #define ECX    10
    111 #define EAX    11
     102#define GS 0
     103#define FS 1
     104#define ES 2
     105#define DS 3
     106#define EDI 4
     107#define ESI 5
     108#define EBP 6
     109#define ESP 7
     110#define EBX 8
     111#define EDX 9
     112#define ECX 10
     113#define EAX 11
    112114#define TRAPNO 12
    113 #define ERR    13
    114 #define EIP    14
    115 #define CS     15
    116 #define EFL    16
    117 #define UESP   17
    118 #define SS     18
    119 
    120 #define REG_PC tabreg[EIP]      /* PC (eip) register offset */
    121 #define REG_SP tabreg[UESP]     /* SP (uesp) register offset */
    122 #define REG_FP tabreg[EBP]      /* FP (ebp) register offset */
     115#define ERR 13
     116#define EIP 14
     117#define CS 15
     118#define EFL 16
     119#define UESP 17
     120#define SS 18
     121
     122#define REG_PC tabreg[EIP] /* PC (eip) register offset */
     123#define REG_SP tabreg[UESP] /* SP (uesp) register offset */
     124#define REG_FP tabreg[EBP] /* FP (ebp) register offset */
    123125/* now define the BREAKPOINT mask technique to a long word */
    124 #define SET_BREAK(l)   ((l&0xFFFFFF00) | 0xCC)
    125 #define IS_BREAK(l)    (((l) & 0xFF) == 0xCC)
     126#define SET_BREAK(l) ((l&0xFFFFFF00) | 0xCC)
     127#define IS_BREAK(l) (((l) & 0xFF) == 0xCC)
    126128#define ORG_BREAK(c,p) (((c) & 0xFFFFFF00) | ((p) & 0xFF))
    127 #define IS_STEP(regs)  (regs.tabreg[TRAPNO] == 1)  /* was step and not break */
    128 #define BREAK_ADJ      1        /* must subtract one from address after bp */
    129 #define BREAK_SIZE     1        /* Breakpoint occupies one byte */
    130 #define TARGET_PROC_TYPE  0
     129#define IS_STEP(regs) (regs.tabreg[TRAPNO] == 1) /* was step and not break */
     130#define BREAK_ADJ 1 /* must subtract one from address after bp */
     131#define BREAK_SIZE 1 /* Breakpoint occupies one byte */
     132#define TARGET_PROC_TYPE 0
    131133#define MAXDEBUGGEE 150
    132134#define NAMEMAX 17
    133   /*
     135 /*
    134136   * Memory data for read/write text or data. The size is in data. The target
    135137   * addr is in the addr field.
    … …  
    140142#define MEM_DATA_MAX 256
    141143
    142   struct xdr_mem {
    143     u_long addr;
    144     u_int dataNb;
    145     u_char data[MEM_DATA_MAX];
    146   };
    147   typedef struct xdr_mem xdr_mem;
    148 
    149   enum break_type {
    150     BRKT_NONE = 0,
    151     BRKT_INSTR = 1,
    152     BRKT_READ = 2,
    153     BRKT_WRITE = 3,
    154     BRKT_ACCESS = 4,
    155     BRKT_EXEC = 5,
    156     BRKT_OS_CALL = 6,
    157     BRKT_OS_SWITCH = 7,
    158     BRKT_STEPEMUL = 8,
    159   };
    160   typedef enum break_type break_type;
     144struct xdr_mem {
     145        u_long addr;
     146        u_int dataNb;
     147        u_char data[MEM_DATA_MAX];
     148};
     149typedef struct xdr_mem xdr_mem;
     150
     151enum break_type {
     152        BRKT_NONE = 0,
     153        BRKT_INSTR = 1,
     154        BRKT_READ = 2,
     155        BRKT_WRITE = 3,
     156        BRKT_ACCESS = 4,
     157        BRKT_EXEC = 5,
     158        BRKT_OS_CALL = 6,
     159        BRKT_OS_SWITCH = 7,
     160        BRKT_STEPEMUL = 8,
     161};
     162typedef enum break_type break_type;
    161163#define MAX_THRD_BRK 4
    162164
    163   struct xdr_break {
    164     u_char type;
    165     u_char thread_spec;
    166     u_short handle;
    167     u_long ee_loc;
    168     u_long ee_type;
    169     u_short length;
    170     u_char pass_count;
    171     u_char curr_pass;
    172     u_long thread_list[MAX_THRD_BRK];
    173   };
    174   typedef struct xdr_break xdr_break;
     165struct xdr_break {
     166        u_char type;
     167        u_char thread_spec;
     168        u_short handle;
     169        u_long ee_loc;
     170        u_long ee_type;
     171        u_short length;
     172        u_char pass_count;
     173        u_char curr_pass;
     174        u_long thread_list[MAX_THRD_BRK];
     175};
     176typedef struct xdr_break xdr_break;
    175177#define UTHREAD_MAX 64
    176178#define THREADNAMEMAX 16
    177179
    178   typedef char *thread_name;
    179 
    180   struct KernThread {
    181     u_int threadLi;
    182   };
    183   typedef struct KernThread KernThread;
    184   typedef KernThread *ptThreadList;
    185 
    186   struct thread_list {
    187     u_int nbThread;
    188     ptThreadList threads;
    189   };
    190   typedef struct thread_list thread_list;
    191 
    192   struct ptrace_addr_data_in {
    193     ptracereq req;
    194     union {
    195       xdr_regs regs;
    196       struct {
    197         u_int pregs_len;
    198         u_int *pregs_val;
    199       } pregs;
    200       thread_name name;
    201       xdr_mem mem;
    202       xdr_break breakp;
    203       u_int address;
    204     } ptrace_addr_data_in_u;
    205   };
    206   typedef struct ptrace_addr_data_in ptrace_addr_data_in;
    207 
    208   struct ptrace_addr_data_out {
    209     ptracereq req;
    210     union {
    211       xdr_regs regs;
    212       struct {
    213         u_int pregs_len;
    214         u_int *pregs_val;
    215       } pregs;
    216       thread_list threads;
    217       thread_name name;
    218       xdr_mem mem;
    219       xdr_break breakp;
    220       u_int addr;
    221     } ptrace_addr_data_out_u;
    222   };
    223   typedef struct ptrace_addr_data_out ptrace_addr_data_out;
    224 
    225   typedef struct {
    226     u_int CHAR_DATA_len;
    227     char *CHAR_DATA_val;
    228   } CHAR_DATA;
    229 #define XRY_MAX_INST_BUFF 128
    230 #define XRY_MAX_INSTANCES 16
    231 #ifndef XRY_MAX_CMD_STR
    232 #define XRY_MAX_CMD_STR 320
    233 #endif                          /* REMDEB_H */
    234 
    235   struct xry_inst {
    236     u_char flags;
    237     u_char type;
    238     u_char sub_type;
    239     u_char res_type;
    240     u_long value;
    241     u_long value2;
    242   };
    243   typedef struct xry_inst xry_inst;
    244 
    245   struct instance {
    246     struct xry_inst instances[XRY_MAX_INSTANCES];
    247     u_char buffer[XRY_MAX_INST_BUFF];
    248   };
    249   typedef struct instance instance;
    250 
    251   struct instance_union {
    252     bool_t instances;
    253     union {
    254       instance inst;
    255       char *buffer;
    256     } instance_union_u;
    257   };
    258   typedef struct instance_union instance_union;
    259 
    260   typedef char *one_arg;
    261 #define XRY_MAX_OBJ_NAME 32
    262   /*
    263    * now open_connex() routine which establishes a connection to server
    264    */
    265 
    266   enum debug_type {
    267     DEBTYP_PROCESS = 0,
    268     DEBTYP_C_ACTOR = 1,
    269     DEBTYP_KERNEL = 2,
    270     DEBTYP_OTHER = 3,
    271   };
    272   typedef enum debug_type debug_type;
    273 #define DEBUGGER_IS_GDB 0x2     /* */
    274 
    275   struct open_in {
    276     u_char back_port[16];
    277     u_short debug_type;
    278     u_short flags;
    279     u_char destination[16];
    280     one_arg user_name;
    281   };
    282   typedef struct open_in open_in;
    283 
    284   struct open_out {
    285     u_long port;
    286     u_int pad[4];
    287     u_int fp;
    288     u_char cmd_table_num;
    289     u_char cmd_table_vers;
    290     u_short server_vers;
    291   };
    292   typedef struct open_out open_out;
    293   /*
    294    * now close_connex() routine which detaches from server
    295    */
    296 
    297   enum close_control {
    298     CLOSE_IGNORE = 0,
    299     CLOSE_KILL = 1,
    300     CLOSE_DETACH = 2,
    301   };
    302   typedef enum close_control close_control;
    303 
    304   struct close_in {
    305     close_control control;
    306   };
    307   typedef struct close_in close_in;
    308   /*
    309    * now send_signal() routine which sends signals to processes like kill(2)
    310    */
    311 
    312   struct signal_in {
    313     int pid;
    314     int sig;
    315   };
    316   typedef struct signal_in signal_in;
    317 
    318   struct signal_out {
    319     int kill_return;
    320     int errNo;
    321   };
    322   typedef struct signal_out signal_out;
    323   /*
    324    * now wait_info() routine which returns results of polling the wait status
    325    * of a process/actor. It may return 0 if running, else pid or -1
    326    */
    327 
    328   enum stop_code {
    329     STOP_ERROR = 0,
    330     STOP_NONE = 1,
    331     STOP_UNKNOWN = 2,
    332     STOP_BREAK = 3,
    333     STOP_STEP = 4,
    334     STOP_SIGNAL = 5,
    335     STOP_TERM_EXIT = 6,
    336     STOP_TERM_SIG = 7,
    337     STOP_DETACHED = 8,
    338     STOP_KILLED = 9,
    339     STOP_SPAWN_FAILED = 10,
    340   };
    341   typedef enum stop_code stop_code;
    342 
    343   struct wait_in {
    344     int pid;
    345   };
    346   typedef struct wait_in wait_in;
    347 
    348   struct wait_out {
    349     int wait_return;
    350     int errNo;
    351     int status;
    352     stop_code reason;
    353     int handle;
    354     u_long PC;
    355     u_long SP;
    356     u_long FP;
    357     u_long thread;
    358   };
    359   typedef struct wait_out wait_out;
    360   /*
    361    * now ptrace() routine. This matches the Sun UNIX ptrace as well as
    362    * some additions
    363    */
     180typedef char *thread_name;
     181
     182struct KernThread {
     183        u_int threadLi;
     184};
     185typedef struct KernThread KernThread;
     186typedef KernThread *ptThreadList;
     187
     188struct thread_list {
     189        u_int nbThread;
     190        ptThreadList threads;
     191};
     192typedef struct thread_list thread_list;
     193
     194struct ptrace_addr_data_in {
     195        ptracereq req;
     196        union {
     197                xdr_regs regs;
     198                struct {
     199                        u_int pregs_len;
     200                        u_int *pregs_val;
     201                } pregs;
     202                thread_name name;
     203                xdr_mem mem;
     204                xdr_break breakp;
     205                u_int address;
     206        } ptrace_addr_data_in_u;
     207};
     208typedef struct ptrace_addr_data_in ptrace_addr_data_in;
     209
     210struct ptrace_addr_data_out {
     211        ptracereq req;
     212        union {
     213                xdr_regs regs;
     214                struct {
     215                        u_int pregs_len;
     216                        u_int *pregs_val;
     217                } pregs;
     218                thread_list threads;
     219                thread_name name;
     220                xdr_mem mem;
     221                xdr_break breakp;
     222                u_int addr;
     223        } ptrace_addr_data_out_u;
     224};
     225typedef struct ptrace_addr_data_out ptrace_addr_data_out;
     226
     227typedef struct {
     228        u_int CHAR_DATA_len;
     229        char *CHAR_DATA_val;
     230} CHAR_DATA;
     231
     232typedef char *one_arg;
     233 /* now open_connex() routine which establishes a connection to server */
     234
     235enum debug_type {
     236        DEBTYP_PROCESS = 0,
     237        DEBTYP_C_ACTOR = 1,
     238        DEBTYP_KERNEL = 2,
     239        DEBTYP_OTHER = 3,
     240};
     241typedef enum debug_type debug_type;
     242#define DEBUGGER_IS_GDB 0x2 /* */
     243
     244struct open_in {
     245        u_char back_port[16];
     246        u_short debug_type;
     247        u_short flags;
     248        u_char destination[16];
     249        one_arg user_name;
     250};
     251typedef struct open_in open_in;
     252
     253struct open_out {
     254        u_long port;
     255        u_int pad[4];
     256        u_int fp;
     257        u_char cmd_table_num;
     258        u_char cmd_table_vers;
     259        u_short server_vers;
     260};
     261typedef struct open_out open_out;
     262 /* now close_connex() routine which detaches from server */
     263
     264enum close_control {
     265        CLOSE_IGNORE = 0,
     266        CLOSE_KILL = 1,
     267        CLOSE_DETACH = 2,
     268};
     269typedef enum close_control close_control;
     270
     271struct close_in {
     272        close_control control;
     273};
     274typedef struct close_in close_in;
     275 /* now send_signal() routine which sends signals to processes like kill(2) */
     276
     277struct signal_in {
     278        int pid;
     279        int sig;
     280};
     281typedef struct signal_in signal_in;
     282
     283struct signal_out {
     284        int kill_return;
     285        int errNo;
     286};
     287typedef struct signal_out signal_out;
     288 /* now wait_info() routine which returns results of polling the wait status
     289        of a process/actor. It may return 0 if running, else pid or -1 */
     290
     291enum stop_code {
     292        STOP_ERROR = 0,
     293        STOP_NONE = 1,
     294        STOP_UNKNOWN = 2,
     295        STOP_BREAK = 3,
     296        STOP_STEP = 4,
     297        STOP_SIGNAL = 5,
     298        STOP_TERM_EXIT = 6,
     299        STOP_TERM_SIG = 7,
     300        STOP_DETACHED = 8,
     301        STOP_KILLED = 9,
     302        STOP_SPAWN_FAILED = 10,
     303};
     304typedef enum stop_code stop_code;
     305
     306struct wait_in {
     307        int pid;
     308};
     309typedef struct wait_in wait_in;
     310
     311struct wait_out {
     312        int wait_return;
     313        int errNo;
     314        int status;
     315        stop_code reason;
     316        int handle;
     317        u_long PC;
     318        u_long SP;
     319        u_long FP;
     320        u_long thread;
     321};
     322typedef struct wait_out wait_out;
     323 /* now ptrace() routine. This matches the Sun UNIX ptrace as well as
     324        some additions */
    364325#define PTRFLG_FORCE 1
    365326#define PTRFLG_NON_OWNER 2
    … …  
    367328#define PTRDET_UNOWN 0x100
    368329
    369   struct ptrace_in {
    370     int pid;
    371     ptrace_addr_data_in addr;
    372     u_int data;
    373     u_int flags;
    374   };
    375   typedef struct ptrace_in ptrace_in;
    376 
    377   struct ptrace_out {
    378     ptrace_addr_data_out addr;
    379     int result;
    380     int errNo;
    381   };
    382   typedef struct ptrace_out ptrace_out;
    383 
    384   struct one_symbol {
    385     char *symbolName;
    386     long symbolValue;
    387   };
    388   typedef struct one_symbol one_symbol;
    389 
    390   typedef struct {
    391     u_int all_symbols_len;
    392     one_symbol *all_symbols_val;
    393   } all_symbols;
    394 
    395   struct get_global_symbols_out {
    396     all_symbols symbols;
    397   };
    398   typedef struct get_global_symbols_out get_global_symbols_out;
    399 
    400   struct get_text_data_in {
    401     int pid;
    402     char *actorName;
    403   };
    404   typedef struct get_text_data_in get_text_data_in;
    405 
    406   struct get_text_data_out {
    407     int result;
    408     int errNo;
    409     u_long textStart;
    410     u_long textSize;
    411     u_long dataStart;
    412     u_long dataSize;
    413   };
    414   typedef struct get_text_data_out get_text_data_out;
    415 
    416   struct one_signal {
    417     u_int number;
    418     char *name;
    419   };
    420   typedef struct one_signal one_signal;
    421 
    422   typedef struct {
    423     u_int all_signals_len;
    424     one_signal *all_signals_val;
    425   } all_signals;
    426 
    427   struct get_signal_names_out {
    428     all_signals signals;
    429   };
    430   typedef struct get_signal_names_out get_signal_names_out;
    431   /*
    432    * now define the actual calls we support
    433    */
     330struct ptrace_in {
     331        int pid;
     332        ptrace_addr_data_in addr;
     333        u_int data;
     334        u_int flags;
     335};
     336typedef struct ptrace_in ptrace_in;
     337
     338struct ptrace_out {
     339        ptrace_addr_data_out addr;
     340        int result;
     341        int errNo;
     342};
     343typedef struct ptrace_out ptrace_out;
     344
     345struct one_symbol {
     346        char *symbolName;
     347        long symbolValue;
     348};
     349typedef struct one_symbol one_symbol;
     350
     351typedef struct {
     352        u_int all_symbols_len;
     353        one_symbol *all_symbols_val;
     354} all_symbols;
     355
     356struct get_global_symbols_out {
     357        all_symbols symbols;
     358};
     359typedef struct get_global_symbols_out get_global_symbols_out;
     360
     361struct get_text_data_in {
     362        int pid;
     363        char *actorName;
     364};
     365typedef struct get_text_data_in get_text_data_in;
     366
     367struct get_text_data_out {
     368        int result;
     369        int errNo;
     370        u_long textStart;
     371        u_long textSize;
     372        u_long dataStart;
     373        u_long dataSize;
     374};
     375typedef struct get_text_data_out get_text_data_out;
     376
     377struct one_signal {
     378        u_int number;
     379        char *name;
     380};
     381typedef struct one_signal one_signal;
     382
     383typedef struct {
     384        u_int all_signals_len;
     385        one_signal *all_signals_val;
     386} all_signals;
     387
     388struct get_signal_names_out {
     389        all_signals signals;
     390};
     391typedef struct get_signal_names_out get_signal_names_out;
     392 /* now define the actual calls we support */
    434393#define REMDEB_H
    435394#endif
    … …  
    440399#if defined(__STDC__) || defined(__cplusplus)
    441400#define OPEN_CONNEX 1
    442   extern open_out *open_connex_2 (open_in *, CLIENT *);
    443   extern open_out *open_connex_2_svc (open_in *, struct svc_req *);
     401extern  open_out * open_connex_2(open_in *, CLIENT *);
     402extern  open_out * open_connex_2_svc(open_in *, struct svc_req *);
    444403#define SEND_SIGNAL 2
    445   extern signal_out *send_signal_2 (signal_in *, CLIENT *);
    446   extern signal_out *send_signal_2_svc (signal_in *, struct svc_req *);
     404extern  signal_out * send_signal_2(signal_in *, CLIENT *);
     405extern  signal_out * send_signal_2_svc(signal_in *, struct svc_req *);
    447406#define CLOSE_CONNEX 10
    448   extern void *close_connex_2 (close_in *, CLIENT *);
    449   extern void *close_connex_2_svc (close_in *, struct svc_req *);
     407extern  void * close_connex_2(close_in *, CLIENT *);
     408extern  void * close_connex_2_svc(close_in *, struct svc_req *);
    450409#define PTRACE 11
    451   extern ptrace_out *ptrace_2 (ptrace_in *, CLIENT *);
    452   extern ptrace_out *ptrace_2_svc (ptrace_in *, struct svc_req *);
     410extern  ptrace_out * ptrace_2(ptrace_in *, CLIENT *);
     411extern  ptrace_out * ptrace_2_svc(ptrace_in *, struct svc_req *);
    453412#define WAIT_INFO 13
    454   extern wait_out *wait_info_2 (wait_in *, CLIENT *);
    455   extern wait_out *wait_info_2_svc (wait_in *, struct svc_req *);
     413extern  wait_out * wait_info_2(wait_in *, CLIENT *);
     414extern  wait_out * wait_info_2_svc(wait_in *, struct svc_req *);
    456415#define GET_SIGNAL_NAMES 17
    457   extern get_signal_names_out *get_signal_names_2 (void *, CLIENT *);
    458   extern get_signal_names_out *get_signal_names_2_svc (void *,
    459                                                        struct svc_req *);
    460   extern int remotedeb_2_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
    461 
    462 #else                           /* K&R C */
     416extern  get_signal_names_out * get_signal_names_2(void *, CLIENT *);
     417extern  get_signal_names_out * get_signal_names_2_svc(void *, struct svc_req *);
     418extern int remotedeb_2_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
     419
     420#else /* K&R C */
    463421#define OPEN_CONNEX 1
    464   extern open_out *open_connex_2 ();
    465   extern open_out *open_connex_2_svc ();
     422extern  open_out * open_connex_2();
     423extern  open_out * open_connex_2_svc();
    466424#define SEND_SIGNAL 2
    467   extern signal_out *send_signal_2 ();
    468   extern signal_out *send_signal_2_svc ();
     425extern  signal_out * send_signal_2();
     426extern  signal_out * send_signal_2_svc();
    469427#define CLOSE_CONNEX 10
    470   extern void *close_connex_2 ();
    471   extern void *close_connex_2_svc ();
     428extern  void * close_connex_2();
     429extern  void * close_connex_2_svc();
    472430#define PTRACE 11
    473   extern ptrace_out *ptrace_2 ();
    474   extern ptrace_out *ptrace_2_svc ();
     431extern  ptrace_out * ptrace_2();
     432extern  ptrace_out * ptrace_2_svc();
    475433#define WAIT_INFO 13
    476   extern wait_out *wait_info_2 ();
    477   extern wait_out *wait_info_2_svc ();
     434extern  wait_out * wait_info_2();
     435extern  wait_out * wait_info_2_svc();
    478436#define GET_SIGNAL_NAMES 17
    479   extern get_signal_names_out *get_signal_names_2 ();
    480   extern get_signal_names_out *get_signal_names_2_svc ();
    481   extern int remotedeb_2_freeresult ();
    482 #endif                          /* K&R C */
     437extern  get_signal_names_out * get_signal_names_2();
     438extern  get_signal_names_out * get_signal_names_2_svc();
     439extern int remotedeb_2_freeresult ();
     440#endif /* K&R C */
    483441
    484442/* the xdr functions */
    485443
    486444#if defined(__STDC__) || defined(__cplusplus)
    487   extern bool_t xdr_rpc_type (XDR *, rpc_type *);
    488   extern bool_t xdr_UDP_MSG (XDR *, UDP_MSG *);
    489   extern bool_t xdr_ptracereq (XDR *, ptracereq *);
    490   extern bool_t xdr_xdr_regs (XDR *, xdr_regs *);
    491   extern bool_t xdr_xdr_mem (XDR *, xdr_mem *);
    492   extern bool_t xdr_break_type (XDR *, break_type *);
    493   extern bool_t xdr_xdr_break (XDR *, xdr_break *);
    494   extern bool_t xdr_thread_name (XDR *, thread_name *);
    495   extern bool_t xdr_KernThread (XDR *, KernThread *);
    496   extern bool_t xdr_thread_list (XDR *, thread_list *);
    497   extern bool_t xdr_ptrace_addr_data_in (XDR *, ptrace_addr_data_in *);
    498   extern bool_t xdr_ptrace_addr_data_out (XDR *, ptrace_addr_data_out *);
    499   extern bool_t xdr_CHAR_DATA (XDR *, CHAR_DATA *);
    500   extern bool_t xdr_xry_inst (XDR *, xry_inst *);
    501   extern bool_t xdr_instance (XDR *, instance *);
    502   extern bool_t xdr_instance_union (XDR *, instance_union *);
    503   extern bool_t xdr_one_arg (XDR *, one_arg *);
    504   extern bool_t xdr_debug_type (XDR *, debug_type *);
    505   extern bool_t xdr_open_in (XDR *, open_in *);
    506   extern bool_t xdr_open_out (XDR *, open_out *);
    507   extern bool_t xdr_close_control (XDR *, close_control *);
    508   extern bool_t xdr_close_in (XDR *, close_in *);
    509   extern bool_t xdr_signal_in (XDR *, signal_in *);
    510   extern bool_t xdr_signal_out (XDR *, signal_out *);
    511   extern bool_t xdr_stop_code (XDR *, stop_code *);
    512   extern bool_t xdr_wait_in (XDR *, wait_in *);
    513   extern bool_t xdr_wait_out (XDR *, wait_out *);
    514   extern bool_t xdr_ptrace_in (XDR *, ptrace_in *);
    515   extern bool_t xdr_ptrace_out (XDR *, ptrace_out *);
    516   extern bool_t xdr_one_symbol (XDR *, one_symbol *);
    517   extern bool_t xdr_all_symbols (XDR *, all_symbols *);
    518   extern bool_t xdr_get_global_symbols_out (XDR *, get_global_symbols_out *);
    519   extern bool_t xdr_get_text_data_in (XDR *, get_text_data_in *);
    520   extern bool_t xdr_get_text_data_out (XDR *, get_text_data_out *);
    521   extern bool_t xdr_one_signal (XDR *, one_signal *);
    522   extern bool_t xdr_all_signals (XDR *, all_signals *);
    523   extern bool_t xdr_get_signal_names_out (XDR *, get_signal_names_out *);
    524 
    525 #else                           /* K&R C */
    526   extern bool_t xdr_rpc_type ();
    527   extern bool_t xdr_UDP_MSG ();
    528   extern bool_t xdr_ptracereq ();
    529   extern bool_t xdr_xdr_regs ();
    530   extern bool_t xdr_xdr_mem ();
    531   extern bool_t xdr_break_type ();
    532   extern bool_t xdr_xdr_break ();
    533   extern bool_t xdr_thread_name ();
    534   extern bool_t xdr_KernThread ();
    535   extern bool_t xdr_thread_list ();
    536   extern bool_t xdr_ptrace_addr_data_in ();
    537   extern bool_t xdr_ptrace_addr_data_out ();
    538   extern bool_t xdr_CHAR_DATA ();
    539   extern bool_t xdr_xry_inst ();
    540   extern bool_t xdr_instance ();
    541   extern bool_t xdr_instance_union ();
    542   extern bool_t xdr_one_arg ();
    543   extern bool_t xdr_debug_type ();
    544   extern bool_t xdr_open_in ();
    545   extern bool_t xdr_open_out ();
    546   extern bool_t xdr_close_control ();
    547   extern bool_t xdr_close_in ();
    548   extern bool_t xdr_signal_in ();
    549   extern bool_t xdr_signal_out ();
    550   extern bool_t xdr_stop_code ();
    551   extern bool_t xdr_wait_in ();
    552   extern bool_t xdr_wait_out ();
    553   extern bool_t xdr_ptrace_in ();
    554   extern bool_t xdr_ptrace_out ();
    555   extern bool_t xdr_one_symbol ();
    556   extern bool_t xdr_all_symbols ();
    557   extern bool_t xdr_get_global_symbols_out ();
    558   extern bool_t xdr_get_text_data_in ();
    559   extern bool_t xdr_get_text_data_out ();
    560   extern bool_t xdr_one_signal ();
    561   extern bool_t xdr_all_signals ();
    562   extern bool_t xdr_get_signal_names_out ();
    563 
    564 #endif                          /* K&R C */
     445extern  bool_t xdr_rpc_type (XDR *, rpc_type*);
     446extern  bool_t xdr_UDP_MSG (XDR *, UDP_MSG*);
     447extern  bool_t xdr_ptracereq (XDR *, ptracereq*);
     448extern  bool_t xdr_xdr_regs (XDR *, xdr_regs*);
     449extern  bool_t xdr_xdr_mem (XDR *, xdr_mem*);
     450extern  bool_t xdr_break_type (XDR *, break_type*);
     451extern  bool_t xdr_xdr_break (XDR *, xdr_break*);
     452extern  bool_t xdr_thread_name (XDR *, thread_name*);
     453extern  bool_t xdr_KernThread (XDR *, KernThread*);
     454extern  bool_t xdr_thread_list (XDR *, thread_list*);
     455extern  bool_t xdr_ptrace_addr_data_in (XDR *, ptrace_addr_data_in*);
     456extern  bool_t xdr_ptrace_addr_data_out (XDR *, ptrace_addr_data_out*);
     457extern  bool_t xdr_CHAR_DATA (XDR *, CHAR_DATA*);
     458extern  bool_t xdr_one_arg (XDR *, one_arg*);
     459extern  bool_t xdr_debug_type (XDR *, debug_type*);
     460extern  bool_t xdr_open_in (XDR *, open_in*);
     461extern  bool_t xdr_open_out (XDR *, open_out*);
     462extern  bool_t xdr_close_control (XDR *, close_control*);
     463extern  bool_t xdr_close_in (XDR *, close_in*);
     464extern  bool_t xdr_signal_in (XDR *, signal_in*);
     465extern  bool_t xdr_signal_out (XDR *, signal_out*);
     466extern  bool_t xdr_stop_code (XDR *, stop_code*);
     467extern  bool_t xdr_wait_in (XDR *, wait_in*);
     468extern  bool_t xdr_wait_out (XDR *, wait_out*);
     469extern  bool_t xdr_ptrace_in (XDR *, ptrace_in*);
     470extern  bool_t xdr_ptrace_out (XDR *, ptrace_out*);
     471extern  bool_t xdr_one_symbol (XDR *, one_symbol*);
     472extern  bool_t xdr_all_symbols (XDR *, all_symbols*);
     473extern  bool_t xdr_get_global_symbols_out (XDR *, get_global_symbols_out*);
     474extern  bool_t xdr_get_text_data_in (XDR *, get_text_data_in*);
     475extern  bool_t xdr_get_text_data_out (XDR *, get_text_data_out*);
     476extern  bool_t xdr_one_signal (XDR *, one_signal*);
     477extern  bool_t xdr_all_signals (XDR *, all_signals*);
     478extern  bool_t xdr_get_signal_names_out (XDR *, get_signal_names_out*);
     479
     480#else /* K&R C */
     481extern bool_t xdr_rpc_type ();
     482extern bool_t xdr_UDP_MSG ();
     483extern bool_t xdr_ptracereq ();
     484extern bool_t xdr_xdr_regs ();
     485extern bool_t xdr_xdr_mem ();
     486extern bool_t xdr_break_type ();
     487extern bool_t xdr_xdr_break ();
     488extern bool_t xdr_thread_name ();
     489extern bool_t xdr_KernThread ();
     490extern bool_t xdr_thread_list ();
     491extern bool_t xdr_ptrace_addr_data_in ();
     492extern bool_t xdr_ptrace_addr_data_out ();
     493extern bool_t xdr_CHAR_DATA ();
     494extern bool_t xdr_one_arg ();
     495extern bool_t xdr_debug_type ();
     496extern bool_t xdr_open_in ();
     497extern bool_t xdr_open_out ();
     498extern bool_t xdr_close_control ();
     499extern bool_t xdr_close_in ();
     500extern bool_t xdr_signal_in ();
     501extern bool_t xdr_signal_out ();
     502extern bool_t xdr_stop_code ();
     503extern bool_t xdr_wait_in ();
     504extern bool_t xdr_wait_out ();
     505extern bool_t xdr_ptrace_in ();
     506extern bool_t xdr_ptrace_out ();
     507extern bool_t xdr_one_symbol ();
     508extern bool_t xdr_all_symbols ();
     509extern bool_t xdr_get_global_symbols_out ();
     510extern bool_t xdr_get_text_data_in ();
     511extern bool_t xdr_get_text_data_out ();
     512extern bool_t xdr_one_signal ();
     513extern bool_t xdr_all_signals ();
     514extern bool_t xdr_get_signal_names_out ();
     515
     516#endif /* K&R C */
    565517
    566518#ifdef __cplusplus
    567519}
    568520#endif
    569 #endif                          /* !_REMDEB_H_RPCGEN */
     521
     522#endif /* !_REMDEB_H_RPCGEN */

  • c/src/librdbg/src/i386/any/remdeb_svc.c

    rbdb86b4 r97f6256  
    1 #include <rpc/types.h>
    2 #include <rpc/rpc.h>
    3 #include <stdio.h>
    4 #include <stdlib.h>
    5 #include <string.h>
    6 #include <bsp.h>
    7 #include <rdbg/servrpc.h>
    8 #include <rdbg/remdeb.h>
    9 #define fprintf(a,b) printf(b)
    10 /*HEADER_START*/
    11 #define RTEMS_PORT 2071
    12 #define RTEMS_BACK_PORT 2073
    13 /*
    14  * Sun request values for the remote ptrace system call
    15  */
    16 
    17   /*
    18    * Memory data for read/write text or data. The size is in data. The target
    19    * addr is in the addr field.
    20    * Be careful before modifying because this value goes into internal
    21    * pipes and is allocated on stack too. Pipes and/or the stack could
    22    * become too small if this value gets incremented.
    23    */
    24 #ifndef XRY_MAX_CMD_STR
    25 #endif /* REMDEB_H */
    26   /*
    27    * now open_connex() routine which establishes a connection to server
    28    */
    29 #define DEBUGGER_IS_GDB 0x2     /* */
    30   /*
    31    * now close_connex() routine which detaches from server
    32    */
    33   /*
    34    * now send_signal() routine which sends signals to processes like kill(2)
    35    */
    36   /*
    37    * now wait_info() routine which returns results of polling the wait status
    38    * of a process/actor. It may return 0 if running, else pid or -1
    39    */
    40   /*
    41    * now ptrace() routine. This matches the Sun UNIX ptrace as well as
    42    * some additions
    43    */
    44   /*
    45    * now define the actual calls we support
    46    */
    47 const char *names[] = {
    48   "NULLPROC", "OPEN_CONNEX", "SEND_SIGNAL", "name3",
    49   "name4", "name5", "name6", "name7",
    50   "name8", "name9", "CLOSE_CONNEX", "PTRACE",
    51   "name12", "WAIT_INFO", "name14", "name15",
    52   "name16", "GET_SIGNAL_NAMES", "name18"
    53 };
    54 
    55 void
    56 remotedeb_2 (struct svc_req *rqstp, register SVCXPRT * transp)
    57 {
    58   union {
    59     open_in open_connex_2_arg;
    60     signal_in send_signal_2_arg;
    61     close_in close_connex_2_arg;
    62     ptrace_in ptrace_2_arg;
    63     wait_in wait_info_2_arg;
    64   } argument;
    65   char *result;
    66   xdrproc_t _xdr_argument, _xdr_result;
    67   char *(*local) (char *, struct svc_req *);
    68 
    69   DPRINTF (("remotedeb_2: %s (%d)\n",
    70             (unsigned) rqstp->rq_proc <
    71             (unsigned) (sizeof names / sizeof names[0]) ?
    72             names[rqstp->rq_proc] : "???", (int) rqstp->rq_proc));
    73 
    74   switch (rqstp->rq_proc) {
    75   case NULLPROC:
    76     (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *) NULL);
    77     return;
    78 
    79   case OPEN_CONNEX:
    80     _xdr_argument = (xdrproc_t) xdr_open_in;
    81     _xdr_result = (xdrproc_t) xdr_open_out;
    82     local = (char *(*)(char *, struct svc_req *)) open_connex_2_svc;
    83     break;
    84 
    85   case SEND_SIGNAL:
    86     _xdr_argument = (xdrproc_t) xdr_signal_in;
    87     _xdr_result = (xdrproc_t) xdr_signal_out;
    88     local = (char *(*)(char *, struct svc_req *)) send_signal_2_svc;
    89     break;
    90 
    91   case CLOSE_CONNEX:
    92     _xdr_argument = (xdrproc_t) xdr_close_in;
    93     _xdr_result = (xdrproc_t) xdr_void;
    94     local = (char *(*)(char *, struct svc_req *)) close_connex_2_svc;
    95     break;
    96 
    97   case PTRACE:
    98     _xdr_argument = (xdrproc_t) xdr_ptrace_in;
    99     _xdr_result = (xdrproc_t) xdr_ptrace_out;
    100     local = (char *(*)(char *, struct svc_req *)) ptrace_2_svc;
    101     break;
    102 
    103   case WAIT_INFO:
    104     _xdr_argument = (xdrproc_t) xdr_wait_in;
    105     _xdr_result = (xdrproc_t) xdr_wait_out;
    106     local = (char *(*)(char *, struct svc_req *)) wait_info_2_svc;
    107     break;
    108 
    109   case GET_SIGNAL_NAMES:
    110     _xdr_argument = (xdrproc_t) xdr_void;
    111     _xdr_result = (xdrproc_t) xdr_get_signal_names_out;
    112     local = (char *(*)(char *, struct svc_req *)) get_signal_names_2_svc;
    113     break;
    114 
    115   default:
    116     svcerr_noproc (transp);
    117     return;
    118   }
    119   memset ((char *) &argument, 0, sizeof (argument));
    120   if (!svc_getargs (transp, _xdr_argument, (caddr_t) & argument)) {
    121     svcerr_decode (transp);
    122     return;
    123   }
    124   result = (*local) ((char *) &argument, rqstp);
    125   if (result != NULL && !svc_sendreply (transp, _xdr_result, result)) {
    126     svcerr_systemerr (transp);
    127   }
    128   if (!svc_freeargs (transp, _xdr_argument, (caddr_t) & argument)) {
    129     fprintf (stderr, "unable to free arguments");
    130     exit (1);
    131   }
    132   return;
    133 }

  • c/src/librdbg/src/i386/any/remdeb_xdr.c

    rbdb86b4 r97f6256  
    99
    1010bool_t
    11 xdr_rpc_type (XDR * xdrs, rpc_type * objp)
    12 {
    13   register int32_t *buf;
    14 
    15   if (!xdr_enum (xdrs, (enum_t *) objp))
    16     return FALSE;
    17   return TRUE;
    18 }
    19 
    20 bool_t
    21 xdr_UDP_MSG (XDR * xdrs, UDP_MSG * objp)
    22 {
    23   register int32_t *buf;
    24 
    25   if (!xdr_u_char (xdrs, &objp->type))
    26     return FALSE;
    27   if (!xdr_u_char (xdrs, &objp->msg_num))
    28     return FALSE;
    29   if (!xdr_u_short (xdrs, &objp->spec))
    30     return FALSE;
    31   if (!xdr_long (xdrs, &objp->pid))
    32     return FALSE;
    33   if (!xdr_u_long (xdrs, &objp->context))
    34     return FALSE;
    35   return TRUE;
    36 }
    37 
     11xdr_rpc_type (XDR *xdrs, rpc_type *objp)
     12{
     13        register int32_t *buf;
     14
     15         if (!xdr_enum (xdrs, (enum_t *) objp))
     16                 return FALSE;
     17        return TRUE;
     18}
     19
     20bool_t
     21xdr_UDP_MSG (XDR *xdrs, UDP_MSG *objp)
     22{
     23        register int32_t *buf;
     24
     25         if (!xdr_u_char (xdrs, &objp->type))
     26                 return FALSE;
     27         if (!xdr_u_char (xdrs, &objp->msg_num))
     28                 return FALSE;
     29         if (!xdr_u_short (xdrs, &objp->spec))
     30                 return FALSE;
     31         if (!xdr_long (xdrs, &objp->pid))
     32                 return FALSE;
     33         if (!xdr_u_long (xdrs, &objp->context))
     34                 return FALSE;
     35        return TRUE;
     36}
    3837/*
    3938 * Sun request values for the remote ptrace system call
    4039 */
    4140
    42 bool_t
    43 xdr_ptracereq (XDR * xdrs, ptracereq * objp)
    44 {
    45   register int32_t *buf;
    46 
    47   if (!xdr_enum (xdrs, (enum_t *) objp))
    48     return FALSE;
    49   return TRUE;
    50 }
    51 
    52 bool_t
    53 xdr_xdr_regs (XDR * xdrs, xdr_regs * objp)
    54 {
    55   register int32_t *buf;
    56 
    57   int i;
    58 
    59   if (xdrs->x_op == XDR_ENCODE) {
    60     buf = XDR_INLINE (xdrs, 19 * BYTES_PER_XDR_UNIT);
    61     if (buf == NULL) {
    62       if (!xdr_vector (xdrs, (char *) objp->tabreg, 19,
    63                        sizeof (u_int), (xdrproc_t) xdr_u_int))
    64         return FALSE;
    65     } else {
    66       {
    67         register u_int *genp;
    68 
    69         for (i = 0, genp = objp->tabreg; i < 19; ++i) {
    70           IXDR_PUT_U_LONG (buf, *genp++);
    71         }
    72       }
    73     }
    74     return TRUE;
    75   } else if (xdrs->x_op == XDR_DECODE) {
    76     buf = XDR_INLINE (xdrs, 19 * BYTES_PER_XDR_UNIT);
    77     if (buf == NULL) {
    78       if (!xdr_vector (xdrs, (char *) objp->tabreg, 19,
    79                        sizeof (u_int), (xdrproc_t) xdr_u_int))
    80         return FALSE;
    81     } else {
    82       {
    83         register u_int *genp;
    84 
    85         for (i = 0, genp = objp->tabreg; i < 19; ++i) {
    86           *genp++ = IXDR_GET_U_LONG (buf);
    87         }
    88       }
    89     }
    90     return TRUE;
    91   }
    92 
    93   if (!xdr_vector (xdrs, (char *) objp->tabreg, 19,
    94                    sizeof (u_int), (xdrproc_t) xdr_u_int))
    95     return FALSE;
    96   return TRUE;
    97 }
    98 
    99   /*
     41
     42bool_t
     43xdr_ptracereq (XDR *xdrs, ptracereq *objp)
     44{
     45        register int32_t *buf;
     46
     47         if (!xdr_enum (xdrs, (enum_t *) objp))
     48                 return FALSE;
     49        return TRUE;
     50}
     51
     52bool_t
     53xdr_xdr_regs (XDR *xdrs, xdr_regs *objp)
     54{
     55        register int32_t *buf;
     56
     57        int i;
     58
     59        if (xdrs->x_op == XDR_ENCODE) {
     60                buf = XDR_INLINE (xdrs, ( 19 ) * BYTES_PER_XDR_UNIT);
     61                if (buf == NULL) {
     62                         if (!xdr_vector (xdrs, (char *)objp->tabreg, 19,
     63                                sizeof (u_int), (xdrproc_t) xdr_u_int))
     64                                 return FALSE;
     65                } else {
     66                        {
     67                                register u_int *genp;
     68
     69                                for (i = 0, genp = objp->tabreg;
     70                                        i < 19; ++i) {
     71                                        IXDR_PUT_U_LONG(buf, *genp++);
     72                                }
     73                        }
     74                }
     75                return TRUE;
     76        } else if (xdrs->x_op == XDR_DECODE) {
     77                buf = XDR_INLINE (xdrs, ( 19 ) * BYTES_PER_XDR_UNIT);
     78                if (buf == NULL) {
     79                         if (!xdr_vector (xdrs, (char *)objp->tabreg, 19,
     80                                sizeof (u_int), (xdrproc_t) xdr_u_int))
     81                                 return FALSE;
     82                } else {
     83                        {
     84                                register u_int *genp;
     85
     86                                for (i = 0, genp = objp->tabreg;
     87                                        i < 19; ++i) {
     88                                        *genp++ = IXDR_GET_U_LONG(buf);
     89                                }
     90                        }
     91                }
     92         return TRUE;
     93        }
     94
     95         if (!xdr_vector (xdrs, (char *)objp->tabreg, 19,
     96                sizeof (u_int), (xdrproc_t) xdr_u_int))
     97                 return FALSE;
     98        return TRUE;
     99}
     100 /*
    100101   * Memory data for read/write text or data. The size is in data. The target
    101102   * addr is in the addr field.
    … …  
    104105   * become too small if this value gets incremented.
    105106   */
    106 bool_t
    107 xdr_xdr_mem (xdrs, objp)
    108      XDR *xdrs;
    109      struct xdr_mem *objp;
    110 {
    111   if (!xdr_u_long (xdrs, &objp->addr)) {
    112     return (FALSE);
    113   }
    114   if (!xdr_u_int (xdrs, &objp->dataNb)) {
    115     return (FALSE);
    116   }
    117   return (xdr_opaque (xdrs, objp->data, objp->dataNb));
    118 }
    119 
    120 bool_t
    121 xdr_break_type (XDR * xdrs, break_type * objp)
    122 {
    123   register int32_t *buf;
    124 
    125   if (!xdr_enum (xdrs, (enum_t *) objp))
    126     return FALSE;
    127   return TRUE;
    128 }
    129 
    130 bool_t
    131 xdr_xdr_break (XDR * xdrs, xdr_break * objp)
    132 {
    133   register int32_t *buf;
    134 
    135   int i;
    136 
    137   if (xdrs->x_op == XDR_ENCODE) {
    138     if (!xdr_u_char (xdrs, &objp->type))
    139       return FALSE;
    140     if (!xdr_u_char (xdrs, &objp->thread_spec))
    141       return FALSE;
    142     buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
    143     if (buf == NULL) {
    144       if (!xdr_u_short (xdrs, &objp->handle))
    145         return FALSE;
    146       if (!xdr_u_long (xdrs, &objp->ee_loc))
    147         return FALSE;
    148       if (!xdr_u_long (xdrs, &objp->ee_type))
    149         return FALSE;
    150       if (!xdr_u_short (xdrs, &objp->length))
    151         return FALSE;
    152 
    153     } else {
    154       IXDR_PUT_U_SHORT (buf, objp->handle);
    155       IXDR_PUT_U_LONG (buf, objp->ee_loc);
    156       IXDR_PUT_U_LONG (buf, objp->ee_type);
    157       IXDR_PUT_U_SHORT (buf, objp->length);
    158     }
    159     if (!xdr_u_char (xdrs, &objp->pass_count))
    160       return FALSE;
    161     if (!xdr_u_char (xdrs, &objp->curr_pass))
    162       return FALSE;
    163     buf = XDR_INLINE (xdrs, MAX_THRD_BRK * BYTES_PER_XDR_UNIT);
    164     if (buf == NULL) {
    165       if (!xdr_vector (xdrs, (char *) objp->thread_list, MAX_THRD_BRK,
    166                        sizeof (u_long), (xdrproc_t) xdr_u_long))
    167         return FALSE;
    168     } else {
    169       {
    170         register u_long *genp;
    171 
    172         for (i = 0, genp = objp->thread_list; i < MAX_THRD_BRK; ++i) {
    173           IXDR_PUT_U_LONG (buf, *genp++);
    174         }
    175       }
    176     }
    177     return TRUE;
    178   } else if (xdrs->x_op == XDR_DECODE) {
    179     if (!xdr_u_char (xdrs, &objp->type))
    180       return FALSE;
    181     if (!xdr_u_char (xdrs, &objp->thread_spec))
    182       return FALSE;
    183     buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
    184     if (buf == NULL) {
    185       if (!xdr_u_short (xdrs, &objp->handle))
    186         return FALSE;
    187       if (!xdr_u_long (xdrs, &objp->ee_loc))
    188         return FALSE;
    189       if (!xdr_u_long (xdrs, &objp->ee_type))
    190         return FALSE;
    191       if (!xdr_u_short (xdrs, &objp->length))
    192         return FALSE;
    193 
    194     } else {
    195       objp->handle = IXDR_GET_U_SHORT (buf);
    196       objp->ee_loc = IXDR_GET_U_LONG (buf);
    197       objp->ee_type = IXDR_GET_U_LONG (buf);
    198       objp->length = IXDR_GET_U_SHORT (buf);
    199     }
    200     if (!xdr_u_char (xdrs, &objp->pass_count))
    201       return FALSE;
    202     if (!xdr_u_char (xdrs, &objp->curr_pass))
    203       return FALSE;
    204     buf = XDR_INLINE (xdrs, MAX_THRD_BRK * BYTES_PER_XDR_UNIT);
    205     if (buf == NULL) {
    206       if (!xdr_vector (xdrs, (char *) objp->thread_list, MAX_THRD_BRK,
    207                        sizeof (u_long), (xdrproc_t) xdr_u_long))
    208         return FALSE;
    209     } else {
    210       {
    211         register u_long *genp;
    212 
    213         for (i = 0, genp = objp->thread_list; i < MAX_THRD_BRK; ++i) {
    214           *genp++ = IXDR_GET_U_LONG (buf);
    215         }
    216       }
    217     }
    218     return TRUE;
    219   }
    220 
    221   if (!xdr_u_char (xdrs, &objp->type))
    222     return FALSE;
    223   if (!xdr_u_char (xdrs, &objp->thread_spec))
    224     return FALSE;
    225   if (!xdr_u_short (xdrs, &objp->handle))
    226     return FALSE;
    227   if (!xdr_u_long (xdrs, &objp->ee_loc))
    228     return FALSE;
    229   if (!xdr_u_long (xdrs, &objp->ee_type))
    230     return FALSE;
    231   if (!xdr_u_short (xdrs, &objp->length))
    232     return FALSE;
    233   if (!xdr_u_char (xdrs, &objp->pass_count))
    234     return FALSE;
    235   if (!xdr_u_char (xdrs, &objp->curr_pass))
    236     return FALSE;
    237   if (!xdr_vector (xdrs, (char *) objp->thread_list, MAX_THRD_BRK,
    238                    sizeof (u_long), (xdrproc_t) xdr_u_long))
    239     return FALSE;
    240   return TRUE;
    241 }
    242 
    243 bool_t
    244 xdr_thread_name (XDR * xdrs, thread_name * objp)
    245 {
    246   register int32_t *buf;
    247 
    248   if (!xdr_string (xdrs, objp, THREADNAMEMAX))
    249     return FALSE;
    250   return TRUE;
    251 }
    252 
    253 bool_t
    254 xdr_KernThread (XDR * xdrs, KernThread * objp)
    255 {
    256   register int32_t *buf;
    257 
    258   if (!xdr_u_int (xdrs, &objp->threadLi))
    259     return FALSE;
    260   return TRUE;
    261 }
    262 
    263 bool_t
    264 xdr_thread_list (xdrs, objp)
    265      XDR *xdrs;
    266      struct thread_list *objp;
    267 {
    268   return (xdr_array (xdrs, (char **) &objp->threads, &objp->nbThread,
    269                      UTHREAD_MAX, sizeof (KernThread), xdr_KernThread));
    270 }
    271 
    272 bool_t
    273 xdr_ptrace_addr_data_in (XDR * xdrs, ptrace_addr_data_in * objp)
    274 {
    275   register int32_t *buf;
    276 
    277   if (!xdr_ptracereq (xdrs, &objp->req))
    278     return FALSE;
    279   switch (objp->req) {
    280   case RPT_SETTHREADREGS:
    281     if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_in_u.regs))
    282       return FALSE;
    283     break;
    284   case RPT_SETREGS:
    285     if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_in_u.regs))
    286       return FALSE;
    287     break;
    288   case RPT_PSETTHREADREGS:
    289     if (!xdr_array
    290         (xdrs, (char **) &objp->ptrace_addr_data_in_u.pregs.pregs_val,
    291          (u_int *) & objp->ptrace_addr_data_in_u.pregs.pregs_len, ~0,
    292          sizeof (u_int), (xdrproc_t) xdr_u_int))
    293       return FALSE;
    294     break;
    295   case RPT_PSETREGS:
    296     if (!xdr_array
    297         (xdrs, (char **) &objp->ptrace_addr_data_in_u.pregs.pregs_val,
    298          (u_int *) & objp->ptrace_addr_data_in_u.pregs.pregs_len, ~0,
    299          sizeof (u_int), (xdrproc_t) xdr_u_int))
    300       return FALSE;
    301     break;
    302   case RPT_SETTHREADNAME:
    303     if (!xdr_thread_name (xdrs, &objp->ptrace_addr_data_in_u.name))
    304       return FALSE;
    305     break;
    306   case RPT_WRITETEXT:
    307     if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_in_u.mem))
    308       return FALSE;
    309     break;
    310   case RPT_WRITEDATA:
    311     if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_in_u.mem))
    312       return FALSE;
    313     break;
    314   case RPT_SETBREAK:
    315     if (!xdr_xdr_break (xdrs, &objp->ptrace_addr_data_in_u.breakp))
    316       return FALSE;
    317     break;
    318   default:
    319     if (!xdr_u_int (xdrs, &objp->ptrace_addr_data_in_u.address))
    320       return FALSE;
    321     break;
    322   }
    323   return TRUE;
    324 }
    325 
    326 bool_t
    327 xdr_ptrace_addr_data_out (XDR * xdrs, ptrace_addr_data_out * objp)
    328 {
    329   register int32_t *buf;
    330 
    331   if (!xdr_ptracereq (xdrs, &objp->req))
    332     return FALSE;
    333   switch (objp->req) {
    334   case RPT_GETREGS:
    335     if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_out_u.regs))
    336       return FALSE;
    337     break;
    338   case RPT_GETTHREADREGS:
    339     if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_out_u.regs))
    340       return FALSE;
    341     break;
    342   case RPT_PGETREGS:
    343     if (!xdr_array
    344         (xdrs, (char **) &objp->ptrace_addr_data_out_u.pregs.pregs_val,
    345          (u_int *) & objp->ptrace_addr_data_out_u.pregs.pregs_len, ~0,
    346          sizeof (u_int), (xdrproc_t) xdr_u_int))
    347       return FALSE;
    348     break;
    349   case RPT_PGETTHREADREGS:
    350     if (!xdr_array
    351         (xdrs, (char **) &objp->ptrace_addr_data_out_u.pregs.pregs_val,
    352          (u_int *) & objp->ptrace_addr_data_out_u.pregs.pregs_len, ~0,
    353          sizeof (u_int), (xdrproc_t) xdr_u_int))
    354       return FALSE;
    355     break;
    356   case RPT_THREADLIST:
    357     if (!xdr_thread_list (xdrs, &objp->ptrace_addr_data_out_u.threads))
    358       return FALSE;
    359     break;
    360   case RPT_GETTHREADNAME:
    361     if (!xdr_thread_name (xdrs, &objp->ptrace_addr_data_out_u.name))
    362       return FALSE;
    363     break;
    364   case RPT_READTEXT:
    365     if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_out_u.mem))
    366       return FALSE;
    367     break;
    368   case RPT_GETNAME:
    369     if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_out_u.mem))
    370       return FALSE;
    371     break;
    372   case RPT_READDATA:
    373     if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_out_u.mem))
    374       return FALSE;
    375     break;
    376   case RPT_GETBREAK:
    377     if (!xdr_xdr_break (xdrs, &objp->ptrace_addr_data_out_u.breakp))
    378       return FALSE;
    379     break;
    380   default:
    381     if (!xdr_u_int (xdrs, &objp->ptrace_addr_data_out_u.addr))
    382       return FALSE;
    383     break;
    384   }
    385   return TRUE;
    386 }
    387 
    388 bool_t
    389 xdr_CHAR_DATA (XDR * xdrs, CHAR_DATA * objp)
    390 {
    391   register int32_t *buf;
    392 
    393   if (!xdr_bytes
    394       (xdrs, (char **) &objp->CHAR_DATA_val, (u_int *) & objp->CHAR_DATA_len,
    395        NET_SAFE))
    396     return FALSE;
    397   return TRUE;
    398 }
    399 
    400 #ifndef XRY_MAX_CMD_STR
    401 #endif /* REMDEB_H */
    402 
    403 bool_t
    404 xdr_xry_inst (XDR * xdrs, xry_inst * objp)
    405 {
    406   register int32_t *buf;
    407 
    408   if (!xdr_u_char (xdrs, &objp->flags))
    409     return FALSE;
    410   if (!xdr_u_char (xdrs, &objp->type))
    411     return FALSE;
    412   if (!xdr_u_char (xdrs, &objp->sub_type))
    413     return FALSE;
    414   if (!xdr_u_char (xdrs, &objp->res_type))
    415     return FALSE;
    416   if (!xdr_u_long (xdrs, &objp->value))
    417     return FALSE;
    418   if (!xdr_u_long (xdrs, &objp->value2))
    419     return FALSE;
    420   return TRUE;
    421 }
    422 
    423 bool_t
    424 xdr_instance (XDR * xdrs, instance * objp)
    425 {
    426   register int32_t *buf;
    427 
    428   int i;
    429   if (!xdr_vector (xdrs, (char *) objp->instances, XRY_MAX_INSTANCES,
    430                    sizeof (xry_inst), (xdrproc_t) xdr_xry_inst))
    431     return FALSE;
    432   if (!xdr_vector (xdrs, (char *) objp->buffer, XRY_MAX_INST_BUFF,
    433                    sizeof (u_char), (xdrproc_t) xdr_u_char))
    434     return FALSE;
    435   return TRUE;
    436 }
    437 
    438 bool_t
    439 xdr_instance_union (XDR * xdrs, instance_union * objp)
    440 {
    441   register int32_t *buf;
    442 
    443   if (!xdr_bool (xdrs, &objp->instances))
    444     return FALSE;
    445   switch (objp->instances) {
    446   case TRUE:
    447     if (!xdr_instance (xdrs, &objp->instance_union_u.inst))
    448       return FALSE;
    449     break;
    450   case FALSE:
    451     if (!xdr_string (xdrs, &objp->instance_union_u.buffer, XRY_MAX_CMD_STR))
    452       return FALSE;
    453     break;
    454   default:
    455     return FALSE;
    456   }
    457   return TRUE;
    458 }
    459 
    460 bool_t
    461 xdr_one_arg (XDR * xdrs, one_arg * objp)
    462 {
    463   register int32_t *buf;
    464 
    465   if (!xdr_string (xdrs, objp, NET_SAFE))
    466     return FALSE;
    467   return TRUE;
    468 }
    469 
    470   /*
    471    * now open_connex() routine which establishes a connection to server
    472    */
    473 
    474 bool_t
    475 xdr_debug_type (XDR * xdrs, debug_type * objp)
    476 {
    477   register int32_t *buf;
    478 
    479   if (!xdr_enum (xdrs, (enum_t *) objp))
    480     return FALSE;
    481   return TRUE;
    482 }
    483 
    484 #define DEBUGGER_IS_GDB 0x2     /* */
    485 
    486 bool_t
    487 xdr_open_in (XDR * xdrs, open_in * objp)
    488 {
    489   register int32_t *buf;
    490 
    491   int i;
    492   if (!xdr_vector (xdrs, (char *) objp->back_port, 16,
    493                    sizeof (u_char), (xdrproc_t) xdr_u_char))
    494     return FALSE;
    495   if (!xdr_u_short (xdrs, &objp->debug_type))
    496     return FALSE;
    497   if (!xdr_u_short (xdrs, &objp->flags))
    498     return FALSE;
    499   if (!xdr_vector (xdrs, (char *) objp->destination, 16,
    500                    sizeof (u_char), (xdrproc_t) xdr_u_char))
    501     return FALSE;
    502   if (!xdr_one_arg (xdrs, &objp->user_name))
    503     return FALSE;
    504   return TRUE;
    505 }
    506 
    507 bool_t
    508 xdr_open_out (XDR * xdrs, open_out * objp)
    509 {
    510   register int32_t *buf;
    511 
    512   int i;
    513 
    514   if (xdrs->x_op == XDR_ENCODE) {
    515     buf = XDR_INLINE (xdrs, (2 + (4)) * BYTES_PER_XDR_UNIT);
    516     if (buf == NULL) {
    517       if (!xdr_u_long (xdrs, &objp->port))
    518         return FALSE;
    519       if (!xdr_vector (xdrs, (char *) objp->pad, 4,
    520                        sizeof (u_int), (xdrproc_t) xdr_u_int))
    521         return FALSE;
    522       if (!xdr_u_int (xdrs, &objp->fp))
    523         return FALSE;
    524 
    525     } else {
    526       IXDR_PUT_U_LONG (buf, objp->port);
    527       {
    528         register u_int *genp;
    529 
    530         for (i = 0, genp = objp->pad; i < 4; ++i) {
    531           IXDR_PUT_U_LONG (buf, *genp++);
    532         }
    533       }
    534       IXDR_PUT_U_LONG (buf, objp->fp);
    535     }
    536     if (!xdr_u_char (xdrs, &objp->cmd_table_num))
    537       return FALSE;
    538     if (!xdr_u_char (xdrs, &objp->cmd_table_vers))
    539       return FALSE;
    540     if (!xdr_u_short (xdrs, &objp->server_vers))
    541       return FALSE;
    542     return TRUE;
    543   } else if (xdrs->x_op == XDR_DECODE) {
    544     buf = XDR_INLINE (xdrs, (2 + (4)) * BYTES_PER_XDR_UNIT);
    545     if (buf == NULL) {
    546       if (!xdr_u_long (xdrs, &objp->port))
    547         return FALSE;
    548       if (!xdr_vector (xdrs, (char *) objp->pad, 4,
    549                        sizeof (u_int), (xdrproc_t) xdr_u_int))
    550         return FALSE;
    551       if (!xdr_u_int (xdrs, &objp->fp))
    552         return FALSE;
    553 
    554     } else {
    555       objp->port = IXDR_GET_U_LONG (buf);
    556       {
    557         register u_int *genp;
    558 
    559         for (i = 0, genp = objp->pad; i < 4; ++i) {
    560           *genp++ = IXDR_GET_U_LONG (buf);
    561         }
    562       }
    563       objp->fp = IXDR_GET_U_LONG (buf);
    564     }
    565     if (!xdr_u_char (xdrs, &objp->cmd_table_num))
    566       return FALSE;
    567     if (!xdr_u_char (xdrs, &objp->cmd_table_vers))
    568       return FALSE;
    569     if (!xdr_u_short (xdrs, &objp->server_vers))
    570       return FALSE;
    571     return TRUE;
    572   }
    573 
    574   if (!xdr_u_long (xdrs, &objp->port))
    575     return FALSE;
    576   if (!xdr_vector (xdrs, (char *) objp->pad, 4,
    577                    sizeof (u_int), (xdrproc_t) xdr_u_int))
    578     return FALSE;
    579   if (!xdr_u_int (xdrs, &objp->fp))
    580     return FALSE;
    581   if (!xdr_u_char (xdrs, &objp->cmd_table_num))
    582     return FALSE;
    583   if (!xdr_u_char (xdrs, &objp->cmd_table_vers))
    584     return FALSE;
    585   if (!xdr_u_short (xdrs, &objp->server_vers))
    586     return FALSE;
    587   return TRUE;
    588 }
    589 
    590   /*
    591    * now close_connex() routine which detaches from server
    592    */
    593 
    594 bool_t
    595 xdr_close_control (XDR * xdrs, close_control * objp)
    596 {
    597   register int32_t *buf;
    598 
    599   if (!xdr_enum (xdrs, (enum_t *) objp))
    600     return FALSE;
    601   return TRUE;
    602 }
    603 
    604 bool_t
    605 xdr_close_in (XDR * xdrs, close_in * objp)
    606 {
    607   register int32_t *buf;
    608 
    609   if (!xdr_close_control (xdrs, &objp->control))
    610     return FALSE;
    611   return TRUE;
    612 }
    613 
    614   /*
    615    * now send_signal() routine which sends signals to processes like kill(2)
    616    */
    617 
    618 bool_t
    619 xdr_signal_in (XDR * xdrs, signal_in * objp)
    620 {
    621   register int32_t *buf;
    622 
    623   if (!xdr_int (xdrs, &objp->pid))
    624     return FALSE;
    625   if (!xdr_int (xdrs, &objp->sig))
    626     return FALSE;
    627   return TRUE;
    628 }
    629 
    630 bool_t
    631 xdr_signal_out (XDR * xdrs, signal_out * objp)
    632 {
    633   register int32_t *buf;
    634 
    635   if (!xdr_int (xdrs, &objp->kill_return))
    636     return FALSE;
    637   if (!xdr_int (xdrs, &objp->errNo))
    638     return FALSE;
    639   return TRUE;
    640 }
    641 
    642   /*
    643    * now wait_info() routine which returns results of polling the wait status
    644    * of a process/actor. It may return 0 if running, else pid or -1
    645    */
    646 
    647 bool_t
    648 xdr_stop_code (XDR * xdrs, stop_code * objp)
    649 {
    650   register int32_t *buf;
    651 
    652   if (!xdr_enum (xdrs, (enum_t *) objp))
    653     return FALSE;
    654   return TRUE;
    655 }
    656 
    657 bool_t
    658 xdr_wait_in (XDR * xdrs, wait_in * objp)
    659 {
    660   register int32_t *buf;
    661 
    662   if (!xdr_int (xdrs, &objp->pid))
    663     return FALSE;
    664   return TRUE;
    665 }
    666 
    667 bool_t
    668 xdr_wait_out (XDR * xdrs, wait_out * objp)
    669 {
    670   register int32_t *buf;
    671 
    672   if (xdrs->x_op == XDR_ENCODE) {
    673     buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
    674     if (buf == NULL) {
    675       if (!xdr_int (xdrs, &objp->wait_return))
    676         return FALSE;
    677       if (!xdr_int (xdrs, &objp->errNo))
    678         return FALSE;
    679       if (!xdr_int (xdrs, &objp->status))
    680         return FALSE;
    681 
    682     } else {
    683       IXDR_PUT_LONG (buf, objp->wait_return);
    684       IXDR_PUT_LONG (buf, objp->errNo);
    685       IXDR_PUT_LONG (buf, objp->status);
    686     }
    687     if (!xdr_stop_code (xdrs, &objp->reason))
    688       return FALSE;
    689     buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
    690     if (buf == NULL) {
    691       if (!xdr_int (xdrs, &objp->handle))
    692         return FALSE;
    693       if (!xdr_u_long (xdrs, &objp->PC))
    694         return FALSE;
    695       if (!xdr_u_long (xdrs, &objp->SP))
    696         return FALSE;
    697       if (!xdr_u_long (xdrs, &objp->FP))
    698         return FALSE;
    699       if (!xdr_u_long (xdrs, &objp->thread))
    700         return FALSE;
    701     } else {
    702       IXDR_PUT_LONG (buf, objp->handle);
    703       IXDR_PUT_U_LONG (buf, objp->PC);
    704       IXDR_PUT_U_LONG (buf, objp->SP);
    705       IXDR_PUT_U_LONG (buf, objp->FP);
    706       IXDR_PUT_U_LONG (buf, objp->thread);
    707     }
    708     return TRUE;
    709   } else if (xdrs->x_op == XDR_DECODE) {
    710     buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
    711     if (buf == NULL) {
    712       if (!xdr_int (xdrs, &objp->wait_return))
    713         return FALSE;
    714       if (!xdr_int (xdrs, &objp->errNo))
    715         return FALSE;
    716       if (!xdr_int (xdrs, &objp->status))
    717         return FALSE;
    718 
    719     } else {
    720       objp->wait_return = IXDR_GET_LONG (buf);
    721       objp->errNo = IXDR_GET_LONG (buf);
    722       objp->status = IXDR_GET_LONG (buf);
    723     }
    724     if (!xdr_stop_code (xdrs, &objp->reason))
    725       return FALSE;
    726     buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
    727     if (buf == NULL) {
    728       if (!xdr_int (xdrs, &objp->handle))
    729         return FALSE;
    730       if (!xdr_u_long (xdrs, &objp->PC))
    731         return FALSE;
    732       if (!xdr_u_long (xdrs, &objp->SP))
    733         return FALSE;
    734       if (!xdr_u_long (xdrs, &objp->FP))
    735         return FALSE;
    736       if (!xdr_u_long (xdrs, &objp->thread))
    737         return FALSE;
    738     } else {
    739       objp->handle = IXDR_GET_LONG (buf);
    740       objp->PC = IXDR_GET_U_LONG (buf);
    741       objp->SP = IXDR_GET_U_LONG (buf);
    742       objp->FP = IXDR_GET_U_LONG (buf);
    743       objp->thread = IXDR_GET_U_LONG (buf);
    744     }
    745     return TRUE;
    746   }
    747 
    748   if (!xdr_int (xdrs, &objp->wait_return))
    749     return FALSE;
    750   if (!xdr_int (xdrs, &objp->errNo))
    751     return FALSE;
    752   if (!xdr_int (xdrs, &objp->status))
    753     return FALSE;
    754   if (!xdr_stop_code (xdrs, &objp->reason))
    755     return FALSE;
    756   if (!xdr_int (xdrs, &objp->handle))
    757     return FALSE;
    758   if (!xdr_u_long (xdrs, &objp->PC))
    759     return FALSE;
    760   if (!xdr_u_long (xdrs, &objp->SP))
    761     return FALSE;
    762   if (!xdr_u_long (xdrs, &objp->FP))
    763     return FALSE;
    764   if (!xdr_u_long (xdrs, &objp->thread))
    765     return FALSE;
    766   return TRUE;
    767 }
    768 
    769   /*
    770    * now ptrace() routine. This matches the Sun UNIX ptrace as well as
    771    * some additions
    772    */
    773 
    774 bool_t
    775 xdr_ptrace_in (XDR * xdrs, ptrace_in * objp)
    776 {
    777   register int32_t *buf;
    778 
    779   if (!xdr_int (xdrs, &objp->pid))
    780     return FALSE;
    781   if (!xdr_ptrace_addr_data_in (xdrs, &objp->addr))
    782     return FALSE;
    783   if (!xdr_u_int (xdrs, &objp->data))
    784     return FALSE;
    785   if (!xdr_u_int (xdrs, &objp->flags))
    786     return FALSE;
    787   return TRUE;
    788 }
    789 
    790 bool_t
    791 xdr_ptrace_out (XDR * xdrs, ptrace_out * objp)
    792 {
    793   register int32_t *buf;
    794 
    795   if (!xdr_ptrace_addr_data_out (xdrs, &objp->addr))
    796     return FALSE;
    797   if (!xdr_int (xdrs, &objp->result))
    798     return FALSE;
    799   if (!xdr_int (xdrs, &objp->errNo))
    800     return FALSE;
    801   return TRUE;
    802 }
    803 
    804 bool_t
    805 xdr_one_symbol (XDR * xdrs, one_symbol * objp)
    806 {
    807   register int32_t *buf;
    808 
    809   if (!xdr_string (xdrs, &objp->symbolName, ~0))
    810     return FALSE;
    811   if (!xdr_long (xdrs, &objp->symbolValue))
    812     return FALSE;
    813   return TRUE;
    814 }
    815 
    816 bool_t
    817 xdr_all_symbols (XDR * xdrs, all_symbols * objp)
    818 {
    819   register int32_t *buf;
    820 
    821   if (!xdr_array
    822       (xdrs, (char **) &objp->all_symbols_val,
    823        (u_int *) & objp->all_symbols_len, ~0, sizeof (one_symbol),
    824        (xdrproc_t) xdr_one_symbol))
    825     return FALSE;
    826   return TRUE;
    827 }
    828 
    829 bool_t
    830 xdr_get_global_symbols_out (XDR * xdrs, get_global_symbols_out * objp)
    831 {
    832   register int32_t *buf;
    833 
    834   if (!xdr_all_symbols (xdrs, &objp->symbols))
    835     return FALSE;
    836   return TRUE;
    837 }
    838 
    839 bool_t
    840 xdr_get_text_data_in (XDR * xdrs, get_text_data_in * objp)
    841 {
    842   register int32_t *buf;
    843 
    844   if (!xdr_int (xdrs, &objp->pid))
    845     return FALSE;
    846   if (!xdr_string (xdrs, &objp->actorName, 16))
    847     return FALSE;
    848   return TRUE;
    849 }
    850 
    851 bool_t
    852 xdr_get_text_data_out (XDR * xdrs, get_text_data_out * objp)
    853 {
    854   register int32_t *buf;
    855 
    856   if (xdrs->x_op == XDR_ENCODE) {
    857     buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
    858     if (buf == NULL) {
    859       if (!xdr_int (xdrs, &objp->result))
    860         return FALSE;
    861       if (!xdr_int (xdrs, &objp->errNo))
    862         return FALSE;
    863       if (!xdr_u_long (xdrs, &objp->textStart))
    864         return FALSE;
    865       if (!xdr_u_long (xdrs, &objp->textSize))
    866         return FALSE;
    867       if (!xdr_u_long (xdrs, &objp->dataStart))
    868         return FALSE;
    869       if (!xdr_u_long (xdrs, &objp->dataSize))
    870         return FALSE;
    871     } else {
    872       IXDR_PUT_LONG (buf, objp->result);
    873       IXDR_PUT_LONG (buf, objp->errNo);
    874       IXDR_PUT_U_LONG (buf, objp->textStart);
    875       IXDR_PUT_U_LONG (buf, objp->textSize);
    876       IXDR_PUT_U_LONG (buf, objp->dataStart);
    877       IXDR_PUT_U_LONG (buf, objp->dataSize);
    878     }
    879     return TRUE;
    880   } else if (xdrs->x_op == XDR_DECODE) {
    881     buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
    882     if (buf == NULL) {
    883       if (!xdr_int (xdrs, &objp->result))
    884         return FALSE;
    885       if (!xdr_int (xdrs, &objp->errNo))
    886         return FALSE;
    887       if (!xdr_u_long (xdrs, &objp->textStart))
    888         return FALSE;
    889       if (!xdr_u_long (xdrs, &objp->textSize))
    890         return FALSE;
    891       if (!xdr_u_long (xdrs, &objp->dataStart))
    892         return FALSE;
    893       if (!xdr_u_long (xdrs, &objp->dataSize))
    894         return FALSE;
    895     } else {
    896       objp->result = IXDR_GET_LONG (buf);
    897       objp->errNo = IXDR_GET_LONG (buf);
    898       objp->textStart = IXDR_GET_U_LONG (buf);
    899       objp->textSize = IXDR_GET_U_LONG (buf);
    900       objp->dataStart = IXDR_GET_U_LONG (buf);
    901       objp->dataSize = IXDR_GET_U_LONG (buf);
    902     }
    903     return TRUE;
    904   }
    905 
    906   if (!xdr_int (xdrs, &objp->result))
    907     return FALSE;
    908   if (!xdr_int (xdrs, &objp->errNo))
    909     return FALSE;
    910   if (!xdr_u_long (xdrs, &objp->textStart))
    911     return FALSE;
    912   if (!xdr_u_long (xdrs, &objp->textSize))
    913     return FALSE;
    914   if (!xdr_u_long (xdrs, &objp->dataStart))
    915     return FALSE;
    916   if (!xdr_u_long (xdrs, &objp->dataSize))
    917     return FALSE;
    918   return TRUE;
    919 }
    920 
    921 bool_t
    922 xdr_one_signal (XDR * xdrs, one_signal * objp)
    923 {
    924   register int32_t *buf;
    925 
    926   if (!xdr_u_int (xdrs, &objp->number))
    927     return FALSE;
    928   if (!xdr_string (xdrs, &objp->name, ~0))
    929     return FALSE;
    930   return TRUE;
    931 }
    932 
    933 bool_t
    934 xdr_all_signals (XDR * xdrs, all_signals * objp)
    935 {
    936   register int32_t *buf;
    937 
    938   if (!xdr_array
    939       (xdrs, (char **) &objp->all_signals_val,
    940        (u_int *) & objp->all_signals_len, ~0, sizeof (one_signal),
    941        (xdrproc_t) xdr_one_signal))
    942     return FALSE;
    943   return TRUE;
    944 }
    945 
    946 bool_t
    947 xdr_get_signal_names_out (XDR * xdrs, get_signal_names_out * objp)
    948 {
    949   register int32_t *buf;
    950 
    951   if (!xdr_all_signals (xdrs, &objp->signals))
    952     return FALSE;
    953   return TRUE;
    954 }
    955 
    956   /*
    957    * now define the actual calls we support
    958    */
     107bool_t xdr_xdr_mem(xdrs, objp)
     108 XDR *xdrs;
     109 struct xdr_mem *objp;
     110{
     111 if (!xdr_u_long(xdrs, &objp->addr)) {
     112 return (FALSE);
     113 }
     114 if (!xdr_u_int(xdrs, &objp->dataNb)) {
     115 return(FALSE);
     116 }
     117 return (xdr_opaque(xdrs, objp->data, objp->dataNb));
     118}
     119
     120bool_t
     121xdr_break_type (XDR *xdrs, break_type *objp)
     122{
     123        register int32_t *buf;
     124
     125         if (!xdr_enum (xdrs, (enum_t *) objp))
     126                 return FALSE;
     127        return TRUE;
     128}
     129
     130bool_t
     131xdr_xdr_break (XDR *xdrs, xdr_break *objp)
     132{
     133        register int32_t *buf;
     134
     135        int i;
     136
     137        if (xdrs->x_op == XDR_ENCODE) {
     138                 if (!xdr_u_char (xdrs, &objp->type))
     139                         return FALSE;
     140                 if (!xdr_u_char (xdrs, &objp->thread_spec))
     141                         return FALSE;
     142                buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
     143                if (buf == NULL) {
     144                         if (!xdr_u_short (xdrs, &objp->handle))
     145                                 return FALSE;
     146                         if (!xdr_u_long (xdrs, &objp->ee_loc))
     147                                 return FALSE;
     148                         if (!xdr_u_long (xdrs, &objp->ee_type))
     149                                 return FALSE;
     150                         if (!xdr_u_short (xdrs, &objp->length))
     151                                 return FALSE;
     152
     153                } else {
     154                IXDR_PUT_U_SHORT(buf, objp->handle);
     155                IXDR_PUT_U_LONG(buf, objp->ee_loc);
     156                IXDR_PUT_U_LONG(buf, objp->ee_type);
     157                IXDR_PUT_U_SHORT(buf, objp->length);
     158                }
     159                 if (!xdr_u_char (xdrs, &objp->pass_count))
     160                         return FALSE;
     161                 if (!xdr_u_char (xdrs, &objp->curr_pass))
     162                         return FALSE;
     163                buf = XDR_INLINE (xdrs, ( MAX_THRD_BRK ) * BYTES_PER_XDR_UNIT);
     164                if (buf == NULL) {
     165                         if (!xdr_vector (xdrs, (char *)objp->thread_list, MAX_THRD_BRK,
     166                                sizeof (u_long), (xdrproc_t) xdr_u_long))
     167                                 return FALSE;
     168                } else {
     169                        {
     170                                register u_long *genp;
     171
     172                                for (i = 0, genp = objp->thread_list;
     173                                        i < MAX_THRD_BRK; ++i) {
     174                                        IXDR_PUT_U_LONG(buf, *genp++);
     175                                }
     176                        }
     177                }
     178                return TRUE;
     179        } else if (xdrs->x_op == XDR_DECODE) {
     180                 if (!xdr_u_char (xdrs, &objp->type))
     181                         return FALSE;
     182                 if (!xdr_u_char (xdrs, &objp->thread_spec))
     183                         return FALSE;
     184                buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
     185                if (buf == NULL) {
     186                         if (!xdr_u_short (xdrs, &objp->handle))
     187                                 return FALSE;
     188                         if (!xdr_u_long (xdrs, &objp->ee_loc))
     189                                 return FALSE;
     190                         if (!xdr_u_long (xdrs, &objp->ee_type))
     191                                 return FALSE;
     192                         if (!xdr_u_short (xdrs, &objp->length))
     193                                 return FALSE;
     194
     195                } else {
     196                objp->handle = IXDR_GET_U_SHORT(buf);
     197                objp->ee_loc = IXDR_GET_U_LONG(buf);
     198                objp->ee_type = IXDR_GET_U_LONG(buf);
     199                objp->length = IXDR_GET_U_SHORT(buf);
     200                }
     201                 if (!xdr_u_char (xdrs, &objp->pass_count))
     202                         return FALSE;
     203                 if (!xdr_u_char (xdrs, &objp->curr_pass))
     204                         return FALSE;
     205                buf = XDR_INLINE (xdrs, ( MAX_THRD_BRK ) * BYTES_PER_XDR_UNIT);
     206                if (buf == NULL) {
     207                         if (!xdr_vector (xdrs, (char *)objp->thread_list, MAX_THRD_BRK,
     208                                sizeof (u_long), (xdrproc_t) xdr_u_long))
     209                                 return FALSE;
     210                } else {
     211                        {
     212                                register u_long *genp;
     213
     214                                for (i = 0, genp = objp->thread_list;
     215                                        i < MAX_THRD_BRK; ++i) {
     216                                        *genp++ = IXDR_GET_U_LONG(buf);
     217                                }
     218                        }
     219                }
     220         return TRUE;
     221        }
     222
     223         if (!xdr_u_char (xdrs, &objp->type))
     224                 return FALSE;
     225         if (!xdr_u_char (xdrs, &objp->thread_spec))
     226                 return FALSE;
     227         if (!xdr_u_short (xdrs, &objp->handle))
     228                 return FALSE;
     229         if (!xdr_u_long (xdrs, &objp->ee_loc))
     230                 return FALSE;
     231         if (!xdr_u_long (xdrs, &objp->ee_type))
     232                 return FALSE;
     233         if (!xdr_u_short (xdrs, &objp->length))
     234                 return FALSE;
     235         if (!xdr_u_char (xdrs, &objp->pass_count))
     236                 return FALSE;
     237         if (!xdr_u_char (xdrs, &objp->curr_pass))
     238                 return FALSE;
     239         if (!xdr_vector (xdrs, (char *)objp->thread_list, MAX_THRD_BRK,
     240                sizeof (u_long), (xdrproc_t) xdr_u_long))
     241                 return FALSE;
     242        return TRUE;
     243}
     244
     245bool_t
     246xdr_thread_name (XDR *xdrs, thread_name *objp)
     247{
     248        register int32_t *buf;
     249
     250         if (!xdr_string (xdrs, objp, THREADNAMEMAX))
     251                 return FALSE;
     252        return TRUE;
     253}
     254
     255bool_t
     256xdr_KernThread (XDR *xdrs, KernThread *objp)
     257{
     258        register int32_t *buf;
     259
     260         if (!xdr_u_int (xdrs, &objp->threadLi))
     261                 return FALSE;
     262        return TRUE;
     263}
     264bool_t xdr_thread_list(xdrs, objp)
     265 XDR *xdrs;
     266 struct thread_list *objp;
     267{
     268 return (xdr_array(xdrs, (char**)&objp->threads, &objp->nbThread,
     269 UTHREAD_MAX, sizeof(KernThread), xdr_KernThread));
     270}
     271
     272bool_t
     273xdr_ptrace_addr_data_in (XDR *xdrs, ptrace_addr_data_in *objp)
     274{
     275        register int32_t *buf;
     276
     277         if (!xdr_ptracereq (xdrs, &objp->req))
     278                 return FALSE;
     279        switch (objp->req) {
     280        case RPT_SETTHREADREGS:
     281                 if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_in_u.regs))
     282                         return FALSE;
     283                break;
     284        case RPT_SETREGS:
     285                 if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_in_u.regs))
     286                         return FALSE;
     287                break;
     288        case RPT_PSETTHREADREGS:
     289                 if (!xdr_array (xdrs, (char **)&objp->ptrace_addr_data_in_u.pregs.pregs_val, (u_int *) &objp->ptrace_addr_data_in_u.pregs.pregs_len, ~0,
     290                        sizeof (u_int), (xdrproc_t) xdr_u_int))
     291                         return FALSE;
     292                break;
     293        case RPT_PSETREGS:
     294                 if (!xdr_array (xdrs, (char **)&objp->ptrace_addr_data_in_u.pregs.pregs_val, (u_int *) &objp->ptrace_addr_data_in_u.pregs.pregs_len, ~0,
     295                        sizeof (u_int), (xdrproc_t) xdr_u_int))
     296                         return FALSE;
     297                break;
     298        case RPT_SETTHREADNAME:
     299                 if (!xdr_thread_name (xdrs, &objp->ptrace_addr_data_in_u.name))
     300                         return FALSE;
     301                break;
     302        case RPT_WRITETEXT:
     303                 if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_in_u.mem))
     304                         return FALSE;
     305                break;
     306        case RPT_WRITEDATA:
     307                 if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_in_u.mem))
     308                         return FALSE;
     309                break;
     310        case RPT_SETBREAK:
     311                 if (!xdr_xdr_break (xdrs, &objp->ptrace_addr_data_in_u.breakp))
     312                         return FALSE;
     313                break;
     314        default:
     315                 if (!xdr_u_int (xdrs, &objp->ptrace_addr_data_in_u.address))
     316                         return FALSE;
     317                break;
     318        }
     319        return TRUE;
     320}
     321
     322bool_t
     323xdr_ptrace_addr_data_out (XDR *xdrs, ptrace_addr_data_out *objp)
     324{
     325        register int32_t *buf;
     326
     327         if (!xdr_ptracereq (xdrs, &objp->req))
     328                 return FALSE;
     329        switch (objp->req) {
     330        case RPT_GETREGS:
     331                 if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_out_u.regs))
     332                         return FALSE;
     333                break;
     334        case RPT_GETTHREADREGS:
     335                 if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_out_u.regs))
     336                         return FALSE;
     337                break;
     338        case RPT_PGETREGS:
     339                 if (!xdr_array (xdrs, (char **)&objp->ptrace_addr_data_out_u.pregs.pregs_val, (u_int *) &objp->ptrace_addr_data_out_u.pregs.pregs_len, ~0,
     340                        sizeof (u_int), (xdrproc_t) xdr_u_int))
     341                         return FALSE;
     342                break;
     343        case RPT_PGETTHREADREGS:
     344                 if (!xdr_array (xdrs, (char **)&objp->ptrace_addr_data_out_u.pregs.pregs_val, (u_int *) &objp->ptrace_addr_data_out_u.pregs.pregs_len, ~0,
     345                        sizeof (u_int), (xdrproc_t) xdr_u_int))
     346                         return FALSE;
     347                break;
     348        case RPT_THREADLIST:
     349                 if (!xdr_thread_list (xdrs, &objp->ptrace_addr_data_out_u.threads))
     350                         return FALSE;
     351                break;
     352        case RPT_GETTHREADNAME:
     353                 if (!xdr_thread_name (xdrs, &objp->ptrace_addr_data_out_u.name))
     354                         return FALSE;
     355                break;
     356        case RPT_READTEXT:
     357                 if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_out_u.mem))
     358                         return FALSE;
     359                break;
     360        case RPT_GETNAME:
     361                 if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_out_u.mem))
     362                         return FALSE;
     363                break;
     364        case RPT_READDATA:
     365                 if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_out_u.mem))
     366                         return FALSE;
     367                break;
     368        case RPT_GETBREAK:
     369                 if (!xdr_xdr_break (xdrs, &objp->ptrace_addr_data_out_u.breakp))
     370                         return FALSE;
     371                break;
     372        default:
     373                 if (!xdr_u_int (xdrs, &objp->ptrace_addr_data_out_u.addr))
     374                         return FALSE;
     375                break;
     376        }
     377        return TRUE;
     378}
     379
     380bool_t
     381xdr_CHAR_DATA (XDR *xdrs, CHAR_DATA *objp)
     382{
     383        register int32_t *buf;
     384
     385         if (!xdr_bytes (xdrs, (char **)&objp->CHAR_DATA_val, (u_int *) &objp->CHAR_DATA_len, NET_SAFE))
     386                 return FALSE;
     387        return TRUE;
     388}
     389
     390bool_t
     391xdr_one_arg (XDR *xdrs, one_arg *objp)
     392{
     393        register int32_t *buf;
     394
     395         if (!xdr_string (xdrs, objp, NET_SAFE))
     396                 return FALSE;
     397        return TRUE;
     398}
     399 /* now open_connex() routine which establishes a connection to server */
     400
     401bool_t
     402xdr_debug_type (XDR *xdrs, debug_type *objp)
     403{
     404        register int32_t *buf;
     405
     406         if (!xdr_enum (xdrs, (enum_t *) objp))
     407                 return FALSE;
     408        return TRUE;
     409}
     410#define DEBUGGER_IS_GDB 0x2 /* */
     411
     412bool_t
     413xdr_open_in (XDR *xdrs, open_in *objp)
     414{
     415        register int32_t *buf;
     416
     417        int i;
     418         if (!xdr_vector (xdrs, (char *)objp->back_port, 16,
     419                sizeof (u_char), (xdrproc_t) xdr_u_char))
     420                 return FALSE;
     421         if (!xdr_u_short (xdrs, &objp->debug_type))
     422                 return FALSE;
     423         if (!xdr_u_short (xdrs, &objp->flags))
     424                 return FALSE;
     425         if (!xdr_vector (xdrs, (char *)objp->destination, 16,
     426                sizeof (u_char), (xdrproc_t) xdr_u_char))
     427                 return FALSE;
     428         if (!xdr_one_arg (xdrs, &objp->user_name))
     429                 return FALSE;
     430        return TRUE;
     431}
     432
     433bool_t
     434xdr_open_out (XDR *xdrs, open_out *objp)
     435{
     436        register int32_t *buf;
     437
     438        int i;
     439
     440        if (xdrs->x_op == XDR_ENCODE) {
     441                buf = XDR_INLINE (xdrs, (2 + ( 4 )) * BYTES_PER_XDR_UNIT);
     442                if (buf == NULL) {
     443                         if (!xdr_u_long (xdrs, &objp->port))
     444                                 return FALSE;
     445                         if (!xdr_vector (xdrs, (char *)objp->pad, 4,
     446                                sizeof (u_int), (xdrproc_t) xdr_u_int))
     447                                 return FALSE;
     448                         if (!xdr_u_int (xdrs, &objp->fp))
     449                                 return FALSE;
     450
     451                } else {
     452                IXDR_PUT_U_LONG(buf, objp->port);
     453                {
     454                        register u_int *genp;
     455
     456                        for (i = 0, genp = objp->pad;
     457                                i < 4; ++i) {
     458                                IXDR_PUT_U_LONG(buf, *genp++);
     459                        }
     460                }
     461                IXDR_PUT_U_LONG(buf, objp->fp);
     462                }
     463                 if (!xdr_u_char (xdrs, &objp->cmd_table_num))
     464                         return FALSE;
     465                 if (!xdr_u_char (xdrs, &objp->cmd_table_vers))
     466                         return FALSE;
     467                 if (!xdr_u_short (xdrs, &objp->server_vers))
     468                         return FALSE;
     469                return TRUE;
     470        } else if (xdrs->x_op == XDR_DECODE) {
     471                buf = XDR_INLINE (xdrs, (2 + ( 4 )) * BYTES_PER_XDR_UNIT);
     472                if (buf == NULL) {
     473                         if (!xdr_u_long (xdrs, &objp->port))
     474                                 return FALSE;
     475                         if (!xdr_vector (xdrs, (char *)objp->pad, 4,
     476                                sizeof (u_int), (xdrproc_t) xdr_u_int))
     477                                 return FALSE;
     478                         if (!xdr_u_int (xdrs, &objp->fp))
     479                                 return FALSE;
     480
     481                } else {
     482                objp->port = IXDR_GET_U_LONG(buf);
     483                {
     484                        register u_int *genp;
     485
     486                        for (i = 0, genp = objp->pad;
     487                                i < 4; ++i) {
     488                                *genp++ = IXDR_GET_U_LONG(buf);
     489                        }
     490                }
     491                objp->fp = IXDR_GET_U_LONG(buf);
     492                }
     493                 if (!xdr_u_char (xdrs, &objp->cmd_table_num))
     494                         return FALSE;
     495                 if (!xdr_u_char (xdrs, &objp->cmd_table_vers))
     496                         return FALSE;
     497                 if (!xdr_u_short (xdrs, &objp->server_vers))
     498                         return FALSE;
     499         return TRUE;
     500        }
     501
     502         if (!xdr_u_long (xdrs, &objp->port))
     503                 return FALSE;
     504         if (!xdr_vector (xdrs, (char *)objp->pad, 4,
     505                sizeof (u_int), (xdrproc_t) xdr_u_int))
     506                 return FALSE;
     507         if (!xdr_u_int (xdrs, &objp->fp))
     508                 return FALSE;
     509         if (!xdr_u_char (xdrs, &objp->cmd_table_num))
     510                 return FALSE;
     511         if (!xdr_u_char (xdrs, &objp->cmd_table_vers))
     512                 return FALSE;
     513         if (!xdr_u_short (xdrs, &objp->server_vers))
     514                 return FALSE;
     515        return TRUE;
     516}
     517 /* now close_connex() routine which detaches from server */
     518
     519bool_t
     520xdr_close_control (XDR *xdrs, close_control *objp)
     521{
     522        register int32_t *buf;
     523
     524         if (!xdr_enum (xdrs, (enum_t *) objp))
     525                 return FALSE;
     526        return TRUE;
     527}
     528
     529bool_t
     530xdr_close_in (XDR *xdrs, close_in *objp)
     531{
     532        register int32_t *buf;
     533
     534         if (!xdr_close_control (xdrs, &objp->control))
     535                 return FALSE;
     536        return TRUE;
     537}
     538 /* now send_signal() routine which sends signals to processes like kill(2) */
     539
     540bool_t
     541xdr_signal_in (XDR *xdrs, signal_in *objp)
     542{
     543        register int32_t *buf;
     544
     545         if (!xdr_int (xdrs, &objp->pid))
     546                 return FALSE;
     547         if (!xdr_int (xdrs, &objp->sig))
     548                 return FALSE;
     549        return TRUE;
     550}
     551
     552bool_t
     553xdr_signal_out (XDR *xdrs, signal_out *objp)
     554{
     555        register int32_t *buf;
     556
     557         if (!xdr_int (xdrs, &objp->kill_return))
     558                 return FALSE;
     559         if (!xdr_int (xdrs, &objp->errNo))
     560                 return FALSE;
     561        return TRUE;
     562}
     563 /* now wait_info() routine which returns results of polling the wait status
     564        of a process/actor. It may return 0 if running, else pid or -1 */
     565
     566bool_t
     567xdr_stop_code (XDR *xdrs, stop_code *objp)
     568{
     569        register int32_t *buf;
     570
     571         if (!xdr_enum (xdrs, (enum_t *) objp))
     572                 return FALSE;
     573        return TRUE;
     574}
     575
     576bool_t
     577xdr_wait_in (XDR *xdrs, wait_in *objp)
     578{
     579        register int32_t *buf;
     580
     581         if (!xdr_int (xdrs, &objp->pid))
     582                 return FALSE;
     583        return TRUE;
     584}
     585
     586bool_t
     587xdr_wait_out (XDR *xdrs, wait_out *objp)
     588{
     589        register int32_t *buf;
     590
     591
     592        if (xdrs->x_op == XDR_ENCODE) {
     593                buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
     594                if (buf == NULL) {
     595                         if (!xdr_int (xdrs, &objp->wait_return))
     596                                 return FALSE;
     597                         if (!xdr_int (xdrs, &objp->errNo))
     598                                 return FALSE;
     599                         if (!xdr_int (xdrs, &objp->status))
     600                                 return FALSE;
     601
     602                } else {
     603                IXDR_PUT_LONG(buf, objp->wait_return);
     604                IXDR_PUT_LONG(buf, objp->errNo);
     605                IXDR_PUT_LONG(buf, objp->status);
     606                }
     607                 if (!xdr_stop_code (xdrs, &objp->reason))
     608                         return FALSE;
     609                buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
     610                if (buf == NULL) {
     611                         if (!xdr_int (xdrs, &objp->handle))
     612                                 return FALSE;
     613                         if (!xdr_u_long (xdrs, &objp->PC))
     614                                 return FALSE;
     615                         if (!xdr_u_long (xdrs, &objp->SP))
     616                                 return FALSE;
     617                         if (!xdr_u_long (xdrs, &objp->FP))
     618                                 return FALSE;
     619                         if (!xdr_u_long (xdrs, &objp->thread))
     620                                 return FALSE;
     621                } else {
     622                        IXDR_PUT_LONG(buf, objp->handle);
     623                        IXDR_PUT_U_LONG(buf, objp->PC);
     624                        IXDR_PUT_U_LONG(buf, objp->SP);
     625                        IXDR_PUT_U_LONG(buf, objp->FP);
     626                        IXDR_PUT_U_LONG(buf, objp->thread);
     627                }
     628                return TRUE;
     629        } else if (xdrs->x_op == XDR_DECODE) {
     630                buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
     631                if (buf == NULL) {
     632                         if (!xdr_int (xdrs, &objp->wait_return))
     633                                 return FALSE;
     634                         if (!xdr_int (xdrs, &objp->errNo))
     635                                 return FALSE;
     636                         if (!xdr_int (xdrs, &objp->status))
     637                                 return FALSE;
     638
     639                } else {
     640                objp->wait_return = IXDR_GET_LONG(buf);
     641                objp->errNo = IXDR_GET_LONG(buf);
     642                objp->status = IXDR_GET_LONG(buf);
     643                }
     644                 if (!xdr_stop_code (xdrs, &objp->reason))
     645                         return FALSE;
     646                buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
     647                if (buf == NULL) {
     648                         if (!xdr_int (xdrs, &objp->handle))
     649                                 return FALSE;
     650                         if (!xdr_u_long (xdrs, &objp->PC))
     651                                 return FALSE;
     652                         if (!xdr_u_long (xdrs, &objp->SP))
     653                                 return FALSE;
     654                         if (!xdr_u_long (xdrs, &objp->FP))
     655                                 return FALSE;
     656                         if (!xdr_u_long (xdrs, &objp->thread))
     657                                 return FALSE;
     658                } else {
     659                        objp->handle = IXDR_GET_LONG(buf);
     660                        objp->PC = IXDR_GET_U_LONG(buf);
     661                        objp->SP = IXDR_GET_U_LONG(buf);
     662                        objp->FP = IXDR_GET_U_LONG(buf);
     663                        objp->thread = IXDR_GET_U_LONG(buf);
     664                }
     665         return TRUE;
     666        }
     667
     668         if (!xdr_int (xdrs, &objp->wait_return))
     669                 return FALSE;
     670         if (!xdr_int (xdrs, &objp->errNo))
     671                 return FALSE;
     672         if (!xdr_int (xdrs, &objp->status))
     673                 return FALSE;
     674         if (!xdr_stop_code (xdrs, &objp->reason))
     675                 return FALSE;
     676         if (!xdr_int (xdrs, &objp->handle))
     677                 return FALSE;
     678         if (!xdr_u_long (xdrs, &objp->PC))
     679                 return FALSE;
     680         if (!xdr_u_long (xdrs, &objp->SP))
     681                 return FALSE;
     682         if (!xdr_u_long (xdrs, &objp->FP))
     683                 return FALSE;
     684         if (!xdr_u_long (xdrs, &objp->thread))
     685                 return FALSE;
     686        return TRUE;
     687}
     688 /* now ptrace() routine. This matches the Sun UNIX ptrace as well as
     689        some additions */
     690
     691bool_t
     692xdr_ptrace_in (XDR *xdrs, ptrace_in *objp)
     693{
     694        register int32_t *buf;
     695
     696         if (!xdr_int (xdrs, &objp->pid))
     697                 return FALSE;
     698         if (!xdr_ptrace_addr_data_in (xdrs, &objp->addr))
     699                 return FALSE;
     700         if (!xdr_u_int (xdrs, &objp->data))
     701                 return FALSE;
     702         if (!xdr_u_int (xdrs, &objp->flags))
     703                 return FALSE;
     704        return TRUE;
     705}
     706
     707bool_t
     708xdr_ptrace_out (XDR *xdrs, ptrace_out *objp)
     709{
     710        register int32_t *buf;
     711
     712         if (!xdr_ptrace_addr_data_out (xdrs, &objp->addr))
     713                 return FALSE;
     714         if (!xdr_int (xdrs, &objp->result))
     715                 return FALSE;
     716         if (!xdr_int (xdrs, &objp->errNo))
     717                 return FALSE;
     718        return TRUE;
     719}
     720
     721bool_t
     722xdr_one_symbol (XDR *xdrs, one_symbol *objp)
     723{
     724        register int32_t *buf;
     725
     726         if (!xdr_string (xdrs, &objp->symbolName, ~0))
     727                 return FALSE;
     728         if (!xdr_long (xdrs, &objp->symbolValue))
     729                 return FALSE;
     730        return TRUE;
     731}
     732
     733bool_t
     734xdr_all_symbols (XDR *xdrs, all_symbols *objp)
     735{
     736        register int32_t *buf;
     737
     738         if (!xdr_array (xdrs, (char **)&objp->all_symbols_val, (u_int *) &objp->all_symbols_len, ~0,
     739                sizeof (one_symbol), (xdrproc_t) xdr_one_symbol))
     740                 return FALSE;
     741        return TRUE;
     742}
     743
     744bool_t
     745xdr_get_global_symbols_out (XDR *xdrs, get_global_symbols_out *objp)
     746{
     747        register int32_t *buf;
     748
     749         if (!xdr_all_symbols (xdrs, &objp->symbols))
     750                 return FALSE;
     751        return TRUE;
     752}
     753
     754bool_t
     755xdr_get_text_data_in (XDR *xdrs, get_text_data_in *objp)
     756{
     757        register int32_t *buf;
     758
     759         if (!xdr_int (xdrs, &objp->pid))
     760                 return FALSE;
     761         if (!xdr_string (xdrs, &objp->actorName, 16))
     762                 return FALSE;
     763        return TRUE;
     764}
     765
     766bool_t
     767xdr_get_text_data_out (XDR *xdrs, get_text_data_out *objp)
     768{
     769        register int32_t *buf;
     770
     771
     772        if (xdrs->x_op == XDR_ENCODE) {
     773                buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
     774                if (buf == NULL) {
     775                         if (!xdr_int (xdrs, &objp->result))
     776                                 return FALSE;
     777                         if (!xdr_int (xdrs, &objp->errNo))
     778                                 return FALSE;
     779                         if (!xdr_u_long (xdrs, &objp->textStart))
     780                                 return FALSE;
     781                         if (!xdr_u_long (xdrs, &objp->textSize))
     782                                 return FALSE;
     783                         if (!xdr_u_long (xdrs, &objp->dataStart))
     784                                 return FALSE;
     785                         if (!xdr_u_long (xdrs, &objp->dataSize))
     786                                 return FALSE;
     787                } else {
     788                        IXDR_PUT_LONG(buf, objp->result);
     789                        IXDR_PUT_LONG(buf, objp->errNo);
     790                        IXDR_PUT_U_LONG(buf, objp->textStart);
     791                        IXDR_PUT_U_LONG(buf, objp->textSize);
     792                        IXDR_PUT_U_LONG(buf, objp->dataStart);
     793                        IXDR_PUT_U_LONG(buf, objp->dataSize);
     794                }
     795                return TRUE;
     796        } else if (xdrs->x_op == XDR_DECODE) {
     797                buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
     798                if (buf == NULL) {
     799                         if (!xdr_int (xdrs, &objp->result))
     800                                 return FALSE;
     801                         if (!xdr_int (xdrs, &objp->errNo))
     802                                 return FALSE;
     803                         if (!xdr_u_long (xdrs, &objp->textStart))
     804                                 return FALSE;
     805                         if (!xdr_u_long (xdrs, &objp->textSize))
     806                                 return FALSE;
     807                         if (!xdr_u_long (xdrs, &objp->dataStart))
     808                                 return FALSE;
     809                         if (!xdr_u_long (xdrs, &objp->dataSize))
     810                                 return FALSE;
     811                } else {
     812                        objp->result = IXDR_GET_LONG(buf);
     813                        objp->errNo = IXDR_GET_LONG(buf);
     814                        objp->textStart = IXDR_GET_U_LONG(buf);
     815                        objp->textSize = IXDR_GET_U_LONG(buf);
     816                        objp->dataStart = IXDR_GET_U_LONG(buf);
     817                        objp->dataSize = IXDR_GET_U_LONG(buf);
     818                }
     819         return TRUE;
     820        }
     821
     822         if (!xdr_int (xdrs, &objp->result))
     823                 return FALSE;
     824         if (!xdr_int (xdrs, &objp->errNo))
     825                 return FALSE;
     826         if (!xdr_u_long (xdrs, &objp->textStart))
     827                 return FALSE;
     828         if (!xdr_u_long (xdrs, &objp->textSize))
     829                 return FALSE;
     830         if (!xdr_u_long (xdrs, &objp->dataStart))
     831                 return FALSE;
     832         if (!xdr_u_long (xdrs, &objp->dataSize))
     833                 return FALSE;
     834        return TRUE;
     835}
     836
     837bool_t
     838xdr_one_signal (XDR *xdrs, one_signal *objp)
     839{
     840        register int32_t *buf;
     841
     842         if (!xdr_u_int (xdrs, &objp->number))
     843                 return FALSE;
     844         if (!xdr_string (xdrs, &objp->name, ~0))
     845                 return FALSE;
     846        return TRUE;
     847}
     848
     849bool_t
     850xdr_all_signals (XDR *xdrs, all_signals *objp)
     851{
     852        register int32_t *buf;
     853
     854         if (!xdr_array (xdrs, (char **)&objp->all_signals_val, (u_int *) &objp->all_signals_len, ~0,
     855                sizeof (one_signal), (xdrproc_t) xdr_one_signal))
     856                 return FALSE;
     857        return TRUE;
     858}
     859
     860bool_t
     861xdr_get_signal_names_out (XDR *xdrs, get_signal_names_out *objp)
     862{
     863        register int32_t *buf;
     864
     865         if (!xdr_all_signals (xdrs, &objp->signals))
     866                 return FALSE;
     867        return TRUE;
     868}
     869 /* now define the actual calls we support */

  • c/src/librdbg/src/m68k/any/remdeb.h

    rbdb86b4 r97f6256  
    99#include <rpc/rpc.h>
    1010
     11
    1112#ifdef __cplusplus
    1213extern "C" {
    … …  
    1617#define RTEMS_BACK_PORT 2073
    1718#ifndef REMDEB_H
    18 #define RPCGENSRVNAME(a)     a
    19 
    20   enum rpc_type {
    21     SUNRPC = 0,
    22     BADRPCTYPE = 25,
    23   };
    24   typedef enum rpc_type rpc_type;
     19#define RPCGENSRVNAME(a) a
     20
     21enum rpc_type {
     22        SUNRPC = 0,
     23        BADRPCTYPE = 25,
     24};
     25typedef enum rpc_type rpc_type;
    2526#define NET_SAFE 1400
    2627
    27   struct UDP_MSG {
    28     u_char type;
    29     u_char msg_num;
    30     u_short spec;
    31     long pid;
    32     u_long context;
    33   };
    34   typedef struct UDP_MSG UDP_MSG;
     28struct UDP_MSG {
     29        u_char type;
     30        u_char msg_num;
     31        u_short spec;
     32        long pid;
     33        u_long context;
     34};
     35typedef struct UDP_MSG UDP_MSG;
    3536/*
    3637 * Sun request values for the remote ptrace system call
    3738 */
    3839
    39   enum ptracereq {
    40     RPT_TRACEME = 0,
    41     RPT_CHILDDONE = 0,
    42     RPT_PEEKTEXT = 0 + 1,
    43     RPT_PEEKDATA = 0 + 2,
    44     RPT_PEEKUSER = 0 + 3,
    45     RPT_POKETEXT = 0 + 4,
    46     RPT_POKEDATA = 0 + 5,
    47     RPT_POKEUSER = 0 + 6,
    48     RPT_CONT = 0 + 7,
    49     RPT_KILL = 0 + 8,
    50     RPT_SINGLESTEP = 0 + 9,
    51     RPT_ATTACH = 0 + 10,
    52     RPT_DETACH = 0 + 11,
    53     RPT_GETREGS = 0 + 12,
    54     RPT_SETREGS = 0 + 13,
    55     RPT_GETFPREGS = 0 + 14,
    56     RPT_SETFPREGS = 0 + 15,
    57     RPT_READDATA = 0 + 16,
    58     RPT_WRITEDATA = 0 + 17,
    59     RPT_READTEXT = 0 + 18,
    60     RPT_WRITETEXT = 0 + 19,
    61     RPT_GETFPAREGS = 0 + 20,
    62     RPT_SETFPAREGS = 0 + 21,
    63     RPT_22 = 0 + 22,
    64     RPT_23 = 0 + 23,
    65     RPT_SYSCALL = 0 + 24,
    66     RPT_DUMPCORE = 0 + 25,
    67     RPT_26 = 0 + 26,
    68     RPT_27 = 0 + 27,
    69     RPT_28 = 0 + 28,
    70     RPT_GETUCODE = 0 + 29,
    71     RPT_GETTARGETTHREAD = 50,
    72     RPT_SETTARGETTHREAD = 51,
    73     RPT_THREADSUSPEND = 52,
    74     RPT_THREADRESUME = 53,
    75     RPT_THREADLIST = 54,
    76     RPT_GETTHREADNAME = 55,
    77     RPT_SETTHREADNAME = 56,
    78     RPT_SETTHREADREGS = 57,
    79     RPT_GETTHREADREGS = 58,
    80     RPT_STEPRANGE = 75,
    81     RPT_CONTTO = 76,
    82     RPT_SETBREAK = 77,
    83     RPT_CLRBREAK = 78,
    84     RPT_GETBREAK = 79,
    85     RPT_GETNAME = 80,
    86     RPT_STOP = 81,
    87     RPT_PGETREGS = 82,
    88     RPT_PSETREGS = 83,
    89     RPT_PSETTHREADREGS = 84,
    90     RPT_PGETTHREADREGS = 85,
    91   };
    92   typedef enum ptracereq ptracereq;
    93 
    94   struct xdr_regs {
    95     int r_dreg[8];
    96     int r_areg[8];
    97     int r_sr;
    98     int r_pc;
    99     int r_vec;
    100   };
    101   typedef struct xdr_regs xdr_regs;
     40
     41enum ptracereq {
     42        RPT_TRACEME = 0,
     43        RPT_CHILDDONE = 0,
     44        RPT_PEEKTEXT = 0 + 1,
     45        RPT_PEEKDATA = 0 + 2,
     46        RPT_PEEKUSER = 0 + 3,
     47        RPT_POKETEXT = 0 + 4,
     48        RPT_POKEDATA = 0 + 5,
     49        RPT_POKEUSER = 0 + 6,
     50        RPT_CONT = 0 + 7,
     51        RPT_KILL = 0 + 8,
     52        RPT_SINGLESTEP = 0 + 9,
     53        RPT_ATTACH = 0 + 10,
     54        RPT_DETACH = 0 + 11,
     55        RPT_GETREGS = 0 + 12,
     56        RPT_SETREGS = 0 + 13,
     57        RPT_GETFPREGS = 0 + 14,
     58        RPT_SETFPREGS = 0 + 15,
     59        RPT_READDATA = 0 + 16,
     60        RPT_WRITEDATA = 0 + 17,
     61        RPT_READTEXT = 0 + 18,
     62        RPT_WRITETEXT = 0 + 19,
     63        RPT_GETFPAREGS = 0 + 20,
     64        RPT_SETFPAREGS = 0 + 21,
     65        RPT_22 = 0 + 22,
     66        RPT_23 = 0 + 23,
     67        RPT_SYSCALL = 0 + 24,
     68        RPT_DUMPCORE = 0 + 25,
     69        RPT_26 = 0 + 26,
     70        RPT_27 = 0 + 27,
     71        RPT_28 = 0 + 28,
     72        RPT_GETUCODE = 0 + 29,
     73        RPT_GETTARGETTHREAD = 50,
     74        RPT_SETTARGETTHREAD = 51,
     75        RPT_THREADSUSPEND = 52,
     76        RPT_THREADRESUME = 53,
     77        RPT_THREADLIST = 54,
     78        RPT_GETTHREADNAME = 55,
     79        RPT_SETTHREADNAME = 56,
     80        RPT_SETTHREADREGS = 57,
     81        RPT_GETTHREADREGS = 58,
     82        RPT_STEPRANGE = 75,
     83        RPT_CONTTO = 76,
     84        RPT_SETBREAK = 77,
     85        RPT_CLRBREAK = 78,
     86        RPT_GETBREAK = 79,
     87        RPT_GETNAME = 80,
     88        RPT_STOP = 81,
     89        RPT_PGETREGS = 82,
     90        RPT_PSETREGS = 83,
     91        RPT_PSETTHREADREGS = 84,
     92        RPT_PGETTHREADREGS = 85,
     93};
     94typedef enum ptracereq ptracereq;
     95
     96struct xdr_regs {
     97        int r_dreg[8];
     98        int r_areg[8];
     99        int r_sr;
     100        int r_pc;
     101        int r_vec;
     102};
     103typedef struct xdr_regs xdr_regs;
    102104/* now define register macros to apply to xdr_reg struct */
    103105
    104 #define r_r0   r_dreg[0]        /* r0 for portability */
    105 #define r_sp   r_areg[7]        /* user stack pointer */
    106 #define r_ps   r_sr
    107 #define REG_PC r_pc             /* PC register offset */
    108 #define REG_SP r_areg[7]        /* SP register offset */
    109 #define REG_FP r_areg[6]        /* FP register offset */
     106#define r_r0 r_dreg[0] /* r0 for portability */
     107#define r_sp r_areg[7] /* user stack pointer */
     108#define r_ps r_sr
     109#define REG_PC r_pc /* PC register offset */
     110#define REG_SP r_areg[7] /* SP register offset */
     111#define REG_FP r_areg[6] /* FP register offset */
    110112/* now define the BREAKPOINT mask technique to a long word */
    111 #define SET_BREAK(l)   ((l&0x0000FFFF) | 0x4E4F0000)    /* TRAP 15 */
    112 #define IS_BREAK(l)    (((l) & 0xFFFF0000) == 0x4E4F0000)
     113#define SET_BREAK(l) ((l&0x0000FFFF) | 0x4E4F0000) /* TRAP 15 */
     114#define IS_BREAK(l) (((l) & 0xFFFF0000) == 0x4E4F0000)
    113115#define ORG_BREAK(c,p) (((c) & 0x0000FFFF) | ((p) & 0xFFFF0000))
    114 #define IS_STEP(regs)  ((regs).r_vec == 9)
    115 #define BREAK_ADJ      0
    116 #define BREAK_SIZE     2
    117 #define TARGET_PROC_TYPE  2
     116#define IS_STEP(regs) ((regs).r_vec == 9)
     117#define BREAK_ADJ 0
     118#define BREAK_SIZE 2
     119#define TARGET_PROC_TYPE 2
    118120#define MAXDEBUGGEE 150
    119121#define NAMEMAX 17
    120   /*
     122 /*
    121123   * Memory data for read/write text or data. The size is in data. The target
    122124   * addr is in the addr field.
    … …  
    127129#define MEM_DATA_MAX 256
    128130
    129   struct xdr_mem {
    130     u_long addr;
    131     u_int dataNb;
    132     u_char data[MEM_DATA_MAX];
    133   };
    134   typedef struct xdr_mem xdr_mem;
    135 
    136   enum break_type {
    137     BRKT_NONE = 0,
    138     BRKT_INSTR = 1,
    139     BRKT_READ = 2,
    140     BRKT_WRITE = 3,
    141     BRKT_ACCESS = 4,
    142     BRKT_EXEC = 5,
    143     BRKT_OS_CALL = 6,
    144     BRKT_OS_SWITCH = 7,
    145     BRKT_STEPEMUL = 8,
    146   };
    147   typedef enum break_type break_type;
     131struct xdr_mem {
     132        u_long addr;
     133        u_int dataNb;
     134        u_char data[MEM_DATA_MAX];
     135};
     136typedef struct xdr_mem xdr_mem;
     137
     138enum break_type {
     139        BRKT_NONE = 0,
     140        BRKT_INSTR = 1,
     141        BRKT_READ = 2,
     142        BRKT_WRITE = 3,
     143        BRKT_ACCESS = 4,
     144        BRKT_EXEC = 5,
     145        BRKT_OS_CALL = 6,
     146        BRKT_OS_SWITCH = 7,
     147        BRKT_STEPEMUL = 8,
     148};
     149typedef enum break_type break_type;
    148150#define MAX_THRD_BRK 4
    149151
    150   struct xdr_break {
    151     u_char type;
    152     u_char thread_spec;
    153     u_short handle;
    154     u_long ee_loc;
    155     u_long ee_type;
    156     u_short length;
    157     u_char pass_count;
    158     u_char curr_pass;
    159     u_long thread_list[MAX_THRD_BRK];
    160   };
    161   typedef struct xdr_break xdr_break;
     152struct xdr_break {
     153        u_char type;
     154        u_char thread_spec;
     155        u_short handle;
     156        u_long ee_loc;
     157        u_long ee_type;
     158        u_short length;
     159        u_char pass_count;
     160        u_char curr_pass;
     161        u_long thread_list[MAX_THRD_BRK];
     162};
     163typedef struct xdr_break xdr_break;
    162164#define UTHREAD_MAX 64
    163165#define THREADNAMEMAX 16
    164166
    165   typedef char *thread_name;
    166 
    167   struct KernThread {
    168     u_int threadLi;
    169   };
    170   typedef struct KernThread KernThread;
    171   typedef KernThread *ptThreadList;
    172 
    173   struct thread_list {
    174     u_int nbThread;
    175     ptThreadList threads;
    176   };
    177   typedef struct thread_list thread_list;
    178 
    179   struct ptrace_addr_data_in {
    180     ptracereq req;
    181     union {
    182       xdr_regs regs;
    183       struct {
    184         u_int pregs_len;
    185         u_int *pregs_val;
    186       } pregs;
    187       thread_name name;
    188       xdr_mem mem;
    189       xdr_break breakp;
    190       u_int address;
    191     } ptrace_addr_data_in_u;
    192   };
    193   typedef struct ptrace_addr_data_in ptrace_addr_data_in;
    194 
    195   struct ptrace_addr_data_out {
    196     ptracereq req;
    197     union {
    198       xdr_regs regs;
    199       struct {
    200         u_int pregs_len;
    201         u_int *pregs_val;
    202       } pregs;
    203       thread_list threads;
    204       thread_name name;
    205       xdr_mem mem;
    206       xdr_break breakp;
    207       u_int addr;
    208     } ptrace_addr_data_out_u;
    209   };
    210   typedef struct ptrace_addr_data_out ptrace_addr_data_out;
    211 
    212   typedef struct {
    213     u_int CHAR_DATA_len;
    214     char *CHAR_DATA_val;
    215   } CHAR_DATA;
    216 #define XRY_MAX_INST_BUFF 128
    217 #define XRY_MAX_INSTANCES 16
    218 #ifndef XRY_MAX_CMD_STR
    219 #define XRY_MAX_CMD_STR 320
    220 #endif                          /* REMDEB_H */
    221 
    222   struct xry_inst {
    223     u_char flags;
    224     u_char type;
    225     u_char sub_type;
    226     u_char res_type;
    227     u_long value;
    228     u_long value2;
    229   };
    230   typedef struct xry_inst xry_inst;
    231 
    232   struct instance {
    233     struct xry_inst instances[XRY_MAX_INSTANCES];
    234     u_char buffer[XRY_MAX_INST_BUFF];
    235   };
    236   typedef struct instance instance;
    237 
    238   struct instance_union {
    239     bool_t instances;
    240     union {
    241       instance inst;
    242       char *buffer;
    243     } instance_union_u;
    244   };
    245   typedef struct instance_union instance_union;
    246 
    247   typedef char *one_arg;
    248 #define XRY_MAX_OBJ_NAME 32
    249   /*
    250    * now open_connex() routine which establishes a connection to server
    251    */
    252 
    253   enum debug_type {
    254     DEBTYP_PROCESS = 0,
    255     DEBTYP_C_ACTOR = 1,
    256     DEBTYP_KERNEL = 2,
    257     DEBTYP_OTHER = 3,
    258   };
    259   typedef enum debug_type debug_type;
    260 #define DEBUGGER_IS_GDB 0x2     /* */
    261 
    262   struct open_in {
    263     u_char back_port[16];
    264     u_short debug_type;
    265     u_short flags;
    266     u_char destination[16];
    267     one_arg user_name;
    268   };
    269   typedef struct open_in open_in;
    270 
    271   struct open_out {
    272     u_long port;
    273     u_int pad[4];
    274     u_int fp;
    275     u_char cmd_table_num;
    276     u_char cmd_table_vers;
    277     u_short server_vers;
    278   };
    279   typedef struct open_out open_out;
    280   /*
    281    * now close_connex() routine which detaches from server
    282    */
    283 
    284   enum close_control {
    285     CLOSE_IGNORE = 0,
    286     CLOSE_KILL = 1,
    287     CLOSE_DETACH = 2,
    288   };
    289   typedef enum close_control close_control;
    290 
    291   struct close_in {
    292     close_control control;
    293   };
    294   typedef struct close_in close_in;
    295   /*
    296    * now send_signal() routine which sends signals to processes like kill(2)
    297    */
    298 
    299   struct signal_in {
    300     int pid;
    301     int sig;
    302   };
    303   typedef struct signal_in signal_in;
    304 
    305   struct signal_out {
    306     int kill_return;
    307     int errNo;
    308   };
    309   typedef struct signal_out signal_out;
    310   /*
    311    * now wait_info() routine which returns results of polling the wait status
    312    * of a process/actor. It may return 0 if running, else pid or -1
    313    */
    314 
    315   enum stop_code {
    316     STOP_ERROR = 0,
    317     STOP_NONE = 1,
    318     STOP_UNKNOWN = 2,
    319     STOP_BREAK = 3,
    320     STOP_STEP = 4,
    321     STOP_SIGNAL = 5,
    322     STOP_TERM_EXIT = 6,
    323     STOP_TERM_SIG = 7,
    324     STOP_DETACHED = 8,
    325     STOP_KILLED = 9,
    326     STOP_SPAWN_FAILED = 10,
    327   };
    328   typedef enum stop_code stop_code;
    329 
    330   struct wait_in {
    331     int pid;
    332   };
    333   typedef struct wait_in wait_in;
    334 
    335   struct wait_out {
    336     int wait_return;
    337     int errNo;
    338     int status;
    339     stop_code reason;
    340     int handle;
    341     u_long PC;
    342     u_long SP;
    343     u_long FP;
    344     u_long thread;
    345   };
    346   typedef struct wait_out wait_out;
    347   /*
    348    * now ptrace() routine. This matches the Sun UNIX ptrace as well as
    349    * some additions
    350    */
     167typedef char *thread_name;
     168
     169struct KernThread {
     170        u_int threadLi;
     171};
     172typedef struct KernThread KernThread;
     173typedef KernThread *ptThreadList;
     174
     175struct thread_list {
     176        u_int nbThread;
     177        ptThreadList threads;
     178};
     179typedef struct thread_list thread_list;
     180
     181struct ptrace_addr_data_in {
     182        ptracereq req;
     183        union {
     184                xdr_regs regs;
     185                struct {
     186                        u_int pregs_len;
     187                        u_int *pregs_val;
     188                } pregs;
     189                thread_name name;
     190                xdr_mem mem;
     191                xdr_break breakp;
     192                u_int address;
     193        } ptrace_addr_data_in_u;
     194};
     195typedef struct ptrace_addr_data_in ptrace_addr_data_in;
     196
     197struct ptrace_addr_data_out {
     198        ptracereq req;
     199        union {
     200                xdr_regs regs;
     201                struct {
     202                        u_int pregs_len;
     203                        u_int *pregs_val;
     204                } pregs;
     205                thread_list threads;
     206                thread_name name;
     207                xdr_mem mem;
     208                xdr_break breakp;
     209                u_int addr;
     210        } ptrace_addr_data_out_u;
     211};
     212typedef struct ptrace_addr_data_out ptrace_addr_data_out;
     213
     214typedef struct {
     215        u_int CHAR_DATA_len;
     216        char *CHAR_DATA_val;
     217} CHAR_DATA;
     218
     219typedef char *one_arg;
     220 /* now open_connex() routine which establishes a connection to server */
     221
     222enum debug_type {
     223        DEBTYP_PROCESS = 0,
     224        DEBTYP_C_ACTOR = 1,
     225        DEBTYP_KERNEL = 2,
     226        DEBTYP_OTHER = 3,
     227};
     228typedef enum debug_type debug_type;
     229#define DEBUGGER_IS_GDB 0x2 /* */
     230
     231struct open_in {
     232        u_char back_port[16];
     233        u_short debug_type;
     234        u_short flags;
     235        u_char destination[16];
     236        one_arg user_name;
     237};
     238typedef struct open_in open_in;
     239
     240struct open_out {
     241        u_long port;
     242        u_int pad[4];
     243        u_int fp;
     244        u_char cmd_table_num;
     245        u_char cmd_table_vers;
     246        u_short server_vers;
     247};
     248typedef struct open_out open_out;
     249 /* now close_connex() routine which detaches from server */
     250
     251enum close_control {
     252        CLOSE_IGNORE = 0,
     253        CLOSE_KILL = 1,
     254        CLOSE_DETACH = 2,
     255};
     256typedef enum close_control close_control;
     257
     258struct close_in {
     259        close_control control;
     260};
     261typedef struct close_in close_in;
     262 /* now send_signal() routine which sends signals to processes like kill(2) */
     263
     264struct signal_in {
     265        int pid;
     266        int sig;
     267};
     268typedef struct signal_in signal_in;
     269
     270struct signal_out {
     271        int kill_return;
     272        int errNo;
     273};
     274typedef struct signal_out signal_out;
     275 /* now wait_info() routine which returns results of polling the wait status
     276        of a process/actor. It may return 0 if running, else pid or -1 */
     277
     278enum stop_code {
     279        STOP_ERROR = 0,
     280        STOP_NONE = 1,
     281        STOP_UNKNOWN = 2,
     282        STOP_BREAK = 3,
     283        STOP_STEP = 4,
     284        STOP_SIGNAL = 5,
     285        STOP_TERM_EXIT = 6,
     286        STOP_TERM_SIG = 7,
     287        STOP_DETACHED = 8,
     288        STOP_KILLED = 9,
     289        STOP_SPAWN_FAILED = 10,
     290};
     291typedef enum stop_code stop_code;
     292
     293struct wait_in {
     294        int pid;
     295};
     296typedef struct wait_in wait_in;
     297
     298struct wait_out {
     299        int wait_return;
     300        int errNo;
     301        int status;
     302        stop_code reason;
     303        int handle;
     304        u_long PC;
     305        u_long SP;
     306        u_long FP;
     307        u_long thread;
     308};
     309typedef struct wait_out wait_out;
     310 /* now ptrace() routine. This matches the Sun UNIX ptrace as well as
     311        some additions */
    351312#define PTRFLG_FORCE 1
    352313#define PTRFLG_NON_OWNER 2
    … …  
    354315#define PTRDET_UNOWN 0x100
    355316
    356   struct ptrace_in {
    357     int pid;
    358     ptrace_addr_data_in addr;
    359     u_int data;
    360     u_int flags;
    361   };
    362   typedef struct ptrace_in ptrace_in;
    363 
    364   struct ptrace_out {
    365     ptrace_addr_data_out addr;
    366     int result;
    367     int errNo;
    368   };
    369   typedef struct ptrace_out ptrace_out;
    370 
    371   struct one_symbol {
    372     char *symbolName;
    373     long symbolValue;
    374   };
    375   typedef struct one_symbol one_symbol;
    376 
    377   typedef struct {
    378     u_int all_symbols_len;
    379     one_symbol *all_symbols_val;
    380   } all_symbols;
    381 
    382   struct get_global_symbols_out {
    383     all_symbols symbols;
    384   };
    385   typedef struct get_global_symbols_out get_global_symbols_out;
    386 
    387   struct get_text_data_in {
    388     int pid;
    389     char *actorName;
    390   };
    391   typedef struct get_text_data_in get_text_data_in;
    392 
    393   struct get_text_data_out {
    394     int result;
    395     int errNo;
    396     u_long textStart;
    397     u_long textSize;
    398     u_long dataStart;
    399     u_long dataSize;
    400   };
    401   typedef struct get_text_data_out get_text_data_out;
    402 
    403   struct one_signal {
    404     u_int number;
    405     char *name;
    406   };
    407   typedef struct one_signal one_signal;
    408 
    409   typedef struct {
    410     u_int all_signals_len;
    411     one_signal *all_signals_val;
    412   } all_signals;
    413 
    414   struct get_signal_names_out {
    415     all_signals signals;
    416   };
    417   typedef struct get_signal_names_out get_signal_names_out;
    418   /*
    419    * now define the actual calls we support
    420    */
     317struct ptrace_in {
     318        int pid;
     319        ptrace_addr_data_in addr;
     320        u_int data;
     321        u_int flags;
     322};
     323typedef struct ptrace_in ptrace_in;
     324
     325struct ptrace_out {
     326        ptrace_addr_data_out addr;
     327        int result;
     328        int errNo;
     329};
     330typedef struct ptrace_out ptrace_out;
     331
     332struct one_symbol {
     333        char *symbolName;
     334        long symbolValue;
     335};
     336typedef struct one_symbol one_symbol;
     337
     338typedef struct {
     339        u_int all_symbols_len;
     340        one_symbol *all_symbols_val;
     341} all_symbols;
     342
     343struct get_global_symbols_out {
     344        all_symbols symbols;
     345};
     346typedef struct get_global_symbols_out get_global_symbols_out;
     347
     348struct get_text_data_in {
     349        int pid;
     350        char *actorName;
     351};
     352typedef struct get_text_data_in get_text_data_in;
     353
     354struct get_text_data_out {
     355        int result;
     356        int errNo;
     357        u_long textStart;
     358        u_long textSize;
     359        u_long dataStart;
     360        u_long dataSize;
     361};
     362typedef struct get_text_data_out get_text_data_out;
     363
     364struct one_signal {
     365        u_int number;
     366        char *name;
     367};
     368typedef struct one_signal one_signal;
     369
     370typedef struct {
     371        u_int all_signals_len;
     372        one_signal *all_signals_val;
     373} all_signals;
     374
     375struct get_signal_names_out {
     376        all_signals signals;
     377};
     378typedef struct get_signal_names_out get_signal_names_out;
     379 /* now define the actual calls we support */
    421380#define REMDEB_H
    422381#endif
    … …  
    427386#if defined(__STDC__) || defined(__cplusplus)
    428387#define OPEN_CONNEX 1
    429   extern open_out *open_connex_2 (open_in *, CLIENT *);
    430   extern open_out *open_connex_2_svc (open_in *, struct svc_req *);
     388extern  open_out * open_connex_2(open_in *, CLIENT *);
     389extern  open_out * open_connex_2_svc(open_in *, struct svc_req *);
    431390#define SEND_SIGNAL 2
    432   extern signal_out *send_signal_2 (signal_in *, CLIENT *);
    433   extern signal_out *send_signal_2_svc (signal_in *, struct svc_req *);
     391extern  signal_out * send_signal_2(signal_in *, CLIENT *);
     392extern  signal_out * send_signal_2_svc(signal_in *, struct svc_req *);
    434393#define CLOSE_CONNEX 10
    435   extern void *close_connex_2 (close_in *, CLIENT *);
    436   extern void *close_connex_2_svc (close_in *, struct svc_req *);
     394extern  void * close_connex_2(close_in *, CLIENT *);
     395extern  void * close_connex_2_svc(close_in *, struct svc_req *);
    437396#define PTRACE 11
    438   extern ptrace_out *ptrace_2 (ptrace_in *, CLIENT *);
    439   extern ptrace_out *ptrace_2_svc (ptrace_in *, struct svc_req *);
     397extern  ptrace_out * ptrace_2(ptrace_in *, CLIENT *);
     398extern  ptrace_out * ptrace_2_svc(ptrace_in *, struct svc_req *);
    440399#define WAIT_INFO 13
    441   extern wait_out *wait_info_2 (wait_in *, CLIENT *);
    442   extern wait_out *wait_info_2_svc (wait_in *, struct svc_req *);
     400extern  wait_out * wait_info_2(wait_in *, CLIENT *);
     401extern  wait_out * wait_info_2_svc(wait_in *, struct svc_req *);
    443402#define GET_SIGNAL_NAMES 17
    444   extern get_signal_names_out *get_signal_names_2 (void *, CLIENT *);
    445   extern get_signal_names_out *get_signal_names_2_svc (void *,
    446                                                        struct svc_req *);
    447   extern int remotedeb_2_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
    448 
    449 #else                           /* K&R C */
     403extern  get_signal_names_out * get_signal_names_2(void *, CLIENT *);
     404extern  get_signal_names_out * get_signal_names_2_svc(void *, struct svc_req *);
     405extern int remotedeb_2_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
     406
     407#else /* K&R C */
    450408#define OPEN_CONNEX 1
    451   extern open_out *open_connex_2 ();
    452   extern open_out *open_connex_2_svc ();
     409extern  open_out * open_connex_2();
     410extern  open_out * open_connex_2_svc();
    453411#define SEND_SIGNAL 2
    454   extern signal_out *send_signal_2 ();
    455   extern signal_out *send_signal_2_svc ();
     412extern  signal_out * send_signal_2();
     413extern  signal_out * send_signal_2_svc();
    456414#define CLOSE_CONNEX 10
    457   extern void *close_connex_2 ();
    458   extern void *close_connex_2_svc ();
     415extern  void * close_connex_2();
     416extern  void * close_connex_2_svc();
    459417#define PTRACE 11
    460   extern ptrace_out *ptrace_2 ();
    461   extern ptrace_out *ptrace_2_svc ();
     418extern  ptrace_out * ptrace_2();
     419extern  ptrace_out * ptrace_2_svc();
    462420#define WAIT_INFO 13
    463   extern wait_out *wait_info_2 ();
    464   extern wait_out *wait_info_2_svc ();
     421extern  wait_out * wait_info_2();
     422extern  wait_out * wait_info_2_svc();
    465423#define GET_SIGNAL_NAMES 17
    466   extern get_signal_names_out *get_signal_names_2 ();
    467   extern get_signal_names_out *get_signal_names_2_svc ();
    468   extern int remotedeb_2_freeresult ();
    469 #endif                          /* K&R C */
     424extern  get_signal_names_out * get_signal_names_2();
     425extern  get_signal_names_out * get_signal_names_2_svc();
     426extern int remotedeb_2_freeresult ();
     427#endif /* K&R C */
    470428
    471429/* the xdr functions */
    472430
    473431#if defined(__STDC__) || defined(__cplusplus)
    474   extern bool_t xdr_rpc_type (XDR *, rpc_type *);
    475   extern bool_t xdr_UDP_MSG (XDR *, UDP_MSG *);
    476   extern bool_t xdr_ptracereq (XDR *, ptracereq *);
    477   extern bool_t xdr_xdr_regs (XDR *, xdr_regs *);
    478   extern bool_t xdr_xdr_mem (XDR *, xdr_mem *);
    479   extern bool_t xdr_break_type (XDR *, break_type *);
    480   extern bool_t xdr_xdr_break (XDR *, xdr_break *);
    481   extern bool_t xdr_thread_name (XDR *, thread_name *);
    482   extern bool_t xdr_KernThread (XDR *, KernThread *);
    483   extern bool_t xdr_thread_list (XDR *, thread_list *);
    484   extern bool_t xdr_ptrace_addr_data_in (XDR *, ptrace_addr_data_in *);
    485   extern bool_t xdr_ptrace_addr_data_out (XDR *, ptrace_addr_data_out *);
    486   extern bool_t xdr_CHAR_DATA (XDR *, CHAR_DATA *);
    487   extern bool_t xdr_xry_inst (XDR *, xry_inst *);
    488   extern bool_t xdr_instance (XDR *, instance *);
    489   extern bool_t xdr_instance_union (XDR *, instance_union *);
    490   extern bool_t xdr_one_arg (XDR *, one_arg *);
    491   extern bool_t xdr_debug_type (XDR *, debug_type *);
    492   extern bool_t xdr_open_in (XDR *, open_in *);
    493   extern bool_t xdr_open_out (XDR *, open_out *);
    494   extern bool_t xdr_close_control (XDR *, close_control *);
    495   extern bool_t xdr_close_in (XDR *, close_in *);
    496   extern bool_t xdr_signal_in (XDR *, signal_in *);
    497   extern bool_t xdr_signal_out (XDR *, signal_out *);
    498   extern bool_t xdr_stop_code (XDR *, stop_code *);
    499   extern bool_t xdr_wait_in (XDR *, wait_in *);
    500   extern bool_t xdr_wait_out (XDR *, wait_out *);
    501   extern bool_t xdr_ptrace_in (XDR *, ptrace_in *);
    502   extern bool_t xdr_ptrace_out (XDR *, ptrace_out *);
    503   extern bool_t xdr_one_symbol (XDR *, one_symbol *);
    504   extern bool_t xdr_all_symbols (XDR *, all_symbols *);
    505   extern bool_t xdr_get_global_symbols_out (XDR *, get_global_symbols_out *);
    506   extern bool_t xdr_get_text_data_in (XDR *, get_text_data_in *);
    507   extern bool_t xdr_get_text_data_out (XDR *, get_text_data_out *);
    508   extern bool_t xdr_one_signal (XDR *, one_signal *);
    509   extern bool_t xdr_all_signals (XDR *, all_signals *);
    510   extern bool_t xdr_get_signal_names_out (XDR *, get_signal_names_out *);
    511 
    512 #else                           /* K&R C */
    513   extern bool_t xdr_rpc_type ();
    514   extern bool_t xdr_UDP_MSG ();
    515   extern bool_t xdr_ptracereq ();
    516   extern bool_t xdr_xdr_regs ();
    517   extern bool_t xdr_xdr_mem ();
    518   extern bool_t xdr_break_type ();
    519   extern bool_t xdr_xdr_break ();
    520   extern bool_t xdr_thread_name ();
    521   extern bool_t xdr_KernThread ();
    522   extern bool_t xdr_thread_list ();
    523   extern bool_t xdr_ptrace_addr_data_in ();
    524   extern bool_t xdr_ptrace_addr_data_out ();
    525   extern bool_t xdr_CHAR_DATA ();
    526   extern bool_t xdr_xry_inst ();
    527   extern bool_t xdr_instance ();
    528   extern bool_t xdr_instance_union ();
    529   extern bool_t xdr_one_arg ();
    530   extern bool_t xdr_debug_type ();
    531   extern bool_t xdr_open_in ();
    532   extern bool_t xdr_open_out ();
    533   extern bool_t xdr_close_control ();
    534   extern bool_t xdr_close_in ();
    535   extern bool_t xdr_signal_in ();
    536   extern bool_t xdr_signal_out ();
    537   extern bool_t xdr_stop_code ();
    538   extern bool_t xdr_wait_in ();
    539   extern bool_t xdr_wait_out ();
    540   extern bool_t xdr_ptrace_in ();
    541   extern bool_t xdr_ptrace_out ();
    542   extern bool_t xdr_one_symbol ();
    543   extern bool_t xdr_all_symbols ();
    544   extern bool_t xdr_get_global_symbols_out ();
    545   extern bool_t xdr_get_text_data_in ();
    546   extern bool_t xdr_get_text_data_out ();
    547   extern bool_t xdr_one_signal ();
    548   extern bool_t xdr_all_signals ();
    549   extern bool_t xdr_get_signal_names_out ();
    550 
    551 #endif                          /* K&R C */
     432extern  bool_t xdr_rpc_type (XDR *, rpc_type*);
     433extern  bool_t xdr_UDP_MSG (XDR *, UDP_MSG*);
     434extern  bool_t xdr_ptracereq (XDR *, ptracereq*);
     435extern  bool_t xdr_xdr_regs (XDR *, xdr_regs*);
     436extern  bool_t xdr_xdr_mem (XDR *, xdr_mem*);
     437extern  bool_t xdr_break_type (XDR *, break_type*);
     438extern  bool_t xdr_xdr_break (XDR *, xdr_break*);
     439extern  bool_t xdr_thread_name (XDR *, thread_name*);
     440extern  bool_t xdr_KernThread (XDR *, KernThread*);
     441extern  bool_t xdr_thread_list (XDR *, thread_list*);
     442extern  bool_t xdr_ptrace_addr_data_in (XDR *, ptrace_addr_data_in*);
     443extern  bool_t xdr_ptrace_addr_data_out (XDR *, ptrace_addr_data_out*);
     444extern  bool_t xdr_CHAR_DATA (XDR *, CHAR_DATA*);
     445extern  bool_t xdr_one_arg (XDR *, one_arg*);
     446extern  bool_t xdr_debug_type (XDR *, debug_type*);
     447extern  bool_t xdr_open_in (XDR *, open_in*);
     448extern  bool_t xdr_open_out (XDR *, open_out*);
     449extern  bool_t xdr_close_control (XDR *, close_control*);
     450extern  bool_t xdr_close_in (XDR *, close_in*);
     451extern  bool_t xdr_signal_in (XDR *, signal_in*);
     452extern  bool_t xdr_signal_out (XDR *, signal_out*);
     453extern  bool_t xdr_stop_code (XDR *, stop_code*);
     454extern  bool_t xdr_wait_in (XDR *, wait_in*);
     455extern  bool_t xdr_wait_out (XDR *, wait_out*);
     456extern  bool_t xdr_ptrace_in (XDR *, ptrace_in*);
     457extern  bool_t xdr_ptrace_out (XDR *, ptrace_out*);
     458extern  bool_t xdr_one_symbol (XDR *, one_symbol*);
     459extern  bool_t xdr_all_symbols (XDR *, all_symbols*);
     460extern  bool_t xdr_get_global_symbols_out (XDR *, get_global_symbols_out*);
     461extern  bool_t xdr_get_text_data_in (XDR *, get_text_data_in*);
     462extern  bool_t xdr_get_text_data_out (XDR *, get_text_data_out*);
     463extern  bool_t xdr_one_signal (XDR *, one_signal*);
     464extern  bool_t xdr_all_signals (XDR *, all_signals*);
     465extern  bool_t xdr_get_signal_names_out (XDR *, get_signal_names_out*);
     466
     467#else /* K&R C */
     468extern bool_t xdr_rpc_type ();
     469extern bool_t xdr_UDP_MSG ();
     470extern bool_t xdr_ptracereq ();
     471extern bool_t xdr_xdr_regs ();
     472extern bool_t xdr_xdr_mem ();
     473extern bool_t xdr_break_type ();
     474extern bool_t xdr_xdr_break ();
     475extern bool_t xdr_thread_name ();
     476extern bool_t xdr_KernThread ();
     477extern bool_t xdr_thread_list ();
     478extern bool_t xdr_ptrace_addr_data_in ();
     479extern bool_t xdr_ptrace_addr_data_out ();
     480extern bool_t xdr_CHAR_DATA ();
     481extern bool_t xdr_one_arg ();
     482extern bool_t xdr_debug_type ();
     483extern bool_t xdr_open_in ();
     484extern bool_t xdr_open_out ();
     485extern bool_t xdr_close_control ();
     486extern bool_t xdr_close_in ();
     487extern bool_t xdr_signal_in ();
     488extern bool_t xdr_signal_out ();
     489extern bool_t xdr_stop_code ();
     490extern bool_t xdr_wait_in ();
     491extern bool_t xdr_wait_out ();
     492extern bool_t xdr_ptrace_in ();
     493extern bool_t xdr_ptrace_out ();
     494extern bool_t xdr_one_symbol ();
     495extern bool_t xdr_all_symbols ();
     496extern bool_t xdr_get_global_symbols_out ();
     497extern bool_t xdr_get_text_data_in ();
     498extern bool_t xdr_get_text_data_out ();
     499extern bool_t xdr_one_signal ();
     500extern bool_t xdr_all_signals ();
     501extern bool_t xdr_get_signal_names_out ();
     502
     503#endif /* K&R C */
    552504
    553505#ifdef __cplusplus
    554506}
    555507#endif
    556 #endif                          /* !_REMDEB_H_RPCGEN */
     508
     509#endif /* !_REMDEB_H_RPCGEN */

  • c/src/librdbg/src/m68k/any/remdeb_svc.c

    rbdb86b4 r97f6256  
    1 #include <rpc/types.h>
    2 #include <rpc/rpc.h>
    3 #include <stdio.h>
    4 #include <stdlib.h>
    5 #include <string.h>
    6 #include <bsp.h>
    7 #include <rdbg/servrpc.h>
    8 #include <rdbg/remdeb.h>
    9 #define fprintf(a,b) printf(b)
    10 /*HEADER_START*/
    11 #define RTEMS_PORT 2071
    12 #define RTEMS_BACK_PORT 2073
    13 /*
    14  * Sun request values for the remote ptrace system call
    15  */
    16 
    17   /*
    18    * Memory data for read/write text or data. The size is in data. The target
    19    * addr is in the addr field.
    20    * Be careful before modifying because this value goes into internal
    21    * pipes and is allocated on stack too. Pipes and/or the stack could
    22    * become too small if this value gets incremented.
    23    */
    24 #ifndef XRY_MAX_CMD_STR
    25 #endif /* REMDEB_H */
    26   /*
    27    * now open_connex() routine which establishes a connection to server
    28    */
    29 #define DEBUGGER_IS_GDB 0x2     /* */
    30   /*
    31    * now close_connex() routine which detaches from server
    32    */
    33   /*
    34    * now send_signal() routine which sends signals to processes like kill(2)
    35    */
    36   /*
    37    * now wait_info() routine which returns results of polling the wait status
    38    * of a process/actor. It may return 0 if running, else pid or -1
    39    */
    40   /*
    41    * now ptrace() routine. This matches the Sun UNIX ptrace as well as
    42    * some additions
    43    */
    44   /*
    45    * now define the actual calls we support
    46    */
    47 const char *names[] = {
    48   "NULLPROC", "OPEN_CONNEX", "SEND_SIGNAL", "name3",
    49   "name4", "name5", "name6", "name7",
    50   "name8", "name9", "CLOSE_CONNEX", "PTRACE",
    51   "name12", "WAIT_INFO", "name14", "name15",
    52   "name16", "GET_SIGNAL_NAMES", "name18"
    53 };
    54 
    55 void
    56 remotedeb_2 (struct svc_req *rqstp, register SVCXPRT * transp)
    57 {
    58   union {
    59     open_in open_connex_2_arg;
    60     signal_in send_signal_2_arg;
    61     close_in close_connex_2_arg;
    62     ptrace_in ptrace_2_arg;
    63     wait_in wait_info_2_arg;
    64   } argument;
    65   char *result;
    66   xdrproc_t _xdr_argument, _xdr_result;
    67   char *(*local) (char *, struct svc_req *);
    68 
    69   DPRINTF (("remotedeb_2: %s (%d)\n",
    70             (unsigned) rqstp->rq_proc <
    71             (unsigned) (sizeof names / sizeof names[0]) ?
    72             names[rqstp->rq_proc] : "???", (int) rqstp->rq_proc));
    73 
    74   switch (rqstp->rq_proc) {
    75   case NULLPROC:
    76     (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *) NULL);
    77     return;
    78 
    79   case OPEN_CONNEX:
    80     _xdr_argument = (xdrproc_t) xdr_open_in;
    81     _xdr_result = (xdrproc_t) xdr_open_out;
    82     local = (char *(*)(char *, struct svc_req *)) open_connex_2_svc;
    83     break;
    84 
    85   case SEND_SIGNAL:
    86     _xdr_argument = (xdrproc_t) xdr_signal_in;
    87     _xdr_result = (xdrproc_t) xdr_signal_out;
    88     local = (char *(*)(char *, struct svc_req *)) send_signal_2_svc;
    89     break;
    90 
    91   case CLOSE_CONNEX:
    92     _xdr_argument = (xdrproc_t) xdr_close_in;
    93     _xdr_result = (xdrproc_t) xdr_void;
    94     local = (char *(*)(char *, struct svc_req *)) close_connex_2_svc;
    95     break;
    96 
    97   case PTRACE:
    98     _xdr_argument = (xdrproc_t) xdr_ptrace_in;
    99     _xdr_result = (xdrproc_t) xdr_ptrace_out;
    100     local = (char *(*)(char *, struct svc_req *)) ptrace_2_svc;
    101     break;
    102 
    103   case WAIT_INFO:
    104     _xdr_argument = (xdrproc_t) xdr_wait_in;
    105     _xdr_result = (xdrproc_t) xdr_wait_out;
    106     local = (char *(*)(char *, struct svc_req *)) wait_info_2_svc;
    107     break;
    108 
    109   case GET_SIGNAL_NAMES:
    110     _xdr_argument = (xdrproc_t) xdr_void;
    111     _xdr_result = (xdrproc_t) xdr_get_signal_names_out;
    112     local = (char *(*)(char *, struct svc_req *)) get_signal_names_2_svc;
    113     break;
    114 
    115   default:
    116     svcerr_noproc (transp);
    117     return;
    118   }
    119   memset ((char *) &argument, 0, sizeof (argument));
    120   if (!svc_getargs (transp, _xdr_argument, (caddr_t) & argument)) {
    121     svcerr_decode (transp);
    122     return;
    123   }
    124   result = (*local) ((char *) &argument, rqstp);
    125   if (result != NULL && !svc_sendreply (transp, _xdr_result, result)) {
    126     svcerr_systemerr (transp);
    127   }
    128   if (!svc_freeargs (transp, _xdr_argument, (caddr_t) & argument)) {
    129     fprintf (stderr, "unable to free arguments");
    130     exit (1);
    131   }
    132   return;
    133 }

  • c/src/librdbg/src/m68k/any/remdeb_xdr.c

    rbdb86b4 r97f6256  
    99
    1010bool_t
    11 xdr_rpc_type (XDR * xdrs, rpc_type * objp)
    12 {
    13   register int32_t *buf;
    14 
    15   if (!xdr_enum (xdrs, (enum_t *) objp))
    16     return FALSE;
    17   return TRUE;
    18 }
    19 
    20 bool_t
    21 xdr_UDP_MSG (XDR * xdrs, UDP_MSG * objp)
    22 {
    23   register int32_t *buf;
    24 
    25   if (!xdr_u_char (xdrs, &objp->type))
    26     return FALSE;
    27   if (!xdr_u_char (xdrs, &objp->msg_num))
    28     return FALSE;
    29   if (!xdr_u_short (xdrs, &objp->spec))
    30     return FALSE;
    31   if (!xdr_long (xdrs, &objp->pid))
    32     return FALSE;
    33   if (!xdr_u_long (xdrs, &objp->context))
    34     return FALSE;
    35   return TRUE;
    36 }
    37 
     11xdr_rpc_type (XDR *xdrs, rpc_type *objp)
     12{
     13        register int32_t *buf;
     14
     15         if (!xdr_enum (xdrs, (enum_t *) objp))
     16                 return FALSE;
     17        return TRUE;
     18}
     19
     20bool_t
     21xdr_UDP_MSG (XDR *xdrs, UDP_MSG *objp)
     22{
     23        register int32_t *buf;
     24
     25         if (!xdr_u_char (xdrs, &objp->type))
     26                 return FALSE;
     27         if (!xdr_u_char (xdrs, &objp->msg_num))
     28                 return FALSE;
     29         if (!xdr_u_short (xdrs, &objp->spec))
     30                 return FALSE;
     31         if (!xdr_long (xdrs, &objp->pid))
     32                 return FALSE;
     33         if (!xdr_u_long (xdrs, &objp->context))
     34                 return FALSE;
     35        return TRUE;
     36}
    3837/*
    3938 * Sun request values for the remote ptrace system call
    4039 */
    4140
    42 bool_t
    43 xdr_ptracereq (XDR * xdrs, ptracereq * objp)
    44 {
    45   register int32_t *buf;
    46 
    47   if (!xdr_enum (xdrs, (enum_t *) objp))
    48     return FALSE;
    49   return TRUE;
    50 }
    51 
    52 bool_t
    53 xdr_xdr_regs (XDR * xdrs, xdr_regs * objp)
    54 {
    55   register int32_t *buf;
    56 
    57   int i;
    58 
    59   if (xdrs->x_op == XDR_ENCODE) {
    60     buf = XDR_INLINE (xdrs, (3 + 8 + 8) * BYTES_PER_XDR_UNIT);
    61     if (buf == NULL) {
    62       if (!xdr_vector (xdrs, (char *) objp->r_dreg, 8,
    63                        sizeof (int), (xdrproc_t) xdr_int))
    64         return FALSE;
    65       if (!xdr_vector (xdrs, (char *) objp->r_areg, 8,
    66                        sizeof (int), (xdrproc_t) xdr_int))
    67         return FALSE;
    68       if (!xdr_int (xdrs, &objp->r_sr))
    69         return FALSE;
    70       if (!xdr_int (xdrs, &objp->r_pc))
    71         return FALSE;
    72       if (!xdr_int (xdrs, &objp->r_vec))
    73         return FALSE;
    74     } else {
    75       {
    76         register int *genp;
    77 
    78         for (i = 0, genp = objp->r_dreg; i < 8; ++i) {
    79           IXDR_PUT_LONG (buf, *genp++);
    80         }
    81       }
    82       {
    83         register int *genp;
    84 
    85         for (i = 0, genp = objp->r_areg; i < 8; ++i) {
    86           IXDR_PUT_LONG (buf, *genp++);
    87         }
    88       }
    89       IXDR_PUT_LONG (buf, objp->r_sr);
    90       IXDR_PUT_LONG (buf, objp->r_pc);
    91       IXDR_PUT_LONG (buf, objp->r_vec);
    92     }
    93     return TRUE;
    94   } else if (xdrs->x_op == XDR_DECODE) {
    95     buf = XDR_INLINE (xdrs, (3 + 8 + 8) * BYTES_PER_XDR_UNIT);
    96     if (buf == NULL) {
    97       if (!xdr_vector (xdrs, (char *) objp->r_dreg, 8,
    98                        sizeof (int), (xdrproc_t) xdr_int))
    99         return FALSE;
    100       if (!xdr_vector (xdrs, (char *) objp->r_areg, 8,
    101                        sizeof (int), (xdrproc_t) xdr_int))
    102         return FALSE;
    103       if (!xdr_int (xdrs, &objp->r_sr))
    104         return FALSE;
    105       if (!xdr_int (xdrs, &objp->r_pc))
    106         return FALSE;
    107       if (!xdr_int (xdrs, &objp->r_vec))
    108         return FALSE;
    109     } else {
    110       {
    111         register int *genp;
    112 
    113         for (i = 0, genp = objp->r_dreg; i < 8; ++i) {
    114           *genp++ = IXDR_GET_LONG (buf);
    115         }
    116       }
    117       {
    118         register int *genp;
    119 
    120         for (i = 0, genp = objp->r_areg; i < 8; ++i) {
    121           *genp++ = IXDR_GET_LONG (buf);
    122         }
    123       }
    124       objp->r_sr = IXDR_GET_LONG (buf);
    125       objp->r_pc = IXDR_GET_LONG (buf);
    126       objp->r_vec = IXDR_GET_LONG (buf);
    127     }
    128     return TRUE;
    129   }
    130 
    131   if (!xdr_vector (xdrs, (char *) objp->r_dreg, 8,
    132                    sizeof (int), (xdrproc_t) xdr_int))
    133     return FALSE;
    134   if (!xdr_vector (xdrs, (char *) objp->r_areg, 8,
    135                    sizeof (int), (xdrproc_t) xdr_int))
    136     return FALSE;
    137   if (!xdr_int (xdrs, &objp->r_sr))
    138     return FALSE;
    139   if (!xdr_int (xdrs, &objp->r_pc))
    140     return FALSE;
    141   if (!xdr_int (xdrs, &objp->r_vec))
    142     return FALSE;
    143   return TRUE;
    144 }
    145 
    146   /*
     41
     42bool_t
     43xdr_ptracereq (XDR *xdrs, ptracereq *objp)
     44{
     45        register int32_t *buf;
     46
     47         if (!xdr_enum (xdrs, (enum_t *) objp))
     48                 return FALSE;
     49        return TRUE;
     50}
     51
     52bool_t
     53xdr_xdr_regs (XDR *xdrs, xdr_regs *objp)
     54{
     55        register int32_t *buf;
     56
     57        int i;
     58
     59        if (xdrs->x_op == XDR_ENCODE) {
     60                buf = XDR_INLINE (xdrs, (3 +  8  + 8 )* BYTES_PER_XDR_UNIT);
     61                if (buf == NULL) {
     62                         if (!xdr_vector (xdrs, (char *)objp->r_dreg, 8,
     63                                sizeof (int), (xdrproc_t) xdr_int))
     64                                 return FALSE;
     65                         if (!xdr_vector (xdrs, (char *)objp->r_areg, 8,
     66                                sizeof (int), (xdrproc_t) xdr_int))
     67                                 return FALSE;
     68                         if (!xdr_int (xdrs, &objp->r_sr))
     69                                 return FALSE;
     70                         if (!xdr_int (xdrs, &objp->r_pc))
     71                                 return FALSE;
     72                         if (!xdr_int (xdrs, &objp->r_vec))
     73                                 return FALSE;
     74                } else {
     75                        {
     76                                register int *genp;
     77
     78                                for (i = 0, genp = objp->r_dreg;
     79                                        i < 8; ++i) {
     80                                        IXDR_PUT_LONG(buf, *genp++);
     81                                }
     82                        }
     83                        {
     84                                register int *genp;
     85
     86                                for (i = 0, genp = objp->r_areg;
     87                                        i < 8; ++i) {
     88                                        IXDR_PUT_LONG(buf, *genp++);
     89                                }
     90                        }
     91                        IXDR_PUT_LONG(buf, objp->r_sr);
     92                        IXDR_PUT_LONG(buf, objp->r_pc);
     93                        IXDR_PUT_LONG(buf, objp->r_vec);
     94                }
     95                return TRUE;
     96        } else if (xdrs->x_op == XDR_DECODE) {
     97                buf = XDR_INLINE (xdrs, (3 +  8  + 8 )* BYTES_PER_XDR_UNIT);
     98                if (buf == NULL) {
     99                         if (!xdr_vector (xdrs, (char *)objp->r_dreg, 8,
     100                                sizeof (int), (xdrproc_t) xdr_int))
     101                                 return FALSE;
     102                         if (!xdr_vector (xdrs, (char *)objp->r_areg, 8,
     103                                sizeof (int), (xdrproc_t) xdr_int))
     104                                 return FALSE;
     105                         if (!xdr_int (xdrs, &objp->r_sr))
     106                                 return FALSE;
     107                         if (!xdr_int (xdrs, &objp->r_pc))
     108                                 return FALSE;
     109                         if (!xdr_int (xdrs, &objp->r_vec))
     110                                 return FALSE;
     111                } else {
     112                        {
     113                                register int *genp;
     114
     115                                for (i = 0, genp = objp->r_dreg;
     116                                        i < 8; ++i) {
     117                                        *genp++ = IXDR_GET_LONG(buf);
     118                                }
     119                        }
     120                        {
     121                                register int *genp;
     122
     123                                for (i = 0, genp = objp->r_areg;
     124                                        i < 8; ++i) {
     125                                        *genp++ = IXDR_GET_LONG(buf);
     126                                }
     127                        }
     128                        objp->r_sr = IXDR_GET_LONG(buf);
     129                        objp->r_pc = IXDR_GET_LONG(buf);
     130                        objp->r_vec = IXDR_GET_LONG(buf);
     131                }
     132         return TRUE;
     133        }
     134
     135         if (!xdr_vector (xdrs, (char *)objp->r_dreg, 8,
     136                sizeof (int), (xdrproc_t) xdr_int))
     137                 return FALSE;
     138         if (!xdr_vector (xdrs, (char *)objp->r_areg, 8,
     139                sizeof (int), (xdrproc_t) xdr_int))
     140                 return FALSE;
     141         if (!xdr_int (xdrs, &objp->r_sr))
     142                 return FALSE;
     143         if (!xdr_int (xdrs, &objp->r_pc))
     144                 return FALSE;
     145         if (!xdr_int (xdrs, &objp->r_vec))
     146                 return FALSE;
     147        return TRUE;
     148}
     149 /*
    147150   * Memory data for read/write text or data. The size is in data. The target
    148151   * addr is in the addr field.
    … …  
    151154   * become too small if this value gets incremented.
    152155   */
    153 bool_t
    154 xdr_xdr_mem (xdrs, objp)
    155      XDR *xdrs;
    156      struct xdr_mem *objp;
    157 {
    158   if (!xdr_u_long (xdrs, &objp->addr)) {
    159     return (FALSE);
    160   }
    161   if (!xdr_u_int (xdrs, &objp->dataNb)) {
    162     return (FALSE);
    163   }
    164   return (xdr_opaque (xdrs, objp->data, objp->dataNb));
    165 }
    166 
    167 bool_t
    168 xdr_break_type (XDR * xdrs, break_type * objp)
    169 {
    170   register int32_t *buf;
    171 
    172   if (!xdr_enum (xdrs, (enum_t *) objp))
    173     return FALSE;
    174   return TRUE;
    175 }
    176 
    177 bool_t
    178 xdr_xdr_break (XDR * xdrs, xdr_break * objp)
    179 {
    180   register int32_t *buf;
    181 
    182   int i;
    183 
    184   if (xdrs->x_op == XDR_ENCODE) {
    185     if (!xdr_u_char (xdrs, &objp->type))
    186       return FALSE;
    187     if (!xdr_u_char (xdrs, &objp->thread_spec))
    188       return FALSE;
    189     buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
    190     if (buf == NULL) {
    191       if (!xdr_u_short (xdrs, &objp->handle))
    192         return FALSE;
    193       if (!xdr_u_long (xdrs, &objp->ee_loc))
    194         return FALSE;
    195       if (!xdr_u_long (xdrs, &objp->ee_type))
    196         return FALSE;
    197       if (!xdr_u_short (xdrs, &objp->length))
    198         return FALSE;
    199 
    200     } else {
    201       IXDR_PUT_U_SHORT (buf, objp->handle);
    202       IXDR_PUT_U_LONG (buf, objp->ee_loc);
    203       IXDR_PUT_U_LONG (buf, objp->ee_type);
    204       IXDR_PUT_U_SHORT (buf, objp->length);
    205     }
    206     if (!xdr_u_char (xdrs, &objp->pass_count))
    207       return FALSE;
    208     if (!xdr_u_char (xdrs, &objp->curr_pass))
    209       return FALSE;
    210     buf = XDR_INLINE (xdrs, MAX_THRD_BRK * BYTES_PER_XDR_UNIT);
    211     if (buf == NULL) {
    212       if (!xdr_vector (xdrs, (char *) objp->thread_list, MAX_THRD_BRK,
    213                        sizeof (u_long), (xdrproc_t) xdr_u_long))
    214         return FALSE;
    215     } else {
    216       {
    217         register u_long *genp;
    218 
    219         for (i = 0, genp = objp->thread_list; i < MAX_THRD_BRK; ++i) {
    220           IXDR_PUT_U_LONG (buf, *genp++);
    221         }
    222       }
    223     }
    224     return TRUE;
    225   } else if (xdrs->x_op == XDR_DECODE) {
    226     if (!xdr_u_char (xdrs, &objp->type))
    227       return FALSE;
    228     if (!xdr_u_char (xdrs, &objp->thread_spec))
    229       return FALSE;
    230     buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
    231     if (buf == NULL) {
    232       if (!xdr_u_short (xdrs, &objp->handle))
    233         return FALSE;
    234       if (!xdr_u_long (xdrs, &objp->ee_loc))
    235         return FALSE;
    236       if (!xdr_u_long (xdrs, &objp->ee_type))
    237         return FALSE;
    238       if (!xdr_u_short (xdrs, &objp->length))
    239         return FALSE;
    240 
    241     } else {
    242       objp->handle = IXDR_GET_U_SHORT (buf);
    243       objp->ee_loc = IXDR_GET_U_LONG (buf);
    244       objp->ee_type = IXDR_GET_U_LONG (buf);
    245       objp->length = IXDR_GET_U_SHORT (buf);
    246     }
    247     if (!xdr_u_char (xdrs, &objp->pass_count))
    248       return FALSE;
    249     if (!xdr_u_char (xdrs, &objp->curr_pass))
    250       return FALSE;
    251     buf = XDR_INLINE (xdrs, MAX_THRD_BRK * BYTES_PER_XDR_UNIT);
    252     if (buf == NULL) {
    253       if (!xdr_vector (xdrs, (char *) objp->thread_list, MAX_THRD_BRK,
    254                        sizeof (u_long), (xdrproc_t) xdr_u_long))
    255         return FALSE;
    256     } else {
    257       {
    258         register u_long *genp;
    259 
    260         for (i = 0, genp = objp->thread_list; i < MAX_THRD_BRK; ++i) {
    261           *genp++ = IXDR_GET_U_LONG (buf);
    262         }
    263       }
    264     }
    265     return TRUE;
    266   }
    267 
    268   if (!xdr_u_char (xdrs, &objp->type))
    269     return FALSE;
    270   if (!xdr_u_char (xdrs, &objp->thread_spec))
    271     return FALSE;
    272   if (!xdr_u_short (xdrs, &objp->handle))
    273     return FALSE;
    274   if (!xdr_u_long (xdrs, &objp->ee_loc))
    275     return FALSE;
    276   if (!xdr_u_long (xdrs, &objp->ee_type))
    277     return FALSE;
    278   if (!xdr_u_short (xdrs, &objp->length))
    279     return FALSE;
    280   if (!xdr_u_char (xdrs, &objp->pass_count))
    281     return FALSE;
    282   if (!xdr_u_char (xdrs, &objp->curr_pass))
    283     return FALSE;
    284   if (!xdr_vector (xdrs, (char *) objp->thread_list, MAX_THRD_BRK,
    285                    sizeof (u_long), (xdrproc_t) xdr_u_long))
    286     return FALSE;
    287   return TRUE;
    288 }
    289 
    290 bool_t
    291 xdr_thread_name (XDR * xdrs, thread_name * objp)
    292 {
    293   register int32_t *buf;
    294 
    295   if (!xdr_string (xdrs, objp, THREADNAMEMAX))
    296     return FALSE;
    297   return TRUE;
    298 }
    299 
    300 bool_t
    301 xdr_KernThread (XDR * xdrs, KernThread * objp)
    302 {
    303   register int32_t *buf;
    304 
    305   if (!xdr_u_int (xdrs, &objp->threadLi))
    306     return FALSE;
    307   return TRUE;
    308 }
    309 
    310 bool_t
    311 xdr_thread_list (xdrs, objp)
    312      XDR *xdrs;
    313      struct thread_list *objp;
    314 {
    315   return (xdr_array (xdrs, (char **) &objp->threads, &objp->nbThread,
    316                      UTHREAD_MAX, sizeof (KernThread), xdr_KernThread));
    317 }
    318 
    319 bool_t
    320 xdr_ptrace_addr_data_in (XDR * xdrs, ptrace_addr_data_in * objp)
    321 {
    322   register int32_t *buf;
    323 
    324   if (!xdr_ptracereq (xdrs, &objp->req))
    325     return FALSE;
    326   switch (objp->req) {
    327   case RPT_SETTHREADREGS:
    328     if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_in_u.regs))
    329       return FALSE;
    330     break;
    331   case RPT_SETREGS:
    332     if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_in_u.regs))
    333       return FALSE;
    334     break;
    335   case RPT_PSETTHREADREGS:
    336     if (!xdr_array
    337         (xdrs, (char **) &objp->ptrace_addr_data_in_u.pregs.pregs_val,
    338          (u_int *) & objp->ptrace_addr_data_in_u.pregs.pregs_len, ~0,
    339          sizeof (u_int), (xdrproc_t) xdr_u_int))
    340       return FALSE;
    341     break;
    342   case RPT_PSETREGS:
    343     if (!xdr_array
    344         (xdrs, (char **) &objp->ptrace_addr_data_in_u.pregs.pregs_val,
    345          (u_int *) & objp->ptrace_addr_data_in_u.pregs.pregs_len, ~0,
    346          sizeof (u_int), (xdrproc_t) xdr_u_int))
    347       return FALSE;
    348     break;
    349   case RPT_SETTHREADNAME:
    350     if (!xdr_thread_name (xdrs, &objp->ptrace_addr_data_in_u.name))
    351       return FALSE;
    352     break;
    353   case RPT_WRITETEXT:
    354     if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_in_u.mem))
    355       return FALSE;
    356     break;
    357   case RPT_WRITEDATA:
    358     if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_in_u.mem))
    359       return FALSE;
    360     break;
    361   case RPT_SETBREAK:
    362     if (!xdr_xdr_break (xdrs, &objp->ptrace_addr_data_in_u.breakp))
    363       return FALSE;
    364     break;
    365   default:
    366     if (!xdr_u_int (xdrs, &objp->ptrace_addr_data_in_u.address))
    367       return FALSE;
    368     break;
    369   }
    370   return TRUE;
    371 }
    372 
    373 bool_t
    374 xdr_ptrace_addr_data_out (XDR * xdrs, ptrace_addr_data_out * objp)
    375 {
    376   register int32_t *buf;
    377 
    378   if (!xdr_ptracereq (xdrs, &objp->req))
    379     return FALSE;
    380   switch (objp->req) {
    381   case RPT_GETREGS:
    382     if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_out_u.regs))
    383       return FALSE;
    384     break;
    385   case RPT_GETTHREADREGS:
    386     if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_out_u.regs))
    387       return FALSE;
    388     break;
    389   case RPT_PGETREGS:
    390     if (!xdr_array
    391         (xdrs, (char **) &objp->ptrace_addr_data_out_u.pregs.pregs_val,
    392          (u_int *) & objp->ptrace_addr_data_out_u.pregs.pregs_len, ~0,
    393          sizeof (u_int), (xdrproc_t) xdr_u_int))
    394       return FALSE;
    395     break;
    396   case RPT_PGETTHREADREGS:
    397     if (!xdr_array
    398         (xdrs, (char **) &objp->ptrace_addr_data_out_u.pregs.pregs_val,
    399          (u_int *) & objp->ptrace_addr_data_out_u.pregs.pregs_len, ~0,
    400          sizeof (u_int), (xdrproc_t) xdr_u_int))
    401       return FALSE;
    402     break;
    403   case RPT_THREADLIST:
    404     if (!xdr_thread_list (xdrs, &objp->ptrace_addr_data_out_u.threads))
    405       return FALSE;
    406     break;
    407   case RPT_GETTHREADNAME:
    408     if (!xdr_thread_name (xdrs, &objp->ptrace_addr_data_out_u.name))
    409       return FALSE;
    410     break;
    411   case RPT_READTEXT:
    412     if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_out_u.mem))
    413       return FALSE;
    414     break;
    415   case RPT_GETNAME:
    416     if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_out_u.mem))
    417       return FALSE;
    418     break;
    419   case RPT_READDATA:
    420     if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_out_u.mem))
    421       return FALSE;
    422     break;
    423   case RPT_GETBREAK:
    424     if (!xdr_xdr_break (xdrs, &objp->ptrace_addr_data_out_u.breakp))
    425       return FALSE;
    426     break;
    427   default:
    428     if (!xdr_u_int (xdrs, &objp->ptrace_addr_data_out_u.addr))
    429       return FALSE;
    430     break;
    431   }
    432   return TRUE;
    433 }
    434 
    435 bool_t
    436 xdr_CHAR_DATA (XDR * xdrs, CHAR_DATA * objp)
    437 {
    438   register int32_t *buf;
    439 
    440   if (!xdr_bytes
    441       (xdrs, (char **) &objp->CHAR_DATA_val, (u_int *) & objp->CHAR_DATA_len,
    442        NET_SAFE))
    443     return FALSE;
    444   return TRUE;
    445 }
    446 
    447 #ifndef XRY_MAX_CMD_STR
    448 #endif /* REMDEB_H */
    449 
    450 bool_t
    451 xdr_xry_inst (XDR * xdrs, xry_inst * objp)
    452 {
    453   register int32_t *buf;
    454 
    455   if (!xdr_u_char (xdrs, &objp->flags))
    456     return FALSE;
    457   if (!xdr_u_char (xdrs, &objp->type))
    458     return FALSE;
    459   if (!xdr_u_char (xdrs, &objp->sub_type))
    460     return FALSE;
    461   if (!xdr_u_char (xdrs, &objp->res_type))
    462     return FALSE;
    463   if (!xdr_u_long (xdrs, &objp->value))
    464     return FALSE;
    465   if (!xdr_u_long (xdrs, &objp->value2))
    466     return FALSE;
    467   return TRUE;
    468 }
    469 
    470 bool_t
    471 xdr_instance (XDR * xdrs, instance * objp)
    472 {
    473   register int32_t *buf;
    474 
    475   int i;
    476   if (!xdr_vector (xdrs, (char *) objp->instances, XRY_MAX_INSTANCES,
    477                    sizeof (xry_inst), (xdrproc_t) xdr_xry_inst))
    478     return FALSE;
    479   if (!xdr_vector (xdrs, (char *) objp->buffer, XRY_MAX_INST_BUFF,
    480                    sizeof (u_char), (xdrproc_t) xdr_u_char))
    481     return FALSE;
    482   return TRUE;
    483 }
    484 
    485 bool_t
    486 xdr_instance_union (XDR * xdrs, instance_union * objp)
    487 {
    488   register int32_t *buf;
    489 
    490   if (!xdr_bool (xdrs, &objp->instances))
    491     return FALSE;
    492   switch (objp->instances) {
    493   case TRUE:
    494     if (!xdr_instance (xdrs, &objp->instance_union_u.inst))
    495       return FALSE;
    496     break;
    497   case FALSE:
    498     if (!xdr_string (xdrs, &objp->instance_union_u.buffer, XRY_MAX_CMD_STR))
    499       return FALSE;
    500     break;
    501   default:
    502     return FALSE;
    503   }
    504   return TRUE;
    505 }
    506 
    507 bool_t
    508 xdr_one_arg (XDR * xdrs, one_arg * objp)
    509 {
    510   register int32_t *buf;
    511 
    512   if (!xdr_string (xdrs, objp, NET_SAFE))
    513     return FALSE;
    514   return TRUE;
    515 }
    516 
    517   /*
    518    * now open_connex() routine which establishes a connection to server
    519    */
    520 
    521 bool_t
    522 xdr_debug_type (XDR * xdrs, debug_type * objp)
    523 {
    524   register int32_t *buf;
    525 
    526   if (!xdr_enum (xdrs, (enum_t *) objp))
    527     return FALSE;
    528   return TRUE;
    529 }
    530 
    531 #define DEBUGGER_IS_GDB 0x2     /* */
    532 
    533 bool_t
    534 xdr_open_in (XDR * xdrs, open_in * objp)
    535 {
    536   register int32_t *buf;
    537 
    538   int i;
    539   if (!xdr_vector (xdrs, (char *) objp->back_port, 16,
    540                    sizeof (u_char), (xdrproc_t) xdr_u_char))
    541     return FALSE;
    542   if (!xdr_u_short (xdrs, &objp->debug_type))
    543     return FALSE;
    544   if (!xdr_u_short (xdrs, &objp->flags))
    545     return FALSE;
    546   if (!xdr_vector (xdrs, (char *) objp->destination, 16,
    547                    sizeof (u_char), (xdrproc_t) xdr_u_char))
    548     return FALSE;
    549   if (!xdr_one_arg (xdrs, &objp->user_name))
    550     return FALSE;
    551   return TRUE;
    552 }
    553 
    554 bool_t
    555 xdr_open_out (XDR * xdrs, open_out * objp)
    556 {
    557   register int32_t *buf;
    558 
    559   int i;
    560 
    561   if (xdrs->x_op == XDR_ENCODE) {
    562     buf = XDR_INLINE (xdrs, (2 + (4)) * BYTES_PER_XDR_UNIT);
    563     if (buf == NULL) {
    564       if (!xdr_u_long (xdrs, &objp->port))
    565         return FALSE;
    566       if (!xdr_vector (xdrs, (char *) objp->pad, 4,
    567                        sizeof (u_int), (xdrproc_t) xdr_u_int))
    568         return FALSE;
    569       if (!xdr_u_int (xdrs, &objp->fp))
    570         return FALSE;
    571 
    572     } else {
    573       IXDR_PUT_U_LONG (buf, objp->port);
    574       {
    575         register u_int *genp;
    576 
    577         for (i = 0, genp = objp->pad; i < 4; ++i) {
    578           IXDR_PUT_U_LONG (buf, *genp++);
    579         }
    580       }
    581       IXDR_PUT_U_LONG (buf, objp->fp);
    582     }
    583     if (!xdr_u_char (xdrs, &objp->cmd_table_num))
    584       return FALSE;
    585     if (!xdr_u_char (xdrs, &objp->cmd_table_vers))
    586       return FALSE;
    587     if (!xdr_u_short (xdrs, &objp->server_vers))
    588       return FALSE;
    589     return TRUE;
    590   } else if (xdrs->x_op == XDR_DECODE) {
    591     buf = XDR_INLINE (xdrs, (2 + (4)) * BYTES_PER_XDR_UNIT);
    592     if (buf == NULL) {
    593       if (!xdr_u_long (xdrs, &objp->port))
    594         return FALSE;
    595       if (!xdr_vector (xdrs, (char *) objp->pad, 4,
    596                        sizeof (u_int), (xdrproc_t) xdr_u_int))
    597         return FALSE;
    598       if (!xdr_u_int (xdrs, &objp->fp))
    599         return FALSE;
    600 
    601     } else {
    602       objp->port = IXDR_GET_U_LONG (buf);
    603       {
    604         register u_int *genp;
    605 
    606         for (i = 0, genp = objp->pad; i < 4; ++i) {
    607           *genp++ = IXDR_GET_U_LONG (buf);
    608         }
    609       }
    610       objp->fp = IXDR_GET_U_LONG (buf);
    611     }
    612     if (!xdr_u_char (xdrs, &objp->cmd_table_num))
    613       return FALSE;
    614     if (!xdr_u_char (xdrs, &objp->cmd_table_vers))
    615       return FALSE;
    616     if (!xdr_u_short (xdrs, &objp->server_vers))
    617       return FALSE;
    618     return TRUE;
    619   }
    620 
    621   if (!xdr_u_long (xdrs, &objp->port))
    622     return FALSE;
    623   if (!xdr_vector (xdrs, (char *) objp->pad, 4,
    624                    sizeof (u_int), (xdrproc_t) xdr_u_int))
    625     return FALSE;
    626   if (!xdr_u_int (xdrs, &objp->fp))
    627     return FALSE;
    628   if (!xdr_u_char (xdrs, &objp->cmd_table_num))
    629     return FALSE;
    630   if (!xdr_u_char (xdrs, &objp->cmd_table_vers))
    631     return FALSE;
    632   if (!xdr_u_short (xdrs, &objp->server_vers))
    633     return FALSE;
    634   return TRUE;
    635 }
    636 
    637   /*
    638    * now close_connex() routine which detaches from server
    639    */
    640 
    641 bool_t
    642 xdr_close_control (XDR * xdrs, close_control * objp)
    643 {
    644   register int32_t *buf;
    645 
    646   if (!xdr_enum (xdrs, (enum_t *) objp))
    647     return FALSE;
    648   return TRUE;
    649 }
    650 
    651 bool_t
    652 xdr_close_in (XDR * xdrs, close_in * objp)
    653 {
    654   register int32_t *buf;
    655 
    656   if (!xdr_close_control (xdrs, &objp->control))
    657     return FALSE;
    658   return TRUE;
    659 }
    660 
    661   /*
    662    * now send_signal() routine which sends signals to processes like kill(2)
    663    */
    664 
    665 bool_t
    666 xdr_signal_in (XDR * xdrs, signal_in * objp)
    667 {
    668   register int32_t *buf;
    669 
    670   if (!xdr_int (xdrs, &objp->pid))
    671     return FALSE;
    672   if (!xdr_int (xdrs, &objp->sig))
    673     return FALSE;
    674   return TRUE;
    675 }
    676 
    677 bool_t
    678 xdr_signal_out (XDR * xdrs, signal_out * objp)
    679 {
    680   register int32_t *buf;
    681 
    682   if (!xdr_int (xdrs, &objp->kill_return))
    683     return FALSE;
    684   if (!xdr_int (xdrs, &objp->errNo))
    685     return FALSE;
    686   return TRUE;
    687 }
    688 
    689   /*
    690    * now wait_info() routine which returns results of polling the wait status
    691    * of a process/actor. It may return 0 if running, else pid or -1
    692    */
    693 
    694 bool_t
    695 xdr_stop_code (XDR * xdrs, stop_code * objp)
    696 {
    697   register int32_t *buf;
    698 
    699   if (!xdr_enum (xdrs, (enum_t *) objp))
    700     return FALSE;
    701   return TRUE;
    702 }
    703 
    704 bool_t
    705 xdr_wait_in (XDR * xdrs, wait_in * objp)
    706 {
    707   register int32_t *buf;
    708 
    709   if (!xdr_int (xdrs, &objp->pid))
    710     return FALSE;
    711   return TRUE;
    712 }
    713 
    714 bool_t
    715 xdr_wait_out (XDR * xdrs, wait_out * objp)
    716 {
    717   register int32_t *buf;
    718 
    719   if (xdrs->x_op == XDR_ENCODE) {
    720     buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
    721     if (buf == NULL) {
    722       if (!xdr_int (xdrs, &objp->wait_return))
    723         return FALSE;
    724       if (!xdr_int (xdrs, &objp->errNo))
    725         return FALSE;
    726       if (!xdr_int (xdrs, &objp->status))
    727         return FALSE;
    728 
    729     } else {
    730       IXDR_PUT_LONG (buf, objp->wait_return);
    731       IXDR_PUT_LONG (buf, objp->errNo);
    732       IXDR_PUT_LONG (buf, objp->status);
    733     }
    734     if (!xdr_stop_code (xdrs, &objp->reason))
    735       return FALSE;
    736     buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
    737     if (buf == NULL) {
    738       if (!xdr_int (xdrs, &objp->handle))
    739         return FALSE;
    740       if (!xdr_u_long (xdrs, &objp->PC))
    741         return FALSE;
    742       if (!xdr_u_long (xdrs, &objp->SP))
    743         return FALSE;
    744       if (!xdr_u_long (xdrs, &objp->FP))
    745         return FALSE;
    746       if (!xdr_u_long (xdrs, &objp->thread))
    747         return FALSE;
    748     } else {
    749       IXDR_PUT_LONG (buf, objp->handle);
    750       IXDR_PUT_U_LONG (buf, objp->PC);
    751       IXDR_PUT_U_LONG (buf, objp->SP);
    752       IXDR_PUT_U_LONG (buf, objp->FP);
    753       IXDR_PUT_U_LONG (buf, objp->thread);
    754     }
    755     return TRUE;
    756   } else if (xdrs->x_op == XDR_DECODE) {
    757     buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
    758     if (buf == NULL) {
    759       if (!xdr_int (xdrs, &objp->wait_return))
    760         return FALSE;
    761       if (!xdr_int (xdrs, &objp->errNo))
    762         return FALSE;
    763       if (!xdr_int (xdrs, &objp->status))
    764         return FALSE;
    765 
    766     } else {
    767       objp->wait_return = IXDR_GET_LONG (buf);
    768       objp->errNo = IXDR_GET_LONG (buf);
    769       objp->status = IXDR_GET_LONG (buf);
    770     }
    771     if (!xdr_stop_code (xdrs, &objp->reason))
    772       return FALSE;
    773     buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
    774     if (buf == NULL) {
    775       if (!xdr_int (xdrs, &objp->handle))
    776         return FALSE;
    777       if (!xdr_u_long (xdrs, &objp->PC))
    778         return FALSE;
    779       if (!xdr_u_long (xdrs, &objp->SP))
    780         return FALSE;
    781       if (!xdr_u_long (xdrs, &objp->FP))
    782         return FALSE;
    783       if (!xdr_u_long (xdrs, &objp->thread))
    784         return FALSE;
    785     } else {
    786       objp->handle = IXDR_GET_LONG (buf);
    787       objp->PC = IXDR_GET_U_LONG (buf);
    788       objp->SP = IXDR_GET_U_LONG (buf);
    789       objp->FP = IXDR_GET_U_LONG (buf);
    790       objp->thread = IXDR_GET_U_LONG (buf);
    791     }
    792     return TRUE;
    793   }
    794 
    795   if (!xdr_int (xdrs, &objp->wait_return))
    796     return FALSE;
    797   if (!xdr_int (xdrs, &objp->errNo))
    798     return FALSE;
    799   if (!xdr_int (xdrs, &objp->status))
    800     return FALSE;
    801   if (!xdr_stop_code (xdrs, &objp->reason))
    802     return FALSE;
    803   if (!xdr_int (xdrs, &objp->handle))
    804     return FALSE;
    805   if (!xdr_u_long (xdrs, &objp->PC))
    806     return FALSE;
    807   if (!xdr_u_long (xdrs, &objp->SP))
    808     return FALSE;
    809   if (!xdr_u_long (xdrs, &objp->FP))
    810     return FALSE;
    811   if (!xdr_u_long (xdrs, &objp->thread))
    812     return FALSE;
    813   return TRUE;
    814 }
    815 
    816   /*
    817    * now ptrace() routine. This matches the Sun UNIX ptrace as well as
    818    * some additions
    819    */
    820 
    821 bool_t
    822 xdr_ptrace_in (XDR * xdrs, ptrace_in * objp)
    823 {
    824   register int32_t *buf;
    825 
    826   if (!xdr_int (xdrs, &objp->pid))
    827     return FALSE;
    828   if (!xdr_ptrace_addr_data_in (xdrs, &objp->addr))
    829     return FALSE;
    830   if (!xdr_u_int (xdrs, &objp->data))
    831     return FALSE;
    832   if (!xdr_u_int (xdrs, &objp->flags))
    833     return FALSE;
    834   return TRUE;
    835 }
    836 
    837 bool_t
    838 xdr_ptrace_out (XDR * xdrs, ptrace_out * objp)
    839 {
    840   register int32_t *buf;
    841 
    842   if (!xdr_ptrace_addr_data_out (xdrs, &objp->addr))
    843     return FALSE;
    844   if (!xdr_int (xdrs, &objp->result))
    845     return FALSE;
    846   if (!xdr_int (xdrs, &objp->errNo))
    847     return FALSE;
    848   return TRUE;
    849 }
    850 
    851 bool_t
    852 xdr_one_symbol (XDR * xdrs, one_symbol * objp)
    853 {
    854   register int32_t *buf;
    855 
    856   if (!xdr_string (xdrs, &objp->symbolName, ~0))
    857     return FALSE;
    858   if (!xdr_long (xdrs, &objp->symbolValue))
    859     return FALSE;
    860   return TRUE;
    861 }
    862 
    863 bool_t
    864 xdr_all_symbols (XDR * xdrs, all_symbols * objp)
    865 {
    866   register int32_t *buf;
    867 
    868   if (!xdr_array
    869       (xdrs, (char **) &objp->all_symbols_val,
    870        (u_int *) & objp->all_symbols_len, ~0, sizeof (one_symbol),
    871        (xdrproc_t) xdr_one_symbol))
    872     return FALSE;
    873   return TRUE;
    874 }
    875 
    876 bool_t
    877 xdr_get_global_symbols_out (XDR * xdrs, get_global_symbols_out * objp)
    878 {
    879   register int32_t *buf;
    880 
    881   if (!xdr_all_symbols (xdrs, &objp->symbols))
    882     return FALSE;
    883   return TRUE;
    884 }
    885 
    886 bool_t
    887 xdr_get_text_data_in (XDR * xdrs, get_text_data_in * objp)
    888 {
    889   register int32_t *buf;
    890 
    891   if (!xdr_int (xdrs, &objp->pid))
    892     return FALSE;
    893   if (!xdr_string (xdrs, &objp->actorName, 16))
    894     return FALSE;
    895   return TRUE;
    896 }
    897 
    898 bool_t
    899 xdr_get_text_data_out (XDR * xdrs, get_text_data_out * objp)
    900 {
    901   register int32_t *buf;
    902 
    903   if (xdrs->x_op == XDR_ENCODE) {
    904     buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
    905     if (buf == NULL) {
    906       if (!xdr_int (xdrs, &objp->result))
    907         return FALSE;
    908       if (!xdr_int (xdrs, &objp->errNo))
    909         return FALSE;
    910       if (!xdr_u_long (xdrs, &objp->textStart))
    911         return FALSE;
    912       if (!xdr_u_long (xdrs, &objp->textSize))
    913         return FALSE;
    914       if (!xdr_u_long (xdrs, &objp->dataStart))
    915         return FALSE;
    916       if (!xdr_u_long (xdrs, &objp->dataSize))
    917         return FALSE;
    918     } else {
    919       IXDR_PUT_LONG (buf, objp->result);
    920       IXDR_PUT_LONG (buf, objp->errNo);
    921       IXDR_PUT_U_LONG (buf, objp->textStart);
    922       IXDR_PUT_U_LONG (buf, objp->textSize);
    923       IXDR_PUT_U_LONG (buf, objp->dataStart);
    924       IXDR_PUT_U_LONG (buf, objp->dataSize);
    925     }
    926     return TRUE;
    927   } else if (xdrs->x_op == XDR_DECODE) {
    928     buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
    929     if (buf == NULL) {
    930       if (!xdr_int (xdrs, &objp->result))
    931         return FALSE;
    932       if (!xdr_int (xdrs, &objp->errNo))
    933         return FALSE;
    934       if (!xdr_u_long (xdrs, &objp->textStart))
    935         return FALSE;
    936       if (!xdr_u_long (xdrs, &objp->textSize))
    937         return FALSE;
    938       if (!xdr_u_long (xdrs, &objp->dataStart))
    939         return FALSE;
    940       if (!xdr_u_long (xdrs, &objp->dataSize))
    941         return FALSE;
    942     } else {
    943       objp->result = IXDR_GET_LONG (buf);
    944       objp->errNo = IXDR_GET_LONG (buf);
    945       objp->textStart = IXDR_GET_U_LONG (buf);
    946       objp->textSize = IXDR_GET_U_LONG (buf);
    947       objp->dataStart = IXDR_GET_U_LONG (buf);
    948       objp->dataSize = IXDR_GET_U_LONG (buf);
    949     }
    950     return TRUE;
    951   }
    952 
    953   if (!xdr_int (xdrs, &objp->result))
    954     return FALSE;
    955   if (!xdr_int (xdrs, &objp->errNo))
    956     return FALSE;
    957   if (!xdr_u_long (xdrs, &objp->textStart))
    958     return FALSE;
    959   if (!xdr_u_long (xdrs, &objp->textSize))
    960     return FALSE;
    961   if (!xdr_u_long (xdrs, &objp->dataStart))
    962     return FALSE;
    963   if (!xdr_u_long (xdrs, &objp->dataSize))
    964     return FALSE;
    965   return TRUE;
    966 }
    967 
    968 bool_t
    969 xdr_one_signal (XDR * xdrs, one_signal * objp)
    970 {
    971   register int32_t *buf;
    972 
    973   if (!xdr_u_int (xdrs, &objp->number))
    974     return FALSE;
    975   if (!xdr_string (xdrs, &objp->name, ~0))
    976     return FALSE;
    977   return TRUE;
    978 }
    979 
    980 bool_t
    981 xdr_all_signals (XDR * xdrs, all_signals * objp)
    982 {
    983   register int32_t *buf;
    984 
    985   if (!xdr_array
    986       (xdrs, (char **) &objp->all_signals_val,
    987        (u_int *) & objp->all_signals_len, ~0, sizeof (one_signal),
    988        (xdrproc_t) xdr_one_signal))
    989     return FALSE;
    990   return TRUE;
    991 }
    992 
    993 bool_t
    994 xdr_get_signal_names_out (XDR * xdrs, get_signal_names_out * objp)
    995 {
    996   register int32_t *buf;
    997 
    998   if (!xdr_all_signals (xdrs, &objp->signals))
    999     return FALSE;
    1000   return TRUE;
    1001 }
    1002 
    1003   /*
    1004    * now define the actual calls we support
    1005    */
     156bool_t xdr_xdr_mem(xdrs, objp)
     157 XDR *xdrs;
     158 struct xdr_mem *objp;
     159{
     160 if (!xdr_u_long(xdrs, &objp->addr)) {
     161 return (FALSE);
     162 }
     163 if (!xdr_u_int(xdrs, &objp->dataNb)) {
     164 return(FALSE);
     165 }
     166 return (xdr_opaque(xdrs, objp->data, objp->dataNb));
     167}
     168
     169bool_t
     170xdr_break_type (XDR *xdrs, break_type *objp)
     171{
     172        register int32_t *buf;
     173
     174         if (!xdr_enum (xdrs, (enum_t *) objp))
     175                 return FALSE;
     176        return TRUE;
     177}
     178
     179bool_t
     180xdr_xdr_break (XDR *xdrs, xdr_break *objp)
     181{
     182        register int32_t *buf;
     183
     184        int i;
     185
     186        if (xdrs->x_op == XDR_ENCODE) {
     187                 if (!xdr_u_char (xdrs, &objp->type))
     188                         return FALSE;
     189                 if (!xdr_u_char (xdrs, &objp->thread_spec))
     190                         return FALSE;
     191                buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
     192                if (buf == NULL) {
     193                         if (!xdr_u_short (xdrs, &objp->handle))
     194                                 return FALSE;
     195                         if (!xdr_u_long (xdrs, &objp->ee_loc))
     196                                 return FALSE;
     197                         if (!xdr_u_long (xdrs, &objp->ee_type))
     198                                 return FALSE;
     199                         if (!xdr_u_short (xdrs, &objp->length))
     200                                 return FALSE;
     201
     202                } else {
     203                IXDR_PUT_U_SHORT(buf, objp->handle);
     204                IXDR_PUT_U_LONG(buf, objp->ee_loc);
     205                IXDR_PUT_U_LONG(buf, objp->ee_type);
     206                IXDR_PUT_U_SHORT(buf, objp->length);
     207                }
     208                 if (!xdr_u_char (xdrs, &objp->pass_count))
     209                         return FALSE;
     210                 if (!xdr_u_char (xdrs, &objp->curr_pass))
     211                         return FALSE;
     212                buf = XDR_INLINE (xdrs, ( MAX_THRD_BRK ) * BYTES_PER_XDR_UNIT);
     213                if (buf == NULL) {
     214                         if (!xdr_vector (xdrs, (char *)objp->thread_list, MAX_THRD_BRK,
     215                                sizeof (u_long), (xdrproc_t) xdr_u_long))
     216                                 return FALSE;
     217                } else {
     218                        {
     219                                register u_long *genp;
     220
     221                                for (i = 0, genp = objp->thread_list;
     222                                        i < MAX_THRD_BRK; ++i) {
     223                                        IXDR_PUT_U_LONG(buf, *genp++);
     224                                }
     225                        }
     226                }
     227                return TRUE;
     228        } else if (xdrs->x_op == XDR_DECODE) {
     229                 if (!xdr_u_char (xdrs, &objp->type))
     230                         return FALSE;
     231                 if (!xdr_u_char (xdrs, &objp->thread_spec))
     232                         return FALSE;
     233                buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
     234                if (buf == NULL) {
     235                         if (!xdr_u_short (xdrs, &objp->handle))
     236                                 return FALSE;
     237                         if (!xdr_u_long (xdrs, &objp->ee_loc))
     238                                 return FALSE;
     239                         if (!xdr_u_long (xdrs, &objp->ee_type))
     240                                 return FALSE;
     241                         if (!xdr_u_short (xdrs, &objp->length))
     242                                 return FALSE;
     243
     244                } else {
     245                objp->handle = IXDR_GET_U_SHORT(buf);
     246                objp->ee_loc = IXDR_GET_U_LONG(buf);
     247                objp->ee_type = IXDR_GET_U_LONG(buf);
     248                objp->length = IXDR_GET_U_SHORT(buf);
     249                }
     250                 if (!xdr_u_char (xdrs, &objp->pass_count))
     251                         return FALSE;
     252                 if (!xdr_u_char (xdrs, &objp->curr_pass))
     253                         return FALSE;
     254                buf = XDR_INLINE (xdrs, ( MAX_THRD_BRK ) * BYTES_PER_XDR_UNIT);
     255                if (buf == NULL) {
     256                         if (!xdr_vector (xdrs, (char *)objp->thread_list, MAX_THRD_BRK,
     257                                sizeof (u_long), (xdrproc_t) xdr_u_long))
     258                                 return FALSE;
     259                } else {
     260                        {
     261                                register u_long *genp;
     262
     263                                for (i = 0, genp = objp->thread_list;
     264                                        i < MAX_THRD_BRK; ++i) {
     265                                        *genp++ = IXDR_GET_U_LONG(buf);
     266                                }
     267                        }
     268                }
     269         return TRUE;
     270        }
     271
     272         if (!xdr_u_char (xdrs, &objp->type))
     273                 return FALSE;
     274         if (!xdr_u_char (xdrs, &objp->thread_spec))
     275                 return FALSE;
     276         if (!xdr_u_short (xdrs, &objp->handle))
     277                 return FALSE;
     278         if (!xdr_u_long (xdrs, &objp->ee_loc))
     279                 return FALSE;
     280         if (!xdr_u_long (xdrs, &objp->ee_type))
     281                 return FALSE;
     282         if (!xdr_u_short (xdrs, &objp->length))
     283                 return FALSE;
     284         if (!xdr_u_char (xdrs, &objp->pass_count))
     285                 return FALSE;
     286         if (!xdr_u_char (xdrs, &objp->curr_pass))
     287                 return FALSE;
     288         if (!xdr_vector (xdrs, (char *)objp->thread_list, MAX_THRD_BRK,
     289                sizeof (u_long), (xdrproc_t) xdr_u_long))
     290                 return FALSE;
     291        return TRUE;
     292}
     293
     294bool_t
     295xdr_thread_name (XDR *xdrs, thread_name *objp)
     296{
     297        register int32_t *buf;
     298
     299         if (!xdr_string (xdrs, objp, THREADNAMEMAX))
     300                 return FALSE;
     301        return TRUE;
     302}
     303
     304bool_t
     305xdr_KernThread (XDR *xdrs, KernThread *objp)
     306{
     307        register int32_t *buf;
     308
     309         if (!xdr_u_int (xdrs, &objp->threadLi))
     310                 return FALSE;
     311        return TRUE;
     312}
     313bool_t xdr_thread_list(xdrs, objp)
     314 XDR *xdrs;
     315 struct thread_list *objp;
     316{
     317 return (xdr_array(xdrs, (char**)&objp->threads, &objp->nbThread,
     318 UTHREAD_MAX, sizeof(KernThread), xdr_KernThread));
     319}
     320
     321bool_t
     322xdr_ptrace_addr_data_in (XDR *xdrs, ptrace_addr_data_in *objp)
     323{
     324        register int32_t *buf;
     325
     326         if (!xdr_ptracereq (xdrs, &objp->req))
     327                 return FALSE;
     328        switch (objp->req) {
     329        case RPT_SETTHREADREGS:
     330                 if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_in_u.regs))
     331                         return FALSE;
     332                break;
     333        case RPT_SETREGS:
     334                 if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_in_u.regs))
     335                         return FALSE;
     336                break;
     337        case RPT_PSETTHREADREGS:
     338                 if (!xdr_array (xdrs, (char **)&objp->ptrace_addr_data_in_u.pregs.pregs_val, (u_int *) &objp->ptrace_addr_data_in_u.pregs.pregs_len, ~0,
     339                        sizeof (u_int), (xdrproc_t) xdr_u_int))
     340                         return FALSE;
     341                break;
     342        case RPT_PSETREGS:
     343                 if (!xdr_array (xdrs, (char **)&objp->ptrace_addr_data_in_u.pregs.pregs_val, (u_int *) &objp->ptrace_addr_data_in_u.pregs.pregs_len, ~0,
     344                        sizeof (u_int), (xdrproc_t) xdr_u_int))
     345                         return FALSE;
     346                break;
     347        case RPT_SETTHREADNAME:
     348                 if (!xdr_thread_name (xdrs, &objp->ptrace_addr_data_in_u.name))
     349                         return FALSE;
     350                break;
     351        case RPT_WRITETEXT:
     352                 if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_in_u.mem))
     353                         return FALSE;
     354                break;
     355        case RPT_WRITEDATA:
     356                 if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_in_u.mem))
     357                         return FALSE;
     358                break;
     359        case RPT_SETBREAK:
     360                 if (!xdr_xdr_break (xdrs, &objp->ptrace_addr_data_in_u.breakp))
     361                         return FALSE;
     362                break;
     363        default:
     364                 if (!xdr_u_int (xdrs, &objp->ptrace_addr_data_in_u.address))
     365                         return FALSE;
     366                break;
     367        }
     368        return TRUE;
     369}
     370
     371bool_t
     372xdr_ptrace_addr_data_out (XDR *xdrs, ptrace_addr_data_out *objp)
     373{
     374        register int32_t *buf;
     375
     376         if (!xdr_ptracereq (xdrs, &objp->req))
     377                 return FALSE;
     378        switch (objp->req) {
     379        case RPT_GETREGS:
     380                 if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_out_u.regs))
     381                         return FALSE;
     382                break;
     383        case RPT_GETTHREADREGS:
     384                 if (!xdr_xdr_regs (xdrs, &objp->ptrace_addr_data_out_u.regs))
     385                         return FALSE;
     386                break;
     387        case RPT_PGETREGS:
     388                 if (!xdr_array (xdrs, (char **)&objp->ptrace_addr_data_out_u.pregs.pregs_val, (u_int *) &objp->ptrace_addr_data_out_u.pregs.pregs_len, ~0,
     389                        sizeof (u_int), (xdrproc_t) xdr_u_int))
     390                         return FALSE;
     391                break;
     392        case RPT_PGETTHREADREGS:
     393                 if (!xdr_array (xdrs, (char **)&objp->ptrace_addr_data_out_u.pregs.pregs_val, (u_int *) &objp->ptrace_addr_data_out_u.pregs.pregs_len, ~0,
     394                        sizeof (u_int), (xdrproc_t) xdr_u_int))
     395                         return FALSE;
     396                break;
     397        case RPT_THREADLIST:
     398                 if (!xdr_thread_list (xdrs, &objp->ptrace_addr_data_out_u.threads))
     399                         return FALSE;
     400                break;
     401        case RPT_GETTHREADNAME:
     402                 if (!xdr_thread_name (xdrs, &objp->ptrace_addr_data_out_u.name))
     403                         return FALSE;
     404                break;
     405        case RPT_READTEXT:
     406                 if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_out_u.mem))
     407                         return FALSE;
     408                break;
     409        case RPT_GETNAME:
     410                 if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_out_u.mem))
     411                         return FALSE;
     412                break;
     413        case RPT_READDATA:
     414                 if (!xdr_xdr_mem (xdrs, &objp->ptrace_addr_data_out_u.mem))
     415                         return FALSE;
     416                break;
     417        case RPT_GETBREAK:
     418                 if (!xdr_xdr_break (xdrs, &objp->ptrace_addr_data_out_u.breakp))
     419                         return FALSE;
     420                break;
     421        default:
     422                 if (!xdr_u_int (xdrs, &objp->ptrace_addr_data_out_u.addr))
     423                         return FALSE;
     424                break;
     425        }
     426        return TRUE;
     427}
     428
     429bool_t
     430xdr_CHAR_DATA (XDR *xdrs, CHAR_DATA *objp)
     431{
     432        register int32_t *buf;
     433
     434         if (!xdr_bytes (xdrs, (char **)&objp->CHAR_DATA_val, (u_int *) &objp->CHAR_DATA_len, NET_SAFE))
     435                 return FALSE;
     436        return TRUE;
     437}
     438
     439bool_t
     440xdr_one_arg (XDR *xdrs, one_arg *objp)
     441{
     442        register int32_t *buf;
     443
     444         if (!xdr_string (xdrs, objp, NET_SAFE))
     445                 return FALSE;
     446        return TRUE;
     447}
     448 /* now open_connex() routine which establishes a connection to server */
     449
     450bool_t
     451xdr_debug_type (XDR *xdrs, debug_type *objp)
     452{
     453        register int32_t *buf;
     454
     455         if (!xdr_enum (xdrs, (enum_t *) objp))
     456                 return FALSE;
     457        return TRUE;
     458}
     459#define DEBUGGER_IS_GDB 0x2 /* */
     460
     461bool_t
     462xdr_open_in (XDR *xdrs, open_in *objp)
     463{
     464        register int32_t *buf;
     465
     466        int i;
     467         if (!xdr_vector (xdrs, (char *)objp->back_port, 16,
     468                sizeof (u_char), (xdrproc_t) xdr_u_char))
     469                 return FALSE;
     470         if (!xdr_u_short (xdrs, &objp->debug_type))
     471                 return FALSE;
     472         if (!xdr_u_short (xdrs, &objp->flags))
     473                 return FALSE;
     474         if (!xdr_vector (xdrs, (char *)objp->destination, 16,
     475                sizeof (u_char), (xdrproc_t) xdr_u_char))
     476                 return FALSE;
     477         if (!xdr_one_arg (xdrs, &objp->user_name))
     478                 return FALSE;
     479        return TRUE;
     480}
     481
     482bool_t
     483xdr_open_out (XDR *xdrs, open_out *objp)
     484{
     485        register int32_t *buf;
     486
     487        int i;
     488
     489        if (xdrs->x_op == XDR_ENCODE) {
     490                buf = XDR_INLINE (xdrs, (2 + ( 4 )) * BYTES_PER_XDR_UNIT);
     491                if (buf == NULL) {
     492                         if (!xdr_u_long (xdrs, &objp->port))
     493                                 return FALSE;
     494                         if (!xdr_vector (xdrs, (char *)objp->pad, 4,
     495                                sizeof (u_int), (xdrproc_t) xdr_u_int))
     496                                 return FALSE;
     497                         if (!xdr_u_int (xdrs, &objp->fp))
     498                                 return FALSE;
     499
     500                } else {
     501                IXDR_PUT_U_LONG(buf, objp->port);
     502                {
     503                        register u_int *genp;
     504
     505                        for (i = 0, genp = objp->pad;
     506                                i < 4; ++i) {
     507                                IXDR_PUT_U_LONG(buf, *genp++);
     508                        }
     509                }
     510                IXDR_PUT_U_LONG(buf, objp->fp);
     511                }
     512                 if (!xdr_u_char (xdrs, &objp->cmd_table_num))
     513                         return FALSE;
     514                 if (!xdr_u_char (xdrs, &objp->cmd_table_vers))
     515                         return FALSE;
     516                 if (!xdr_u_short (xdrs, &objp->server_vers))
     517                         return FALSE;
     518                return TRUE;
     519        } else if (xdrs->x_op == XDR_DECODE) {
     520                buf = XDR_INLINE (xdrs, (2 + ( 4 )) * BYTES_PER_XDR_UNIT);
     521                if (buf == NULL) {
     522                         if (!xdr_u_long (xdrs, &objp->port))
     523                                 return FALSE;
     524                         if (!xdr_vector (xdrs, (char *)objp->pad, 4,
     525                                sizeof (u_int), (xdrproc_t) xdr_u_int))
     526                                 return FALSE;
     527                         if (!xdr_u_int (xdrs, &objp->fp))
     528                                 return FALSE;
     529
     530                } else {
     531                objp->port = IXDR_GET_U_LONG(buf);
     532                {
     533                        register u_int *genp;
     534
     535                        for (i = 0, genp = objp->pad;
     536                                i < 4; ++i) {
     537                                *genp++ = IXDR_GET_U_LONG(buf);
     538                        }
     539                }
     540                objp->fp = IXDR_GET_U_LONG(buf);
     541                }
     542                 if (!xdr_u_char (xdrs, &objp->cmd_table_num))
     543                         return FALSE;
     544                 if (!xdr_u_char (xdrs, &objp->cmd_table_vers))
     545                         return FALSE;
     546                 if (!xdr_u_short (xdrs, &objp->server_vers))
     547                         return FALSE;
     548         return TRUE;
     549        }
     550
     551         if (!xdr_u_long (xdrs, &objp->port))
     552                 return FALSE;
     553         if (!xdr_vector (xdrs, (char *)objp->pad, 4,
     554                sizeof (u_int), (xdrproc_t) xdr_u_int))
     555                 return FALSE;
     556         if (!xdr_u_int (xdrs, &objp->fp))
     557                 return FALSE;
     558         if (!xdr_u_char (xdrs, &objp->cmd_table_num))
     559                 return FALSE;
     560         if (!xdr_u_char (xdrs, &objp->cmd_table_vers))
     561                 return FALSE;
     562         if (!xdr_u_short (xdrs, &objp->server_vers))
     563                 return FALSE;
     564        return TRUE;
     565}
     566 /* now close_connex() routine which detaches from server */
     567
     568bool_t
     569xdr_close_control (XDR *xdrs, close_control *objp)
     570{
     571        register int32_t *buf;
     572
     573         if (!xdr_enum (xdrs, (enum_t *) objp))
     574                 return FALSE;
     575        return TRUE;
     576}
     577
     578bool_t
     579xdr_close_in (XDR *xdrs, close_in *objp)
     580{
     581        register int32_t *buf;
     582
     583         if (!xdr_close_control (xdrs, &objp->control))
     584                 return FALSE;
     585        return TRUE;
     586}
     587 /* now send_signal() routine which sends signals to processes like kill(2) */
     588
     589bool_t
     590xdr_signal_in (XDR *xdrs, signal_in *objp)
     591{
     592        register int32_t *buf;
     593
     594         if (!xdr_int (xdrs, &objp->pid))
     595                 return FALSE;
     596         if (!xdr_int (xdrs, &objp->sig))
     597                 return FALSE;
     598        return TRUE;
     599}
     600
     601bool_t
     602xdr_signal_out (XDR *xdrs, signal_out *objp)
     603{
     604        register int32_t *buf;
     605
     606         if (!xdr_int (xdrs, &objp->kill_return))
     607                 return FALSE;
     608         if (!xdr_int (xdrs, &objp->errNo))
     609                 return FALSE;
     610        return TRUE;
     611}
     612 /* now wait_info() routine which returns results of polling the wait status
     613        of a process/actor. It may return 0 if running, else pid or -1 */
     614
     615bool_t
     616xdr_stop_code (XDR *xdrs, stop_code *objp)
     617{
     618        register int32_t *buf;
     619
     620         if (!xdr_enum (xdrs, (enum_t *) objp))
     621                 return FALSE;
     622        return TRUE;
     623}
     624
     625bool_t
     626xdr_wait_in (XDR *xdrs, wait_in *objp)
     627{
     628        register int32_t *buf;
     629
     630         if (!xdr_int (xdrs, &objp->pid))
     631                 return FALSE;
     632        return TRUE;
     633}
     634
     635bool_t
     636xdr_wait_out (XDR *xdrs, wait_out *objp)
     637{
     638        register int32_t *buf;
     639
     640
     641        if (xdrs->x_op == XDR_ENCODE) {
     642                buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
     643                if (buf == NULL) {
     644                         if (!xdr_int (xdrs, &objp->wait_return))
     645                                 return FALSE;
     646                         if (!xdr_int (xdrs, &objp->errNo))
     647                                 return FALSE;
     648                         if (!xdr_int (xdrs, &objp->status))
     649                                 return FALSE;
     650
     651                } else {
     652                IXDR_PUT_LONG(buf, objp->wait_return);
     653                IXDR_PUT_LONG(buf, objp->errNo);
     654                IXDR_PUT_LONG(buf, objp->status);
     655                }
     656                 if (!xdr_stop_code (xdrs, &objp->reason))
     657                         return FALSE;
     658                buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
     659                if (buf == NULL) {
     660                         if (!xdr_int (xdrs, &objp->handle))
     661                                 return FALSE;
     662                         if (!xdr_u_long (xdrs, &objp->PC))
     663                                 return FALSE;
     664                         if (!xdr_u_long (xdrs, &objp->SP))
     665                                 return FALSE;
     666                         if (!xdr_u_long (xdrs, &objp->FP))
     667                                 return FALSE;
     668                         if (!xdr_u_long (xdrs, &objp->thread))
     669                                 return FALSE;
     670                } else {
     671                        IXDR_PUT_LONG(buf, objp->handle);
     672                        IXDR_PUT_U_LONG(buf, objp->PC);
     673                        IXDR_PUT_U_LONG(buf, objp->SP);
     674                        IXDR_PUT_U_LONG(buf, objp->FP);
     675                        IXDR_PUT_U_LONG(buf, objp->thread);
     676                }
     677                return TRUE;
     678        } else if (xdrs->x_op == XDR_DECODE) {
     679                buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
     680                if (buf == NULL) {
     681                         if (!xdr_int (xdrs, &objp->wait_return))
     682                                 return FALSE;
     683                         if (!xdr_int (xdrs, &objp->errNo))
     684                                 return FALSE;
     685                         if (!xdr_int (xdrs, &objp->status))
     686                                 return FALSE;
     687
     688                } else {
     689                objp->wait_return = IXDR_GET_LONG(buf);
     690                objp->errNo = IXDR_GET_LONG(buf);
     691                objp->status = IXDR_GET_LONG(buf);
     692                }
     693                 if (!xdr_stop_code (xdrs, &objp->reason))
     694                         return FALSE;
     695                buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
     696                if (buf == NULL) {
     697                         if (!xdr_int (xdrs, &objp->handle))
     698                                 return FALSE;
     699                         if (!xdr_u_long (xdrs, &objp->PC))
     700                                 return FALSE;
     701                         if (!xdr_u_long (xdrs, &objp->SP))
     702                                 return FALSE;
     703                         if (!xdr_u_long (xdrs, &objp->FP))
     704                                 return FALSE;
     705                         if (!xdr_u_long (xdrs, &objp->thread))
     706                                 return FALSE;
     707                } else {
     708                        objp->handle = IXDR_GET_LONG(buf);
     709                        objp->PC = IXDR_GET_U_LONG(buf);
     710                        objp->SP = IXDR_GET_U_LONG(buf);
     711                        objp->FP = IXDR_GET_U_LONG(buf);
     712                        objp->thread = IXDR_GET_U_LONG(buf);
     713                }
     714         return TRUE;
     715        }
     716
     717         if (!xdr_int (xdrs, &objp->wait_return))
     718                 return FALSE;
     719         if (!xdr_int (xdrs, &objp->errNo))
     720                 return FALSE;
     721         if (!xdr_int (xdrs, &objp->status))
     722                 return FALSE;
     723         if (!xdr_stop_code (xdrs, &objp->reason))
     724                 return FALSE;
     725         if (!xdr_int (xdrs, &objp->handle))
     726                 return FALSE;
     727         if (!xdr_u_long (xdrs, &objp->PC))
     728                 return FALSE;
     729         if (!xdr_u_long (xdrs, &objp->SP))
     730                 return FALSE;
     731         if (!xdr_u_long (xdrs, &objp->FP))
     732                 return FALSE;
     733         if (!xdr_u_long (xdrs, &objp->thread))
     734                 return FALSE;
     735        return TRUE;
     736}
     737 /* now ptrace() routine. This matches the Sun UNIX ptrace as well as
     738        some additions */
     739
     740bool_t
     741xdr_ptrace_in (XDR *xdrs, ptrace_in *objp)
     742{
     743        register int32_t *buf;
     744
     745         if (!xdr_int (xdrs, &objp->pid))
     746                 return FALSE;
     747         if (!xdr_ptrace_addr_data_in (xdrs, &objp->addr))
     748                 return FALSE;
     749         if (!xdr_u_int (xdrs, &objp->data))
     750                 return FALSE;
     751         if (!xdr_u_int (xdrs, &objp->flags))
     752                 return FALSE;
     753        return TRUE;
     754}
     755
     756bool_t
     757xdr_ptrace_out (XDR *xdrs, ptrace_out *objp)
     758{
     759        register int32_t *buf;
     760
     761         if (!xdr_ptrace_addr_data_out (xdrs, &objp->addr))
     762                 return FALSE;
     763         if (!xdr_int (xdrs, &objp->result))
     764                 return FALSE;
     765         if (!xdr_int (xdrs, &objp->errNo))
     766                 return FALSE;
     767        return TRUE;
     768}
     769
     770bool_t
     771xdr_one_symbol (XDR *xdrs, one_symbol *objp)
     772{
     773        register int32_t *buf;
     774
     775         if (!xdr_string (xdrs, &objp->symbolName, ~0))
     776                 return FALSE;
     777         if (!xdr_long (xdrs, &objp->symbolValue))
     778                 return FALSE;
     779        return TRUE;
     780}
     781
     782bool_t
     783xdr_all_symbols (XDR *xdrs, all_symbols *objp)
     784{
     785        register int32_t *buf;
     786
     787         if (!xdr_array (xdrs, (char **)&objp->all_symbols_val, (u_int *) &objp->all_symbols_len, ~0,
     788                sizeof (one_symbol), (xdrproc_t) xdr_one_symbol))
     789                 return FALSE;
     790        return TRUE;
     791}
     792
     793bool_t
     794xdr_get_global_symbols_out (XDR *xdrs, get_global_symbols_out *objp)
     795{
     796        register int32_t *buf;
     797
     798         if (!xdr_all_symbols (xdrs, &objp->symbols))
     799                 return FALSE;
     800        return TRUE;
     801}
     802
     803bool_t
     804xdr_get_text_data_in (XDR *xdrs, get_text_data_in *objp)
     805{
     806        register int32_t *buf;
     807
     808         if (!xdr_int (xdrs, &objp->pid))
     809                 return FALSE;
     810         if (!xdr_string (xdrs, &objp->actorName, 16))
     811                 return FALSE;
     812        return TRUE;
     813}
     814
     815bool_t
     816xdr_get_text_data_out (XDR *xdrs, get_text_data_out *objp)
     817{
     818        register int32_t *buf;
     819
     820
     821        if (xdrs->x_op == XDR_ENCODE) {
     822                buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
     823                if (buf == NULL) {
     824                         if (!xdr_int (xdrs, &objp->result))
     825                                 return FALSE;
     826                         if (!xdr_int (xdrs, &objp->errNo))
     827                                 return FALSE;
     828                         if (!xdr_u_long (xdrs, &objp->textStart))
     829                                 return FALSE;
     830                         if (!xdr_u_long (xdrs, &objp->textSize))
     831                                 return FALSE;
     832                         if (!xdr_u_long (xdrs, &objp->dataStart))
     833                                 return FALSE;
     834                         if (!xdr_u_long (xdrs, &objp->dataSize))
     835                                 return FALSE;
     836                } else {
     837                        IXDR_PUT_LONG(buf, objp->result);
     838                        IXDR_PUT_LONG(buf, objp->errNo);
     839                        IXDR_PUT_U_LONG(buf, objp->textStart);
     840                        IXDR_PUT_U_LONG(buf, objp->textSize);
     841                        IXDR_PUT_U_LONG(buf, objp->dataStart);
     842                        IXDR_PUT_U_LONG(buf, objp->dataSize);
     843                }
     844                return TRUE;
     845        } else if (xdrs->x_op == XDR_DECODE) {
     846                buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
     847                if (buf == NULL) {
     848                         if (!xdr_int (xdrs, &objp->result))
     849                                 return FALSE;
     850                         if (!xdr_int (xdrs, &objp->errNo))
     851                                 return FALSE;
     852                         if (!xdr_u_long (xdrs, &objp->textStart))
     853                                 return FALSE;
     854                         if (!xdr_u_long (xdrs, &objp->textSize))
     855                                 return FALSE;
     856                         if (!xdr_u_long (xdrs, &objp->dataStart))
     857                                 return FALSE;
     858                         if (!xdr_u_long (xdrs, &objp->dataSize))
     859                                 return FALSE;
     860                } else {
     861                        objp->result = IXDR_GET_LONG(buf);
     862                        objp->errNo = IXDR_GET_LONG(buf);
     863                        objp->textStart = IXDR_GET_U_LONG(buf);
     864                        objp->textSize = IXDR_GET_U_LONG(buf);
     865                        objp->dataStart = IXDR_GET_U_LONG(buf);
     866                        objp->dataSize = IXDR_GET_U_LONG(buf);
     867                }
     868         return TRUE;
     869        }
     870
     871         if (!xdr_int (xdrs, &objp->result))
     872                 return FALSE;
     873         if (!xdr_int (xdrs, &objp->errNo))
     874                 return FALSE;
     875         if (!xdr_u_long (xdrs, &objp->textStart))
     876                 return FALSE;
     877         if (!xdr_u_long (xdrs, &objp->textSize))
     878                 return FALSE;
     879         if (!xdr_u_long (xdrs, &objp->dataStart))
     880                 return FALSE;
     881         if (!xdr_u_long (xdrs, &objp->dataSize))
     882                 return FALSE;
     883        return TRUE;
     884}
     885
     886bool_t
     887xdr_one_signal (XDR *xdrs, one_signal *objp)
     888{
     889        register int32_t *buf;
     890
     891         if (!xdr_u_int (xdrs, &objp->number))
     892                 return FALSE;
     893         if (!xdr_string (xdrs, &objp->name, ~0))
     894                 return FALSE;
     895        return TRUE;
     896}
     897
     898bool_t
     899xdr_all_signals (XDR *xdrs, all_signals *objp)
     900{
     901        register int32_t *buf;
     902
     903         if (!xdr_array (xdrs, (char **)&objp->all_signals_val, (u_int *) &objp->all_signals_len, ~0,
     904                sizeof (one_signal), (xdrproc_t) xdr_one_signal))
     905                 return FALSE;
     906        return TRUE;
     907}
     908
     909bool_t
     910xdr_get_signal_names_out (XDR *xdrs, get_signal_names_out *objp)
     911{
     912        register int32_t *buf;
     913
     914         if (!xdr_all_signals (xdrs, &objp->signals))
     915                 return FALSE;
     916        return TRUE;
     917}
     918 /* now define the actual calls we support */

  • c/src/librdbg/src/powerpc/new_exception_processing/remdeb.h

    rbdb86b4 r97f6256  
    1717#define RTEMS_BACK_PORT 2073
    1818#ifndef REMDEB_H
    19 #define RPCGENSRVNAME(a)     a
     19#define RPCGENSRVNAME(a) a
    2020
    2121enum rpc_type {
    … …  
    100100/* now define register macros to apply to xdr_regs struct */
    101101
    102 #define R_PC            0
    103 #define R_MSR           1
    104 #define R_EXCEPNB       2
    105 #define R_R0            3
    106 #define R_R1    (R_R0 + 1)
    107 #define R_R2    (R_R0 + 2)
    108 #define R_R3    (R_R0 + 3)
    109 #define R_R4    (R_R0 + 4)
    110 #define R_R5    (R_R0 + 5)
    111 #define R_R6    (R_R0 + 6)
    112 #define R_R7    (R_R0 + 7)
    113 #define R_R8    (R_R0 + 8)
    114 #define R_R9    (R_R0 + 9)
    115 #define R_R10   (R_R0 + 10)
    116 #define R_R11   (R_R0 + 11)
    117 #define R_R12   (R_R0 + 12)
    118 #define R_R13   (R_R0 + 13)
    119 #define R_R14   (R_R0 + 14)
    120 #define R_R15   (R_R0 + 15)
    121 #define R_R16   (R_R0 + 16)
    122 #define R_R17   (R_R0 + 17)
    123 #define R_R18   (R_R0 + 18)
    124 #define R_R19   (R_R0 + 19)
    125 #define R_R20   (R_R0 + 20)
    126 #define R_R21   (R_R0 + 21)
    127 #define R_R22   (R_R0 + 22)
    128 #define R_R23   (R_R0 + 23)
    129 #define R_R24   (R_R0 + 24)
    130 #define R_R25   (R_R0 + 25)
    131 #define R_R26   (R_R0 + 26)
    132 #define R_R27   (R_R0 + 27)
    133 #define R_R28   (R_R0 + 28)
    134 #define R_R29   (R_R0 + 29)
    135 #define R_R30   (R_R0 + 30)
    136 #define R_R31   (R_R0 + 31)
    137 #define R_CR    35
    138 #define R_CTR   36
    139 #define R_XER   37
    140 #define R_LR    38
    141 #define R_MQ    39
     102#define R_PC 0
     103#define R_MSR 1
     104#define R_EXCEPNB 2
     105#define R_R0 3
     106#define R_R1 (R_R0 + 1)
     107#define R_R2 (R_R0 + 2)
     108#define R_R3 (R_R0 + 3)
     109#define R_R4 (R_R0 + 4)
     110#define R_R5 (R_R0 + 5)
     111#define R_R6 (R_R0 + 6)
     112#define R_R7 (R_R0 + 7)
     113#define R_R8 (R_R0 + 8)
     114#define R_R9 (R_R0 + 9)
     115#define R_R10 (R_R0 + 10)
     116#define R_R11 (R_R0 + 11)
     117#define R_R12 (R_R0 + 12)
     118#define R_R13 (R_R0 + 13)
     119#define R_R14 (R_R0 + 14)
     120#define R_R15 (R_R0 + 15)
     121#define R_R16 (R_R0 + 16)
     122#define R_R17 (R_R0 + 17)
     123#define R_R18 (R_R0 + 18)
     124#define R_R19 (R_R0 + 19)
     125#define R_R20 (R_R0 + 20)
     126#define R_R21 (R_R0 + 21)
     127#define R_R22 (R_R0 + 22)
     128#define R_R23 (R_R0 + 23)
     129#define R_R24 (R_R0 + 24)
     130#define R_R25 (R_R0 + 25)
     131#define R_R26 (R_R0 + 26)
     132#define R_R27 (R_R0 + 27)
     133#define R_R28 (R_R0 + 28)
     134#define R_R29 (R_R0 + 29)
     135#define R_R30 (R_R0 + 30)
     136#define R_R31 (R_R0 + 31)
     137#define R_CR 35
     138#define R_CTR 36
     139#define R_XER 37
     140#define R_LR 38
     141#define R_MQ 39
    142142
    143143#include <libcpu/raw_exception.h>
    144144
    145 #define REG_PC tabreg[R_PC]     /* PC register offset */
    146 #define REG_SP tabreg[R_R1]    /* SP register offset */
    147 #define REG_FP tabreg[R_R1]    /* SP register offset (no FP on PPC) */
    148 #define BREAK_SIZE     4      /* Breakpoint occupies 4 bytes */
    149 #define BREAK_ADJ      0      /* Nothing to subtract from address after bp */
    150 #define IS_BREAK(l)    ((l) == 0x7d8d6808)
    151 #define SET_BREAK(l)   (0x7d8d6808)
     145#define REG_PC tabreg[R_PC] /* PC register offset */
     146#define REG_SP tabreg[R_R1] /* SP register offset */
     147#define REG_FP tabreg[R_R1] /* SP register offset (no FP on PPC) */
     148#define BREAK_SIZE 4 /* Breakpoint occupies 4 bytes */
     149#define BREAK_ADJ 0 /* Nothing to subtract from address after bp */
     150#define IS_BREAK(l) ((l) == 0x7d8d6808)
     151#define SET_BREAK(l) (0x7d8d6808)
    152152#define ORG_BREAK(c,p) (p)
    153 #define IS_STEP(regs)  (regs.tabreg[R_EXCEPNB] == ASM_TRACE_VECTOR) /* Was step and not break */
    154 #define TARGET_PROC_TYPE  3
     153#define IS_STEP(regs) (regs.tabreg[R_EXCEPNB] == ASM_TRACE_VECTOR) /* Was step and not break */
     154#define TARGET_PROC_TYPE 3
    155155#define MAXDEBUGGEE 150
    156156#define NAMEMAX 17
    157   /*
     157 /*
    158158   * Memory data for read/write text or data. The size is in data. The target
    159159   * addr is in the addr field.
    … …  
    253253
    254254typedef char *one_arg;
    255   /* now open_connex() routine which establishes a connection to server */
     255 /* now open_connex() routine which establishes a connection to server */
    256256
    257257enum debug_type {
    … …  
    262262};
    263263typedef enum debug_type debug_type;
    264 #define DEBUGGER_IS_GDB 0x2    /* */
     264#define DEBUGGER_IS_GDB 0x2 /* */
    265265
    266266struct open_in {
    … …  
    282282};
    283283typedef struct open_out open_out;
    284   /* now close_connex() routine which detaches from server */
     284 /* now close_connex() routine which detaches from server */
    285285
    286286enum close_control {
    … …  
    295295};
    296296typedef struct close_in close_in;
    297   /* now send_signal() routine which sends signals to processes like kill(2) */
     297 /* now send_signal() routine which sends signals to processes like kill(2) */
    298298
    299299struct signal_in {
    … …  
    308308};
    309309typedef struct signal_out signal_out;
    310   /* now wait_info() routine which returns results of polling the wait status
     310 /* now wait_info() routine which returns results of polling the wait status
    311311        of a process/actor. It may return 0 if running, else pid or -1 */
    312312
    … …  
    343343};
    344344typedef struct wait_out wait_out;
    345   /* now ptrace() routine. This matches the Sun UNIX ptrace as well as
    346         some additions */ 
     345 /* now ptrace() routine. This matches the Sun UNIX ptrace as well as
     346        some additions */
    347347#define PTRFLG_FORCE 1
    348348#define PTRFLG_NON_OWNER 2
    … …  
    412412};
    413413typedef struct get_signal_names_out get_signal_names_out;
    414   /* now define the actual calls we support */
     414 /* now define the actual calls we support */
    415415#define REMDEB_H
    416416#endif

  • c/src/librdbg/src/powerpc/new_exception_processing/remdeb_svc.c

    rbdb86b4 r97f6256  
    1 #include <rpc/types.h>
    2 #include <rpc/rpc.h>
    3 #include <stdio.h>
    4 #include <stdlib.h>
    5 #include <string.h>
    6 #include <bsp.h>
    7 #include <rdbg/servrpc.h>
    8 #include <rdbg/remdeb.h>
    9 #define printf(c)
    10 /*HEADER_START*/
    11 #define RTEMS_PORT 2071
    12 #define RTEMS_BACK_PORT 2073
    13 /*
    14  * Sun request values for the remote ptrace system call
    15  */
    16 
    17   /*
    18    * Memory data for read/write text or data. The size is in data. The target
    19    * addr is in the addr field.
    20    * Be careful before modifying because this value goes into internal
    21    * pipes and is allocated on stack too. Pipes and/or the stack could
    22    * become too small if this value gets incremented.
    23    */
    24   /* now open_connex() routine which establishes a connection to server */
    25 #define DEBUGGER_IS_GDB 0x2    /* */
    26   /* now close_connex() routine which detaches from server */
    27   /* now send_signal() routine which sends signals to processes like kill(2) */
    28   /* now wait_info() routine which returns results of polling the wait status
    29         of a process/actor. It may return 0 if running, else pid or -1 */
    30   /* now ptrace() routine. This matches the Sun UNIX ptrace as well as
    31         some additions */
    32   /* now define the actual calls we support */
    33 const char* names [] = {
    34     "NULLPROC", "OPEN_CONNEX", "SEND_SIGNAL", "name3",
    35     "name4", "name5", "name6", "name7",
    36     "name8", "name9", "CLOSE_CONNEX", "PTRACE",
    37     "name12", "WAIT_INFO", "name14", "name15",
    38     "name16", "GET_SIGNAL_NAMES", "name18"
    39 };
    40 
    41 void
    42 remotedeb_2(struct svc_req *rqstp, register SVCXPRT *transp)
    43 {
    44         union {
    45                 open_in open_connex_2_arg;
    46                 signal_in send_signal_2_arg;
    47                 close_in close_connex_2_arg;
    48                 ptrace_in ptrace_2_arg;
    49                 wait_in wait_info_2_arg;
    50         } argument;
    51         char *result;
    52         xdrproc_t _xdr_argument, _xdr_result;
    53         char *(*local)(char *, struct svc_req *);
    54 
    55         DPRINTF (("remotedeb_2: %s (%d)\n",
    56                 (unsigned) rqstp->rq_proc <
    57                 (unsigned) (sizeof names / sizeof names[0]) ?
    58                 names [rqstp->rq_proc] : "???",
    59                 (int) rqstp->rq_proc));
    60 
    61         switch (rqstp->rq_proc) {
    62         case NULLPROC:
    63                 (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
    64                 return;
    65 
    66         case OPEN_CONNEX:
    67                 _xdr_argument = (xdrproc_t) xdr_open_in;
    68                 _xdr_result = (xdrproc_t) xdr_open_out;
    69                 local = (char *(*)(char *, struct svc_req *)) open_connex_2_svc;
    70                 break;
    71 
    72         case SEND_SIGNAL:
    73                 _xdr_argument = (xdrproc_t) xdr_signal_in;
    74                 _xdr_result = (xdrproc_t) xdr_signal_out;
    75                 local = (char *(*)(char *, struct svc_req *)) send_signal_2_svc;
    76                 break;
    77 
    78         case CLOSE_CONNEX:
    79                 _xdr_argument = (xdrproc_t) xdr_close_in;
    80                 _xdr_result = (xdrproc_t) xdr_void;
    81                 local = (char *(*)(char *, struct svc_req *)) close_connex_2_svc;
    82                 break;
    83 
    84         case PTRACE:
    85                 _xdr_argument = (xdrproc_t) xdr_ptrace_in;
    86                 _xdr_result = (xdrproc_t) xdr_ptrace_out;
    87                 local = (char *(*)(char *, struct svc_req *)) ptrace_2_svc;
    88                 break;
    89 
    90         case WAIT_INFO:
    91                 _xdr_argument = (xdrproc_t) xdr_wait_in;
    92                 _xdr_result = (xdrproc_t) xdr_wait_out;
    93                 local = (char *(*)(char *, struct svc_req *)) wait_info_2_svc;
    94                 break;
    95 
    96         case GET_SIGNAL_NAMES:
    97                 _xdr_argument = (xdrproc_t) xdr_void;
    98                 _xdr_result = (xdrproc_t) xdr_get_signal_names_out;
    99                 local = (char *(*)(char *, struct svc_req *)) get_signal_names_2_svc;
    100                 break;
    101 
    102         default:
    103                 svcerr_noproc (transp);
    104                 return;
    105         }
    106         memset ((char *)&argument, 0, sizeof (argument));
    107         if (!svc_getargs (transp, _xdr_argument, (caddr_t) &argument)) {
    108                 svcerr_decode (transp);
    109                 return;
    110         }
    111         result = (*local)((char *)&argument, rqstp);
    112         if (result != NULL && !svc_sendreply(transp, _xdr_result, result)) {
    113                 svcerr_systemerr (transp);
    114         }
    115         if (!svc_freeargs (transp, _xdr_argument, (caddr_t) &argument)) {
    116                 printf( "unable to free arguments");
    117                 exit (1);
    118         }
    119         return;
    120 }

  • c/src/librdbg/src/powerpc/new_exception_processing/remdeb_xdr.c

    rbdb86b4 r97f6256  
    9898        return TRUE;
    9999}
    100   /*
     100 /*
    101101   * Memory data for read/write text or data. The size is in data. The target