Changeset 40cf43ea in rtems


Ignore:
Timestamp:
Feb 1, 2002, 5:00:01 PM (19 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
569a01f
Parents:
8e3caa5
Message:
  • 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:
35 edited

Legend:

Unmodified
Added
Removed
  • c/src/librdbg/ChangeLog

    r8e3caa5 r40cf43ea  
     1
     2        * So many patches have been posted recently on the mailing list and
     3        because we were unable to find correct solution to compile on various
     4        linux distros (due to rpcgen incompatibilities), and because the coding
     5        style of rdbg was rather inconsistant among various pieces of code, I
     6        decided to:
     7            1) make some cleaning regarding global coding style (using
     8               indent + manual edits),
     9            2) incorporate/review the paches send by various people
     10               (S. Holford, T. Strauman),
     11            3) Fix the bug due to varying rpcgen code generation
     12               in remdeb_svc.c,
     13            4) Remove some dead code,
     14            5) Apply a patches enabling to call enterRdbg imediately
     15               after rdbg initialization is done,
     16
     17        NB : the paches is huge but it is mainly due to coding styke chnages.
     18        Only few lines of codes have been really changed and they do not impact
     19        rdbg functionnality (AFAIKT).
     20
     21        * include/rdbg/servrpc.h, include/rdbg/i386/rdbg_f.h,
     22        include/rdbg/m68k/rdbg_f.h, include/rdbg/powerpc/rdbg_f.h,
     23        src/_servtgt.c, src/awk.svc, src/excep.c, src/ptrace.c, src/rdbg.c,
     24        src/remdeb.x, src/servbkpt.c, src/servcon.c, src/servrpc.c,
     25        src/servtgt.c, src/servtsp.c, src/servutil.c, src/i386/excep_f.c,
     26        src/i386/rdbg_f.c, src/i386/any/Makefile.am, src/i386/any/remdeb.h,
     27        src/i386/any/remdeb_svc.c, src/i386/any/remdeb_xdr.c,
     28        src/m68k/excep_f.c, src/m68k/rdbg_f.c, src/m68k/any/Makefile.am,
     29        src/m68k/any/remdeb.h, src/m68k/any/remdeb_svc.c,
     30        src/m68k/any/remdeb_xdr.c, src/powerpc/excep_f.c, src/powerpc/rdbg_f.c,
     31        src/powerpc/new_exception_processing/Makefile.am,
     32        src/powerpc/new_exception_processing/remdeb.h,
     33        src/powerpc/new_exception_processing/remdeb_svc.c,
     34        src/powerpc/new_exception_processing/remdeb_xdr.c: Modified.
     35
    1362002-01-18      Till Straumann <strauman@slac.stanford.edu>
    237
  • c/src/librdbg/include/rdbg/i386/rdbg_f.h

    r8e3caa5 r40cf43ea  
    3535
    3636extern void connect_rdbg_exception();
     37extern void disconnect_rdbg_exception();
    3738
    3839#endif
  • c/src/librdbg/include/rdbg/m68k/rdbg_f.h

    r8e3caa5 r40cf43ea  
    3333
    3434extern void connect_rdbg_exception();
     35extern void disconnect_rdbg_exception();
    3536
    3637#endif
  • c/src/librdbg/include/rdbg/powerpc/rdbg_f.h

    r8e3caa5 r40cf43ea  
    2222  if (
    2323      ctx->ctx->_EXC_number != ASM_SYS_VECTOR &&
     24      ctx->ctx->_EXC_number != ASM_PROG_VECTOR &&
    2425      ctx->ctx->_EXC_number != ASM_TRACE_VECTOR
    2526      ) return 0;
     
    3233
    3334extern void connect_rdbg_exception();
     35extern void disconnect_rdbg_exception();
    3436
    3537#endif
  • c/src/librdbg/include/rdbg/servrpc.h

    r8e3caa5 r40cf43ea  
    2424extern int TSP_RETRIES;
    2525extern int BackPort;
    26 extern char ActName[];
     26extern char taskName[];
    2727extern int getId();
    2828
  • c/src/librdbg/src/_servtgt.c

    r8e3caa5 r40cf43ea  
    66*/
    77
    8 
    9 #include <string.h>             
     8#include <string.h>
    109#include <rtems.h>
    1110#include <rtems/error.h>
     
    1312#include <rdbg/rdbg.h>
    1413#include <rdbg/rdbg_f.h>
    15 #include <rdbg/servrpc.h>       
     14#include <rdbg/servrpc.h>
    1615#include <errno.h>
    17 #include <sys/socket.h>         
     16#include <sys/socket.h>
    1817#include <assert.h>
    1918#include <rtems/score/cpu.h>
     
    3029rtems_id serializeSemId;
    3130rtems_id wakeupEventSemId;
     31rtems_id debugId;
    3232
    3333CPU_Exception_frame Idle_frame;
     
    3737   ----------------------------------------------------------------- */
    3838
    39     int
    40 TgtRealPtrace(int req, PID aid, char* addr, int d, void* addr2)
    41 {
    42     return ptrace(req, aid, addr, d, addr2);
    43 }
    44 
    45 
     39  int
     40TgtRealPtrace (int req, PID aid, char *addr, int d, void *addr2)
     41{
     42  return ptrace (req, aid, addr, d, addr2);
     43}
    4644
    4745/* -----------------------------------------------------------------------
     
    5149   ----------------------------------------------------------------------- */
    5250
    53     static int
    54 TgtChange (PID pid, CPU_Exception_frame* ctx, int status)
    55 {
    56 
    57     if (TgtHandleChildChange (pid, &status, NULL, ctx)) {
    58       TgtNotifyWaitChange (pid, status, -1);
    59     }
    60 
    61     return 0;
     51  static int
     52TgtChange (PID pid, CPU_Exception_frame * ctx, int status)
     53{
     54
     55  if (TgtHandleChildChange (pid, &status, NULL, ctx)) {
     56    TgtNotifyWaitChange (pid, status, -1);
     57  }
     58
     59  return 0;
    6260}
    6361
     
    6664   ----------------------------------------------------------------------- */
    6765
    68 rtems_task eventTask( rtems_task_argument pid)
     66  rtems_task
     67eventTask (rtems_task_argument pid)
    6968{
    7069  Exception_context *ctx;
     
    7271  DPRINTF (("event task: pid %d\n", pid));
    7372
    74  
    7573  /*
    7674   * we spend all our time waiting for a semaphore.
    7775   * If wait change, we send info
    7876   */
    79  
    80   for (;;){     
     77
     78  for (;;) {
    8179    DPRINTF (("Event Task: wait event\n"));
    82     rtems_semaphore_obtain(wakeupEventSemId, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     80    rtems_semaphore_obtain (wakeupEventSemId, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    8381    DPRINTF (("Event Task: wake up !!!!!!!!!!!!!\n"));
    84    
     82
    8583    errno = 0;
    86     ctx = GetExceptCtx(currentTargetThread);
    87 
    88     CheckForSingleStep(ctx->ctx);
    89 
    90     TgtChange(pid, ctx->ctx,STS_MAKESIG(ExcepToSig(ctx)));
    91      
     84    ctx = GetExceptCtx (currentTargetThread);
     85
     86    CheckForSingleStep (ctx->ctx);
     87
     88    TgtChange (pid, ctx->ctx, STS_MAKESIG (ExcepToSig (ctx)));
    9289  }
    9390}
     
    10198   ---------------------------------------------------------------------*/
    10299
    103 rtems_task MyThreadIdle(rtems_task_argument argument)
    104 {
    105   enterRdbg();
    106   rtems_task_delete( RTEMS_SELF );
     100  rtems_task
     101MyThreadIdle (rtems_task_argument argument)
     102{
     103  enterRdbg ();
     104  rtems_task_delete (RTEMS_SELF);
    107105}
    108106
     
    115113   ----------------------------------------------------------------------- */
    116114
    117 Boolean TgtAttach(
    118   int           conn_idx,       /* client that is requesting */
    119   PID           pid)            /* process to attach to */
    120 {
     115  Boolean
     116TgtAttach (int conn_idx,        /* client that is requesting */
     117           PID pid)
     118{                               /* process to attach to */
    121119  rtems_name task_name;
    122120  rtems_status_code status;
    123   rtems_id debugId;
    124  
     121
    125122  errno = 0;
    126123
    127   DPRINTF (("TgtAttach pid=%d\n",pid));
    128  
    129   Ptrace(RPT_ATTACH, pid, NULL, 0, NULL);
     124  DPRINTF (("TgtAttach pid=%d\n", pid));
     125
     126  Ptrace (RPT_ATTACH, pid, NULL, 0, NULL);
    130127  if (errno)
    131     return(False);              /* failed */
    132 
    133   TgtCreateNew(pid, conn_idx, 0, NULL, False);
    134 
    135 
    136   connect_rdbg_exception();
    137  
     128    return (False);             /* failed */
     129
     130  TgtCreateNew (pid, conn_idx, 0, NULL, False);
     131
     132  connect_rdbg_exception ();
     133
    138134  /*
    139    * Create the attach debuger task
     135   * Search for and remove debugging tasks / semaphores left over from
     136   * a previous attach without a detach.
    140137   */
    141   task_name = rtems_build_name( 'E', 'v', 'n', 't' );
    142   if ((status = rtems_task_create( task_name, 10, 24576,
    143                                    RTEMS_INTERRUPT_LEVEL(0),
    144                                    RTEMS_DEFAULT_ATTRIBUTES | RTEMS_SYSTEM_TASK,
    145                                    &eventTaskId ))
    146       != RTEMS_SUCCESSFUL){
    147     printf("status = %d\n",status);
     138
     139  if (rtems_task_ident (rtems_build_name ('E', 'v', 'n', 't'),
     140                        RTEMS_SEARCH_ALL_NODES,
     141                        &eventTaskId) == RTEMS_SUCCESSFUL)
     142    rtems_task_delete (eventTaskId);
     143
     144  if (rtems_semaphore_ident (rtems_build_name ('D', 'B', 'G', 's'),
     145                             RTEMS_SEARCH_ALL_NODES,
     146                             &serializeSemId) == RTEMS_SUCCESSFUL)
     147    rtems_semaphore_delete (serializeSemId);
     148
     149  if (rtems_semaphore_ident (rtems_build_name ('D', 'B', 'G', 'w'),
     150                             RTEMS_SEARCH_ALL_NODES,
     151                             &wakeupEventSemId) == RTEMS_SUCCESSFUL)
     152    rtems_semaphore_delete (wakeupEventSemId);
     153
     154  /*
     155   * Create the attach debugger task
     156   */
     157  task_name = rtems_build_name ('E', 'v', 'n', 't');
     158  if ((status = rtems_task_create (task_name, 10, 24576,
     159                                   RTEMS_INTERRUPT_LEVEL (0),
     160                                   RTEMS_DEFAULT_ATTRIBUTES |
     161                                   RTEMS_SYSTEM_TASK, &eventTaskId))
     162      != RTEMS_SUCCESSFUL) {
     163    printf ("status = %d\n", status);
    148164    rtems_panic ("Can't create task.\n");
    149165  }
    150  
    151   status = rtems_task_start(eventTaskId, eventTask, pid);
    152 
    153   status = rtems_semaphore_create (rtems_build_name('D', 'B', 'G', 's'),
    154                                    1,
    155                                    RTEMS_FIFO |
    156                                    RTEMS_COUNTING_SEMAPHORE |
    157                                    RTEMS_NO_INHERIT_PRIORITY |
    158                                    RTEMS_NO_PRIORITY_CEILING |
    159                                    RTEMS_LOCAL,
    160                                    0,
    161                                    &serializeSemId);
     166
     167  status = rtems_task_start (eventTaskId, eventTask, pid);
     168
     169  status = rtems_semaphore_create (rtems_build_name ('D', 'B', 'G', 's'),
     170                                   1,
     171                                   RTEMS_FIFO |
     172                                   RTEMS_COUNTING_SEMAPHORE |
     173                                   RTEMS_NO_INHERIT_PRIORITY |
     174                                   RTEMS_NO_PRIORITY_CEILING |
     175                                   RTEMS_LOCAL, 0, &serializeSemId);
    162176  if (status != RTEMS_SUCCESSFUL)
    163     rtems_panic ("Can't create serialize semaphore: `%s'\n",rtems_status_text(status));
    164 
    165   status = rtems_semaphore_create (rtems_build_name('D', 'B', 'G', 'w'),
    166                                    0,
    167                                    RTEMS_FIFO |
    168                                    RTEMS_COUNTING_SEMAPHORE |
    169                                    RTEMS_NO_INHERIT_PRIORITY |
    170                                    RTEMS_NO_PRIORITY_CEILING |
    171                                    RTEMS_LOCAL,
    172                                    0,
    173                                    &wakeupEventSemId);
     177    rtems_panic ("Can't create serialize semaphore: `%s'\n",
     178                 rtems_status_text (status));
     179
     180  status = rtems_semaphore_create (rtems_build_name ('D', 'B', 'G', 'w'),
     181                                   0,
     182                                   RTEMS_FIFO |
     183                                   RTEMS_COUNTING_SEMAPHORE |
     184                                   RTEMS_NO_INHERIT_PRIORITY |
     185                                   RTEMS_NO_PRIORITY_CEILING |
     186                                   RTEMS_LOCAL, 0, &wakeupEventSemId);
    174187  if (status != RTEMS_SUCCESSFUL)
    175     rtems_panic ("Can't create wakeup semaphore: `%s'\n",rtems_status_text(status));
     188    rtems_panic ("Can't create wakeup semaphore: `%s'\n",
     189                 rtems_status_text (status));
    176190
    177191  /*
    178192   * Create the MyThreadIdle task to init Exception mechanism
    179193   */
    180   task_name = rtems_build_name( 'R', 'i', 'n', 'i' );
    181   if ((status = rtems_task_create( task_name, 10, 24576,
    182                                    RTEMS_INTERRUPT_LEVEL(0),
    183                                    RTEMS_DEFAULT_ATTRIBUTES,
    184                                    &debugId ))
    185       != RTEMS_SUCCESSFUL){
    186     printf("status = %d (%s)\n",status,rtems_status_text(status));
     194  task_name = rtems_build_name ('R', 'i', 'n', 'i');
     195  if ((status = rtems_task_create (task_name, 10, 24576,
     196                                   RTEMS_INTERRUPT_LEVEL (0),
     197                                   RTEMS_DEFAULT_ATTRIBUTES, &debugId))
     198      != RTEMS_SUCCESSFUL) {
     199    printf ("status = %d (%s)\n", status, rtems_status_text (status));
    187200    rtems_panic ("Can't create task.\n");
    188201  }
    189202
    190   status = rtems_task_start(debugId, MyThreadIdle, pid);
    191 
    192   return(True);
     203  status = rtems_task_start (debugId, MyThreadIdle, pid);
     204
     205  return (True);
    193206}
    194207
     
    197210   ----------------------------------------------------------------------- */
    198211
    199 int TgtPtrace(         
    200   int           req,
    201   PID           pid,
    202   char          *addr,
    203   int           data,
    204   void          *addr2)
     212int
     213TgtPtrace (int req, PID pid, char *addr, int data, void *addr2)
    205214{
    206215  if ((req == RPT_SINGLESTEP || req == RPT_CONT)
    207   &&  addr2)                    /* clear then step */
    208   {                             /* addr2 is the old value */
    209     int         ret;
     216      && addr2) {               /* clear then step *//* addr2 is the old value */
     217
     218    int ret;
    210219
    211220    errno = 0;
    212221    TgtBreakRestoreOrig (pid, addr, addr2);
    213     ret = Ptrace(RPT_SINGLESTEP, pid, addr, data, NULL); /* step over */
    214     if (ret)            /* error, cannot single-step */
    215     {
     222    ret = Ptrace (RPT_SINGLESTEP, pid, addr, data, NULL);   /* step over */
     223    if (ret) {                  /* error, cannot single-step */
    216224      int pid_idx = FindPidEntry (pid);
    217       TgtBreakCancelStep (&pid_list [pid_idx]);
     225      TgtBreakCancelStep (&pid_list[pid_idx]);
    218226    }
    219     return(ret);                /* failed or done */
    220   }
    221   else
    222     return(Ptrace(req, pid, addr, data, addr2)); /* normal call */
     227    return (ret);               /* failed or done */
     228  } else
     229      return (Ptrace (req, pid, addr, data, addr2));  /* normal call */
    223230}
    224231
     
    227234   --------------------------------------------------------------- */
    228235
    229 int TgtGetThreadName (
    230    PID_LIST     *plst,          /* Process entry */
    231    unsigned     Id,             /* Thread ID */
    232    char         *ThrName)               /* Thread name */
    233 {
    234     int index;
    235     unsigned name;
    236    
    237     if ( Id <_Objects_Information_table[OBJECTS_RTEMS_TASKS]->maximum_id &&
    238          Id >_Objects_Information_table[OBJECTS_RTEMS_TASKS]->minimum_id) {
    239 
    240       index = Id - _Objects_Information_table[OBJECTS_RTEMS_TASKS]->minimum_id;
    241       name = *(unsigned*)(_Objects_Information_table[OBJECTS_RTEMS_TASKS]->local_table[1+index]->name);
    242       ThrName[0] = (char)((name >> 24) & 0xFF );
    243       ThrName[1] = (char)((name >> 16) & 0xFF );
    244       ThrName[2] = (char)((name >> 8)  & 0xFF );
    245       ThrName[3] = (char)( name        & 0xFF );
    246       ThrName[4] = 0x0;
    247       return 0;
    248     }
    249      
    250     if ( Id <_Objects_Information_table[OBJECTS_POSIX_THREADS]->maximum_id &&
    251          Id >_Objects_Information_table[OBJECTS_POSIX_THREADS]->minimum_id) {
    252 
    253       index = Id - _Objects_Information_table[OBJECTS_POSIX_THREADS]->minimum_id;
    254       name = *(unsigned*)(_Objects_Information_table[OBJECTS_POSIX_THREADS]->local_table[1+index]->name);
    255       ThrName[0] = (char)((name >> 24) & 0xFF );
    256       ThrName[1] = (char)((name >> 16) & 0xFF );
    257       ThrName[2] = (char)((name >> 8)  & 0xFF );
    258       ThrName[3] = (char)( name        & 0xFF );
    259       ThrName[4] = 0x0;
    260       return 0;
    261     }
    262      
    263        
    264     return -1;
    265 
     236  int
     237TgtGetThreadName (PID_LIST * plst,  /* Process entry */
     238                  unsigned Id,  /* Thread ID */
     239                  char *ThrName)
     240{                               /* Thread name */
     241  int index;
     242  unsigned name;
     243
     244  if (Id < _Objects_Information_table[OBJECTS_RTEMS_TASKS]->maximum_id &&
     245      Id > _Objects_Information_table[OBJECTS_RTEMS_TASKS]->minimum_id) {
     246
     247    index = Id - _Objects_Information_table[OBJECTS_RTEMS_TASKS]->minimum_id;
     248    name =
     249      *(unsigned *) (_Objects_Information_table[OBJECTS_RTEMS_TASKS]->
     250                     local_table[1 + index]->name);
     251    ThrName[0] = (char) ((name >> 24) & 0xFF);
     252    ThrName[1] = (char) ((name >> 16) & 0xFF);
     253    ThrName[2] = (char) ((name >> 8) & 0xFF);
     254    ThrName[3] = (char) (name & 0xFF);
     255    ThrName[4] = 0x0;
     256    return 0;
     257  }
     258
     259  if (Id < _Objects_Information_table[OBJECTS_POSIX_THREADS]->maximum_id &&
     260      Id > _Objects_Information_table[OBJECTS_POSIX_THREADS]->minimum_id) {
     261
     262    index =
     263      Id - _Objects_Information_table[OBJECTS_POSIX_THREADS]->minimum_id;
     264    name =
     265      *(unsigned *) (_Objects_Information_table[OBJECTS_POSIX_THREADS]->
     266                     local_table[1 + index]->name);
     267    ThrName[0] = (char) ((name >> 24) & 0xFF);
     268    ThrName[1] = (char) ((name >> 16) & 0xFF);
     269    ThrName[2] = (char) ((name >> 8) & 0xFF);
     270    ThrName[3] = (char) (name & 0xFF);
     271    ThrName[4] = 0x0;
     272    return 0;
     273  }
     274
     275  return -1;
    266276}
    267277
     
    270280   ----------------------------------------------------------------- */
    271281
    272     int
    273 TgtThreadList (
    274   PID_LIST* plst,               /* Process entry */
    275   unsigned* threads,            /* Output buffer */
    276   unsigned size)                /* Output buffer size */
    277 {
    278     int curr = 0;
    279     Objects_Id  id;     
    280     unsigned index;
    281 
    282     id = _Objects_Information_table[OBJECTS_RTEMS_TASKS]->minimum_id;
    283 
    284     while (id < _Objects_Information_table[OBJECTS_RTEMS_TASKS]->maximum_id){
    285       index = id - _Objects_Information_table[OBJECTS_RTEMS_TASKS]->minimum_id;
    286       if ( _Objects_Information_table[OBJECTS_RTEMS_TASKS]->local_table[1+index] != NULL){
     282  int
     283TgtThreadList (PID_LIST * plst, /* Process entry */
     284               unsigned *threads,   /* Output buffer */
     285               unsigned size)
     286{                               /* Output buffer size */
     287  int curr = 0;
     288  Objects_Id id;
     289  unsigned index;
     290
     291  id = _Objects_Information_table[OBJECTS_RTEMS_TASKS]->minimum_id;
     292
     293  while (id < _Objects_Information_table[OBJECTS_RTEMS_TASKS]->maximum_id) {
     294    index = id - _Objects_Information_table[OBJECTS_RTEMS_TASKS]->minimum_id;
     295    if (_Objects_Information_table[OBJECTS_RTEMS_TASKS]->
     296        local_table[1 + index] != NULL) {
    287297      threads[curr] = (unsigned) id;
    288298      curr++;
    289       }
    290       id ++;
    291299    }
    292        
    293     id = _Objects_Information_table[OBJECTS_POSIX_THREADS]->minimum_id;
    294 
    295     while (id < _Objects_Information_table[OBJECTS_POSIX_THREADS]->maximum_id){
    296       index = id - _Objects_Information_table[OBJECTS_POSIX_THREADS]->minimum_id;
    297       if ( _Objects_Information_table[OBJECTS_POSIX_THREADS]->local_table[1+index] != NULL){
     300    id++;
     301  }
     302
     303  id = _Objects_Information_table[OBJECTS_POSIX_THREADS]->minimum_id;
     304
     305  while (id < _Objects_Information_table[OBJECTS_POSIX_THREADS]->maximum_id) {
     306    index =
     307      id - _Objects_Information_table[OBJECTS_POSIX_THREADS]->minimum_id;
     308    if (_Objects_Information_table[OBJECTS_POSIX_THREADS]->
     309        local_table[1 + index] != NULL) {
    298310      threads[curr] = (unsigned) id;
    299311      curr++;
    300       }
    301       id ++;
    302312    }
    303        
    304     return curr;
    305 }
     313    id++;
     314  }
     315
     316  return curr;
     317}
  • c/src/librdbg/src/awk.svc

    r8e3caa5 r40cf43ea  
    2727    printf("#include <rdbg/servrpc.h>\n");
    2828    printf("#include <rdbg/%s>\n", THEPROG);
    29     printf("#define fprintf(a,b) printf(b)\n");
     29    printf("#define fprintf(a,b,c) printf(b,c)\n");
    3030}
    3131
  • c/src/librdbg/src/excep.c

    r8e3caa5 r40cf43ea  
    2525CPU_Exception_frame SavedContext;
    2626
     27/*
     28 * Save an exception context at the end of a list
     29 */
    2730
    28 /********* Save an exception context at the end of a list *****/
    29 
    30 int PushExceptCtx ( Objects_Id Id, Objects_Id semId, CPU_Exception_frame *ctx ) {
     31  int
     32PushExceptCtx (Objects_Id Id, Objects_Id semId, CPU_Exception_frame * ctx)
     33{
    3134
    3235  Exception_context *SaveCtx;
    3336
    34   SaveCtx = (Exception_context *)malloc(sizeof(Exception_context));
     37  SaveCtx = (Exception_context *) malloc (sizeof (Exception_context));
    3538  if (SaveCtx == NULL)
    36     rtems_panic("Can't allocate memory to save Exception context");
    37  
     39    rtems_panic ("Can't allocate memory to save Exception context");
     40
    3841  SaveCtx->id = Id;
    3942  SaveCtx->ctx = ctx;
     
    4144  SaveCtx->previous = NULL;
    4245  SaveCtx->next = NULL;
    43  
    44   if (FirstCtx == NULL){  /* initialization */
     46
     47  if (FirstCtx == NULL) {       /* initialization */
    4548    FirstCtx = SaveCtx;
    46     LastCtx  = SaveCtx;
     49    LastCtx = SaveCtx;
    4750    NbExceptCtx = 1;
    48   }
    49   else {
    50     NbExceptCtx ++;
     51  } else {
     52    NbExceptCtx++;
    5153    LastCtx->next = SaveCtx;
    5254    SaveCtx->previous = LastCtx;
     
    5658}
    5759
    58 /********* Save an temporary exception context in a ******/
    59 /********* global variable                          ******/
     60/*
     61 * Save an temporary exception context in a global variable
     62 */
    6063
    61 int PushSavedExceptCtx ( Objects_Id Id, CPU_Exception_frame *ctx ) {
    62 
    63   memcpy (&(SavedContext), ctx, sizeof(CPU_Exception_frame));
     64  int
     65PushSavedExceptCtx (Objects_Id Id, CPU_Exception_frame * ctx)
     66{
     67  memcpy (&(SavedContext), ctx, sizeof (CPU_Exception_frame));
    6468  return 0;
    6569}
    6670
     71/*
     72 * Remove the context of the specified Id thread.
     73 * If Id = -1, then return the first context
     74 */
    6775
    68 /****** Remove the context of the specified Id thread *********/
    69 /****** If Id = -1, then return the first context     *********/
    70 
    71 
    72 int PopExceptCtx ( Objects_Id Id ) {
     76  int
     77PopExceptCtx (Objects_Id Id)
     78{
    7379
    7480  Exception_context *ExtractCtx;
    75  
    76   if (FirstCtx == NULL) return -1;
    77  
    78   if  (Id == -1) {
     81
     82  if (FirstCtx == NULL)
     83    return -1;
     84
     85  if (Id == -1) {
    7986    ExtractCtx = LastCtx;
    8087    LastCtx = LastCtx->previous;
    81     free(ExtractCtx);
    82     NbExceptCtx --;
     88    free (ExtractCtx);
     89    NbExceptCtx--;
    8390    return 0;
    8491  }
    85  
     92
    8693  ExtractCtx = LastCtx;
    87  
     94
    8895  while (ExtractCtx->id != Id && ExtractCtx != NULL) {
    8996    ExtractCtx = ExtractCtx->previous;
     
    93100    return -1;
    94101
    95   if ( ExtractCtx->previous != NULL)
     102  if (ExtractCtx->previous != NULL)
    96103    (ExtractCtx->previous)->next = ExtractCtx->next;
    97104
    98   if ( ExtractCtx->next != NULL)
     105  if (ExtractCtx->next != NULL)
    99106    (ExtractCtx->next)->previous = ExtractCtx->previous;
    100107
    101108  if (ExtractCtx == FirstCtx)
    102109    FirstCtx = FirstCtx->next;
    103   else
    104   if (ExtractCtx == LastCtx)
     110  else if (ExtractCtx == LastCtx)
    105111    LastCtx = LastCtx->previous;
    106  
    107   free(ExtractCtx);
    108   NbExceptCtx --;
     112
     113  free (ExtractCtx);
     114  NbExceptCtx--;
    109115  return 0;
    110116}
    111  
    112 /****** Return the context of the specified Id thread *********/
    113 /****** If Id = -1, then return the first context     *********/
    114117
     118/*
     119 * Return the context of the specified Id thread.
     120 * If Id = -1, then return the first context.
     121 */
    115122
    116 Exception_context *GetExceptCtx ( Objects_Id Id ) {
     123  Exception_context *
     124GetExceptCtx (Objects_Id Id)
     125{
    117126
    118127  Exception_context *ExtractCtx;
    119128
    120   if (FirstCtx == NULL) return NULL;
    121  
    122   if  (Id == -1) {
     129  if (FirstCtx == NULL)
     130    return NULL;
     131
     132  if (Id == -1) {
    123133    return LastCtx;
    124134  }
    125  
     135
    126136  ExtractCtx = LastCtx;
    127137
  • c/src/librdbg/src/i386/any/Makefile.am

    r8e3caa5 r40cf43ea  
    7272        $(AWK) -f ./awk.svc THEPROG="remdeb.h" i386/any/tmpSvc.c \
    7373          > i386/any/remdeb_svc.c; \
     74        $(SED) -e 's/fprintf.*,/printf(/'  i386/any/remdeb_svc.c > i386/any/remdeb_svc.tmp; \
     75        mv i386/any/remdeb_svc.tmp i386/any/remdeb_svc.c; \
    7476        rm -f i386/any/tmpSvc.c )
    7577endif
  • c/src/librdbg/src/i386/any/remdeb.h

    r8e3caa5 r40cf43ea  
    99#include <rpc/rpc.h>
    1010
    11 
    1211#ifdef __cplusplus
    1312extern "C" {
     
    1918#define RPCGENSRVNAME(a)     a
    2019
    21 enum rpc_type {
    22         SUNRPC = 0,
    23         BADRPCTYPE = 25,
    24 };
    25 typedef enum rpc_type rpc_type;
     20  enum rpc_type {
     21    SUNRPC = 0,
     22    BADRPCTYPE = 25,
     23  };
     24  typedef enum rpc_type rpc_type;
    2625#define NET_SAFE 1400
    2726
    28 struct UDP_MSG {
    29         u_char type;
    30         u_char msg_num;
    31         u_short spec;
    32         long pid;
    33         u_long context;
    34 };
    35 typedef struct UDP_MSG UDP_MSG;
     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;
    3635/*
    3736 * Sun request values for the remote ptrace system call
    3837 */
    3938
    40 
    41 enum 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 };
    94 typedef enum ptracereq ptracereq;
    95 
    96 struct xdr_regs {
    97         u_int tabreg[19];
    98 };
    99 typedef struct xdr_regs xdr_regs;
     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;
    10098/* now define register macros to apply to xdr_reg struct */
    10199
     
    120118#define SS     18
    121119
    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 */
     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 */
    125123/* now define the BREAKPOINT mask technique to a long word */
    126 #define SET_BREAK(l)   ((l&0xFFFFFF00) | 0xCC) 
     124#define SET_BREAK(l)   ((l&0xFFFFFF00) | 0xCC)
    127125#define IS_BREAK(l)    (((l) & 0xFF) == 0xCC)
    128126#define ORG_BREAK(c,p) (((c) & 0xFFFFFF00) | ((p) & 0xFF))
    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 */
     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 */
    132130#define TARGET_PROC_TYPE  0
    133131#define MAXDEBUGGEE 150
     
    142140#define MEM_DATA_MAX 256
    143141
    144 struct xdr_mem {
    145         u_long addr;
    146         u_int dataNb;
    147         u_char data[MEM_DATA_MAX];
    148 };
    149 typedef struct xdr_mem xdr_mem;
    150 
    151 enum 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 };
    162 typedef enum break_type break_type;
     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;
    163161#define MAX_THRD_BRK 4
    164162
    165 struct 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 };
    176 typedef struct xdr_break xdr_break;
     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;
    177175#define UTHREAD_MAX 64
    178176#define THREADNAMEMAX 16
    179177
    180 typedef char *thread_name;
    181 
    182 struct KernThread {
    183         u_int threadLi;
    184 };
    185 typedef struct KernThread KernThread;
    186 typedef KernThread *ptThreadList;
    187 
    188 struct thread_list {
    189         u_int nbThread;
    190         ptThreadList threads;
    191 };
    192 typedef struct thread_list thread_list;
    193 
    194 struct 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 };
    208 typedef struct ptrace_addr_data_in ptrace_addr_data_in;
    209 
    210 struct 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 };
    225 typedef struct ptrace_addr_data_out ptrace_addr_data_out;
    226 
    227 typedef struct {
    228         u_int CHAR_DATA_len;
    229         char *CHAR_DATA_val;
    230 } CHAR_DATA;
     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;
    231229#define XRY_MAX_INST_BUFF 128
    232230#define XRY_MAX_INSTANCES 16
    233231#ifndef XRY_MAX_CMD_STR
    234232#define XRY_MAX_CMD_STR 320
    235 #endif  /* REMDEB_H */
    236 
    237 struct xry_inst {
    238         u_char flags;
    239         u_char type;
    240         u_char sub_type;
    241         u_char res_type;
    242         u_long value;
    243         u_long value2;
    244 };
    245 typedef struct xry_inst xry_inst;
    246 
    247 struct instance {
    248         struct xry_inst instances[XRY_MAX_INSTANCES];
    249         u_char buffer[XRY_MAX_INST_BUFF];
    250 };
    251 typedef struct instance instance;
    252 
    253 struct instance_union {
    254         bool_t instances;
    255         union {
    256                 instance inst;
    257                 char *buffer;
    258         } instance_union_u;
    259 };
    260 typedef struct instance_union instance_union;
    261 
    262 typedef char *one_arg;
     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;
    263261#define XRY_MAX_OBJ_NAME 32
    264   /* now open_connex() routine which establishes a connection to server */
    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   /* now close_connex() routine which detaches from server */
    294 
    295 enum close_control {
    296         CLOSE_IGNORE = 0,
    297         CLOSE_KILL = 1,
    298         CLOSE_DETACH = 2,
    299 };
    300 typedef enum close_control close_control;
    301 
    302 struct close_in {
    303         close_control control;
    304 };
    305 typedef struct close_in close_in;
    306   /* now send_signal() routine which sends signals to processes like kill(2) */
    307 
    308 struct signal_in {
    309         int pid;
    310         int sig;
    311 };
    312 typedef struct signal_in signal_in;
    313 
    314 struct signal_out {
    315         int kill_return;
    316         int errNo;
    317 };
    318 typedef struct signal_out signal_out;
    319   /* now wait_info() routine which returns results of polling the wait status
    320         of a process/actor. It may return 0 if running, else pid or -1 */
    321 
    322 enum stop_code {
    323         STOP_ERROR = 0,
    324         STOP_NONE = 1,
    325         STOP_UNKNOWN = 2,
    326         STOP_BREAK = 3,
    327         STOP_STEP = 4,
    328         STOP_SIGNAL = 5,
    329         STOP_TERM_EXIT = 6,
    330         STOP_TERM_SIG = 7,
    331         STOP_DETACHED = 8,
    332         STOP_KILLED = 9,
    333         STOP_SPAWN_FAILED = 10,
    334 };
    335 typedef enum stop_code stop_code;
    336 
    337 struct wait_in {
    338         int pid;
    339 };
    340 typedef struct wait_in wait_in;
    341 
    342 struct wait_out {
    343         int wait_return;
    344         int errNo;
    345         int status;
    346         stop_code reason;
    347         int handle;
    348         u_long PC;
    349         u_long SP;
    350         u_long FP;
    351         u_long thread;
    352 };
    353 typedef struct wait_out wait_out;
    354   /* now ptrace() routine. This matches the Sun UNIX ptrace as well as
    355         some additions */
     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   */
    356364#define PTRFLG_FORCE 1
    357365#define PTRFLG_NON_OWNER 2
     
    359367#define PTRDET_UNOWN 0x100
    360368
    361 struct ptrace_in {
    362         int pid;
    363         ptrace_addr_data_in addr;
    364         u_int data;
    365         u_int flags;
    366 };
    367 typedef struct ptrace_in ptrace_in;
    368 
    369 struct ptrace_out {
    370         ptrace_addr_data_out addr;
    371         int result;
    372         int errNo;
    373 };
    374 typedef struct ptrace_out ptrace_out;
    375 
    376 struct one_symbol {
    377         char *symbolName;
    378         long symbolValue;
    379 };
    380 typedef struct one_symbol one_symbol;
    381 
    382 typedef struct {
    383         u_int all_symbols_len;
    384         one_symbol *all_symbols_val;
    385 } all_symbols;
    386 
    387 struct get_global_symbols_out {
    388         all_symbols symbols;
    389 };
    390 typedef struct get_global_symbols_out get_global_symbols_out;
    391 
    392 struct get_text_data_in {
    393         int pid;
    394         char *actorName;
    395 };
    396 typedef struct get_text_data_in get_text_data_in;
    397 
    398 struct get_text_data_out {
    399         int result;
    400         int errNo;
    401         u_long textStart;
    402         u_long textSize;
    403         u_long dataStart;
    404         u_long dataSize;
    405 };
    406 typedef struct get_text_data_out get_text_data_out;
    407 
    408 struct one_signal {
    409         u_int number;
    410         char *name;
    411 };
    412 typedef struct one_signal one_signal;
    413 
    414 typedef struct {
    415         u_int all_signals_len;
    416         one_signal *all_signals_val;
    417 } all_signals;
    418 
    419 struct get_signal_names_out {
    420         all_signals signals;
    421 };
    422 typedef struct get_signal_names_out get_signal_names_out;
    423   /* now define the actual calls we support */
     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   */
    424434#define REMDEB_H
    425435#endif
     
    430440#if defined(__STDC__) || defined(__cplusplus)
    431441#define OPEN_CONNEX 1
    432 extern  open_out * open_connex_2(open_in *, CLIENT *);
    433 extern  open_out * open_connex_2_svc(open_in *, struct svc_req *);
     442  extern open_out *open_connex_2 (open_in *, CLIENT *);
     443  extern open_out *open_connex_2_svc (open_in *, struct svc_req *);
    434444#define SEND_SIGNAL 2
    435 extern  signal_out * send_signal_2(signal_in *, CLIENT *);
    436 extern  signal_out * send_signal_2_svc(signal_in *, struct svc_req *);
     445  extern signal_out *send_signal_2 (signal_in *, CLIENT *);
     446  extern signal_out *send_signal_2_svc (signal_in *, struct svc_req *);
    437447#define CLOSE_CONNEX 10
    438 extern  void * close_connex_2(close_in *, CLIENT *);
    439 extern  void * close_connex_2_svc(close_in *, struct svc_req *);
     448  extern void *close_connex_2 (close_in *, CLIENT *);
     449  extern void *close_connex_2_svc (close_in *, struct svc_req *);
    440450#define PTRACE 11
    441 extern  ptrace_out * ptrace_2(ptrace_in *, CLIENT *);
    442 extern  ptrace_out * ptrace_2_svc(ptrace_in *, struct svc_req *);
     451  extern ptrace_out *ptrace_2 (ptrace_in *, CLIENT *);
     452  extern ptrace_out *ptrace_2_svc (ptrace_in *, struct svc_req *);
    443453#define WAIT_INFO 13
    444 extern  wait_out * wait_info_2(wait_in *, CLIENT *);
    445 extern  wait_out * wait_info_2_svc(wait_in *, struct svc_req *);
     454  extern wait_out *wait_info_2 (wait_in *, CLIENT *);
     455  extern wait_out *wait_info_2_svc (wait_in *, struct svc_req *);
    446456#define GET_SIGNAL_NAMES 17
    447 extern  get_signal_names_out * get_signal_names_2(void *, CLIENT *);
    448 extern  get_signal_names_out * get_signal_names_2_svc(void *, struct svc_req *);
    449 extern int remotedeb_2_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
    450 
    451 #else /* K&R C */
     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 */
    452463#define OPEN_CONNEX 1
    453 extern  open_out * open_connex_2();
    454 extern  open_out * open_connex_2_svc();
     464  extern open_out *open_connex_2 ();
     465  extern open_out *open_connex_2_svc ();
    455466#define SEND_SIGNAL 2
    456 extern  signal_out * send_signal_2();
    457 extern  signal_out * send_signal_2_svc();
     467  extern signal_out *send_signal_2 ();
     468  extern signal_out *send_signal_2_svc ();
    458469#define CLOSE_CONNEX 10
    459 extern  void * close_connex_2();
    460 extern  void * close_connex_2_svc();
     470  extern void *close_connex_2 ();
     471  extern void *close_connex_2_svc ();
    461472#define PTRACE 11
    462 extern  ptrace_out * ptrace_2();
    463 extern  ptrace_out * ptrace_2_svc();
     473  extern ptrace_out *ptrace_2 ();
     474  extern ptrace_out *ptrace_2_svc ();
    464475#define WAIT_INFO 13
    465 extern  wait_out * wait_info_2();
    466 extern  wait_out * wait_info_2_svc();
     476  extern wait_out *wait_info_2 ();
     477  extern wait_out *wait_info_2_svc ();
    467478#define GET_SIGNAL_NAMES 17
    468 extern  get_signal_names_out * get_signal_names_2();
    469 extern  get_signal_names_out * get_signal_names_2_svc();
    470 extern int remotedeb_2_freeresult ();
    471 #endif /* K&R C */
     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 */
    472483
    473484/* the xdr functions */
    474485
    475486#if defined(__STDC__) || defined(__cplusplus)
    476 extern  bool_t xdr_rpc_type (XDR *, rpc_type*);
    477 extern  bool_t xdr_UDP_MSG (XDR *, UDP_MSG*);
    478 extern  bool_t xdr_ptracereq (XDR *, ptracereq*);
    479 extern  bool_t xdr_xdr_regs (XDR *, xdr_regs*);
    480 extern  bool_t xdr_xdr_mem (XDR *, xdr_mem*);
    481 extern  bool_t xdr_break_type (XDR *, break_type*);
    482 extern  bool_t xdr_xdr_break (XDR *, xdr_break*);
    483 extern  bool_t xdr_thread_name (XDR *, thread_name*);
    484 extern  bool_t xdr_KernThread (XDR *, KernThread*);
    485 extern  bool_t xdr_thread_list (XDR *, thread_list*);
    486 extern  bool_t xdr_ptrace_addr_data_in (XDR *, ptrace_addr_data_in*);
    487 extern  bool_t xdr_ptrace_addr_data_out (XDR *, ptrace_addr_data_out*);
    488 extern  bool_t xdr_CHAR_DATA (XDR *, CHAR_DATA*);
    489 extern  bool_t xdr_xry_inst (XDR *, xry_inst*);
    490 extern  bool_t xdr_instance (XDR *, instance*);
    491 extern  bool_t xdr_instance_union (XDR *, instance_union*);
    492 extern  bool_t xdr_one_arg (XDR *, one_arg*);
    493 extern  bool_t xdr_debug_type (XDR *, debug_type*);
    494 extern  bool_t xdr_open_in (XDR *, open_in*);
    495 extern  bool_t xdr_open_out (XDR *, open_out*);
    496 extern  bool_t xdr_close_control (XDR *, close_control*);
    497 extern  bool_t xdr_close_in (XDR *, close_in*);
    498 extern  bool_t xdr_signal_in (XDR *, signal_in*);
    499 extern  bool_t xdr_signal_out (XDR *, signal_out*);
    500 extern  bool_t xdr_stop_code (XDR *, stop_code*);
    501 extern  bool_t xdr_wait_in (XDR *, wait_in*);
    502 extern  bool_t xdr_wait_out (XDR *, wait_out*);
    503 extern  bool_t xdr_ptrace_in (XDR *, ptrace_in*);
    504 extern  bool_t xdr_ptrace_out (XDR *, ptrace_out*);
    505 extern  bool_t xdr_one_symbol (XDR *, one_symbol*);
    506 extern  bool_t xdr_all_symbols (XDR *, all_symbols*);
    507 extern  bool_t xdr_get_global_symbols_out (XDR *, get_global_symbols_out*);
    508 extern  bool_t xdr_get_text_data_in (XDR *, get_text_data_in*);
    509 extern  bool_t xdr_get_text_data_out (XDR *, get_text_data_out*);
    510 extern  bool_t xdr_one_signal (XDR *, one_signal*);
    511 extern  bool_t xdr_all_signals (XDR *, all_signals*);
    512 extern  bool_t xdr_get_signal_names_out (XDR *, get_signal_names_out*);
    513 
    514 #else /* K&R C */
    515 extern bool_t xdr_rpc_type ();
    516 extern bool_t xdr_UDP_MSG ();
    517 extern bool_t xdr_ptracereq ();
    518 extern bool_t xdr_xdr_regs ();
    519 extern bool_t xdr_xdr_mem ();
    520 extern bool_t xdr_break_type ();
    521 extern bool_t xdr_xdr_break ();
    522 extern bool_t xdr_thread_name ();
    523 extern bool_t xdr_KernThread ();
    524 extern bool_t xdr_thread_list ();
    525 extern bool_t xdr_ptrace_addr_data_in ();
    526 extern bool_t xdr_ptrace_addr_data_out ();
    527 extern bool_t xdr_CHAR_DATA ();
    528 extern bool_t xdr_xry_inst ();
    529 extern bool_t xdr_instance ();
    530 extern bool_t xdr_instance_union ();
    531 extern bool_t xdr_one_arg ();
    532 extern bool_t xdr_debug_type ();
    533 extern bool_t xdr_open_in ();
    534 extern bool_t xdr_open_out ();
    535 extern bool_t xdr_close_control ();
    536 extern bool_t xdr_close_in ();
    537 extern bool_t xdr_signal_in ();
    538 extern bool_t xdr_signal_out ();
    539 extern bool_t xdr_stop_code ();
    540 extern bool_t xdr_wait_in ();
    541 extern bool_t xdr_wait_out ();
    542 extern bool_t xdr_ptrace_in ();
    543 extern bool_t xdr_ptrace_out ();
    544 extern bool_t xdr_one_symbol ();
    545 extern bool_t xdr_all_symbols ();
    546 extern bool_t xdr_get_global_symbols_out ();
    547 extern bool_t xdr_get_text_data_in ();
    548 extern bool_t xdr_get_text_data_out ();
    549 extern bool_t xdr_one_signal ();
    550 extern bool_t xdr_all_signals ();
    551 extern bool_t xdr_get_signal_names_out ();
    552 
    553 #endif /* K&R C */
     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 */
    554565
    555566#ifdef __cplusplus
    556567}
    557568#endif
    558 
    559 #endif /* !_REMDEB_H_RPCGEN */
     569#endif                          /* !_REMDEB_H_RPCGEN */
  • c/src/librdbg/src/i386/any/remdeb_svc.c

    r8e3caa5 r40cf43ea  
    2323   */
    2424#ifndef XRY_MAX_CMD_STR
    25 #endif  /* REMDEB_H */
    26   /* now open_connex() routine which establishes a connection to server */
    27 #define DEBUGGER_IS_GDB 0x2    /* */
    28   /* now close_connex() routine which detaches from server */
    29   /* now send_signal() routine which sends signals to processes like kill(2) */
    30   /* now wait_info() routine which returns results of polling the wait status
    31         of a process/actor. It may return 0 if running, else pid or -1 */
    32   /* now ptrace() routine. This matches the Sun UNIX ptrace as well as
    33         some additions */
    34   /* now define the actual calls we support */
    35 const char* names [] = {
    36     "NULLPROC", "OPEN_CONNEX", "SEND_SIGNAL", "name3",
    37     "name4", "name5", "name6", "name7",
    38     "name8", "name9", "CLOSE_CONNEX", "PTRACE",
    39     "name12", "WAIT_INFO", "name14", "name15",
    40     "name16", "GET_SIGNAL_NAMES", "name18"
     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   */
     47const 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"
    4153};
    4254
    4355void
    44 remotedeb_2(struct svc_req *rqstp, register SVCXPRT *transp)
     56remotedeb_2 (struct svc_req *rqstp, register SVCXPRT * transp)
    4557{
    46         union {
    47                 open_in open_connex_2_arg;
    48                 signal_in send_signal_2_arg;
    49                 close_in close_connex_2_arg;
    50                 ptrace_in ptrace_2_arg;
    51                 wait_in wait_info_2_arg;
    52         } argument;
    53         char *result;
    54         xdrproc_t _xdr_argument, _xdr_result;
    55         char *(*local)(char *, struct svc_req *);
     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 *);
    5668
    57         DPRINTF (("remotedeb_2: %s (%d)\n",
    58                 (unsigned) rqstp->rq_proc <
    59                 (unsigned) (sizeof names / sizeof names[0]) ?
    60                 names [rqstp->rq_proc] : "???",
    61                 (int) rqstp->rq_proc));
     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));
    6273
    63         switch (rqstp->rq_proc) {
    64         case NULLPROC:
    65                 (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
    66                 return;
     74  switch (rqstp->rq_proc) {
     75  case NULLPROC:
     76    (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *) NULL);
     77    return;
    6778
    68         case OPEN_CONNEX:
    69                 _xdr_argument = (xdrproc_t) xdr_open_in;
    70                 _xdr_result = (xdrproc_t) xdr_open_out;
    71                 local = (char *(*)(char *, struct svc_req *)) open_connex_2_svc;
    72                 break;
     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;
    7384
    74         case SEND_SIGNAL:
    75                 _xdr_argument = (xdrproc_t) xdr_signal_in;
    76                 _xdr_result = (xdrproc_t) xdr_signal_out;
    77                 local = (char *(*)(char *, struct svc_req *)) send_signal_2_svc;
    78                 break;
     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;
    7990
    80         case CLOSE_CONNEX:
    81                 _xdr_argument = (xdrproc_t) xdr_close_in;
    82                 _xdr_result = (xdrproc_t) xdr_void;
    83                 local = (char *(*)(char *, struct svc_req *)) close_connex_2_svc;
    84                 break;
     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;
    8596
    86         case PTRACE:
    87                 _xdr_argument = (xdrproc_t) xdr_ptrace_in;
    88                 _xdr_result = (xdrproc_t) xdr_ptrace_out;
    89                 local = (char *(*)(char *, struct svc_req *)) ptrace_2_svc;
    90                 break;
     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;
    91102
    92         case WAIT_INFO:
    93                 _xdr_argument = (xdrproc_t) xdr_wait_in;
    94                 _xdr_result = (xdrproc_t) xdr_wait_out;
    95                 local = (char *(*)(char *, struct svc_req *)) wait_info_2_svc;
    96                 break;
     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;
    97108
    98         case GET_SIGNAL_NAMES:
    99                 _xdr_argument = (xdrproc_t) xdr_void;
    100                 _xdr_result = (xdrproc_t) xdr_get_signal_names_out;
    101                 local = (char *(*)(char *, struct svc_req *)) get_signal_names_2_svc;
    102                 break;
     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;
    103114
    104         default:
    105                 svcerr_noproc (transp);
    106                 return;
    107         }
    108         memset ((char *)&argument, 0, sizeof (argument));
    109         if (!svc_getargs (transp, _xdr_argument, (caddr_t) &argument)) {
    110                 svcerr_decode (transp);
    111                 return;
    112         }
    113         result = (*local)((char *)&argument, rqstp);
    114         if (result != NULL && !svc_sendreply(transp, _xdr_result, result)) {
    115                 svcerr_systemerr (transp);
    116         }
    117         if (!svc_freeargs (transp, _xdr_argument, (caddr_t) &argument)) {
    118                 fprintf (stderr, "unable to free arguments");
    119                 exit (1);
    120         }
    121         return;
     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;
    122133}
  • c/src/librdbg/src/i386/any/remdeb_xdr.c

    r8e3caa5 r40cf43ea  
    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 }
     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}
     37
    3738/*
    3839 * Sun request values for the remote ptrace system call
    3940 */
    4041
    41 
    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;
    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 }
     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; 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
    10099  /*
    101100   * Memory data for read/write text or data. The size is in data. The target
     
    105104   * become too small if this value gets incremented.
    106105   */
    107 bool_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 
    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;
    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 
    245 bool_t
    246 xdr_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 
    255 bool_t
    256 xdr_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 }
    264 bool_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 
    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 (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 
    322 bool_t
    323 xdr_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 
    380 bool_t
    381 xdr_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 }
     106bool_t
     107xdr_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; 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
     243bool_t
     244xdr_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
     253bool_t
     254xdr_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
     263bool_t
     264xdr_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
     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
     326bool_t
     327xdr_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
     388bool_t
     389xdr_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
    389400#ifndef XRY_MAX_CMD_STR
    390 #endif  /* REMDEB_H */
    391 
    392 bool_t
    393 xdr_xry_inst (XDR *xdrs, xry_inst *objp)
    394 {
    395         register int32_t *buf;
    396 
    397          if (!xdr_u_char (xdrs, &objp->flags))
    398                  return FALSE;
    399          if (!xdr_u_char (xdrs, &objp->type))
    400                  return FALSE;
    401          if (!xdr_u_char (xdrs, &objp->sub_type))
    402                  return FALSE;
    403          if (!xdr_u_char (xdrs, &objp->res_type))
    404                  return FALSE;
    405          if (!xdr_u_long (xdrs, &objp->value))
    406                  return FALSE;
    407          if (!xdr_u_long (xdrs, &objp->value2))
    408                  return FALSE;
    409         return TRUE;
    410 }
    411 
    412 bool_t
    413 xdr_instance (XDR *xdrs, instance *objp)
    414 {
    415         register int32_t *buf;
    416 
    417         int i;
    418          if (!xdr_vector (xdrs, (char *)objp->instances, XRY_MAX_INSTANCES,
    419                 sizeof (xry_inst), (xdrproc_t) xdr_xry_inst))
    420                  return FALSE;
    421          if (!xdr_vector (xdrs, (char *)objp->buffer, XRY_MAX_INST_BUFF,
    422                 sizeof (u_char), (xdrproc_t) xdr_u_char))
    423                  return FALSE;
    424         return TRUE;
    425 }
    426 
    427 bool_t
    428 xdr_instance_union (XDR *xdrs, instance_union *objp)
    429 {
    430         register int32_t *buf;
    431 
    432          if (!xdr_bool (xdrs, &objp->instances))
    433                  return FALSE;
    434         switch (objp->instances) {
    435         case TRUE:
    436                  if (!xdr_instance (xdrs, &objp->instance_union_u.inst))
    437                          return FALSE;
    438                 break;
    439         case FALSE:
    440                  if (!xdr_string (xdrs, &objp->instance_union_u.buffer, XRY_MAX_CMD_STR))
    441                          return FALSE;
    442                 break;
    443         default:
    444                 return FALSE;
    445         }
    446         return TRUE;
    447 }
    448 
    449 bool_t
    450 xdr_one_arg (XDR *xdrs, one_arg *objp)
    451 {
    452         register int32_t *buf;
    453 
    454          if (!xdr_string (xdrs, objp, NET_SAFE))
    455                  return FALSE;
    456         return TRUE;
    457 }
    458   /* now open_connex() routine which establishes a connection to server */
    459 
    460 bool_t
    461 xdr_debug_type (XDR *xdrs, debug_type *objp)
    462 {
    463         register int32_t *buf;
    464 
    465          if (!xdr_enum (xdrs, (enum_t *) objp))
    466                  return FALSE;
    467         return TRUE;
    468 }
    469 #define DEBUGGER_IS_GDB 0x2    /* */
    470 
    471 bool_t
    472 xdr_open_in (XDR *xdrs, open_in *objp)
    473 {
    474         register int32_t *buf;
    475 
    476         int i;
    477          if (!xdr_vector (xdrs, (char *)objp->back_port, 16,
    478                 sizeof (u_char), (xdrproc_t) xdr_u_char))
    479                  return FALSE;
    480          if (!xdr_u_short (xdrs, &objp->debug_type))
    481                  return FALSE;
    482          if (!xdr_u_short (xdrs, &objp->flags))
    483                  return FALSE;
    484          if (!xdr_vector (xdrs, (char *)objp->destination, 16,
    485                 sizeof (u_char), (xdrproc_t) xdr_u_char))
    486                  return FALSE;
    487          if (!xdr_one_arg (xdrs, &objp->user_name))
    488                  return FALSE;
    489         return TRUE;
    490 }
    491 
    492 bool_t
    493 xdr_open_out (XDR *xdrs, open_out *objp)
    494 {
    495         register int32_t *buf;
    496 
    497         int i;
    498 
    499         if (xdrs->x_op == XDR_ENCODE) {
    500                 buf = XDR_INLINE(xdrs, (2 + ( 4 )) * BYTES_PER_XDR_UNIT);
    501                 if (buf == NULL) {
    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 
    510                 } else {
    511                 IXDR_PUT_U_LONG(buf, objp->port);
    512                 {
    513                         register u_int *genp;
    514 
    515                         for (i = 0, genp = objp->pad;
    516                                 i < 4; ++i) {
    517                                 IXDR_PUT_U_LONG(buf, *genp++);
    518                         }
    519                 }
    520                 IXDR_PUT_U_LONG(buf, objp->fp);
    521                 }
    522                  if (!xdr_u_char (xdrs, &objp->cmd_table_num))
    523                          return FALSE;
    524                  if (!xdr_u_char (xdrs, &objp->cmd_table_vers))
    525                          return FALSE;
    526                  if (!xdr_u_short (xdrs, &objp->server_vers))
    527                          return FALSE;
    528                 return TRUE;
    529         } else if (xdrs->x_op == XDR_DECODE) {
    530                 buf = XDR_INLINE(xdrs, (2 + ( 4 )) * BYTES_PER_XDR_UNIT);
    531                 if (buf == NULL) {
    532                          if (!xdr_u_long (xdrs, &objp->port))
    533                                  return FALSE;
    534                          if (!xdr_vector (xdrs, (char *)objp->pad, 4,
    535                                 sizeof (u_int), (xdrproc_t) xdr_u_int))
    536                                  return FALSE;
    537                          if (!xdr_u_int (xdrs, &objp->fp))
    538                                  return FALSE;
    539 
    540                 } else {
    541                 objp->port = IXDR_GET_U_LONG(buf);
    542                 {
    543                         register u_int *genp;
    544 
    545                         for (i = 0, genp = objp->pad;
    546                                 i < 4; ++i) {
    547                                 *genp++ = IXDR_GET_U_LONG(buf);
    548                         }
    549                 }
    550                 objp->fp = IXDR_GET_U_LONG(buf);
    551                 }
    552                  if (!xdr_u_char (xdrs, &objp->cmd_table_num))
    553                          return FALSE;
    554                  if (!xdr_u_char (xdrs, &objp->cmd_table_vers))
    555                          return FALSE;
    556                  if (!xdr_u_short (xdrs, &objp->server_vers))
    557                          return FALSE;
    558          return TRUE;
    559         }
    560 
    561          if (!xdr_u_long (xdrs, &objp->port))
    562                  return FALSE;
    563          if (!xdr_vector (xdrs, (char *)objp->pad, 4,
    564                 sizeof (u_int), (xdrproc_t) xdr_u_int))
    565                  return FALSE;
    566          if (!xdr_u_int (xdrs, &objp->fp))
    567                  return FALSE;
    568          if (!xdr_u_char (xdrs, &objp->cmd_table_num))
    569                  return FALSE;
    570          if (!xdr_u_char (xdrs, &objp->cmd_table_vers))
    571                  return FALSE;
    572          if (!xdr_u_short (xdrs, &objp->server_vers))
    573                  return FALSE;
    574         return TRUE;
    575 }
    576   /* now close_connex() routine which detaches from server */
    577 
    578 bool_t
    579 xdr_close_control (XDR *xdrs, close_control *objp)
    580 {
    581         register int32_t *buf;
    582 
    583          if (!xdr_enum (xdrs, (enum_t *) objp))
    584                  return FALSE;
    585         return TRUE;
    586 }
    587 
    588 bool_t
    589 xdr_close_in (XDR *xdrs, close_in *objp)
    590 {
    591         register int32_t *buf;
    592 
    593          if (!xdr_close_control (xdrs, &objp->control))
    594                  return FALSE;
    595         return TRUE;
    596 }
    597   /* now send_signal() routine which sends signals to processes like kill(2) */
    598 
    599 bool_t
    600 xdr_signal_in (XDR *xdrs, signal_in *objp)
    601 {
    602         register int32_t *buf;
    603 
    604          if (!xdr_int (xdrs, &objp->pid))
    605                  return FALSE;
    606          if (!xdr_int (xdrs, &objp->sig))
    607                  return FALSE;
    608         return TRUE;
    609 }
    610 
    611 bool_t
    612 xdr_signal_out (XDR *xdrs, signal_out *objp)
    613 {
    614         register int32_t *buf;
    615 
    616          if (!xdr_int (xdrs, &objp->kill_return))
    617                  return FALSE;
    618          if (!xdr_int (xdrs, &objp->errNo))
    619                  return FALSE;
    620         return TRUE;
    621 }
    622   /* now wait_info() routine which returns results of polling the wait status
    623         of a process/actor. It may return 0 if running, else pid or -1 */
    624 
    625 bool_t
    626 xdr_stop_code (XDR *xdrs, stop_code *objp)
    627 {
    628         register int32_t *buf;
    629 
    630          if (!xdr_enum (xdrs, (enum_t *) objp))
    631                  return FALSE;
    632         return TRUE;
    633 }
    634 
    635 bool_t
    636 xdr_wait_in (XDR *xdrs, wait_in *objp)
    637 {
    638         register int32_t *buf;
    639 
    640          if (!xdr_int (xdrs, &objp->pid))
    641                  return FALSE;
    642         return TRUE;
    643 }
    644 
    645 bool_t
    646 xdr_wait_out (XDR *xdrs, wait_out *objp)
    647 {
    648         register int32_t *buf;
    649 
    650 
    651         if (xdrs->x_op == XDR_ENCODE) {
    652                 buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
    653                 if (buf == NULL) {
    654                          if (!xdr_int (xdrs, &objp->wait_return))
    655                                  return FALSE;
    656                          if (!xdr_int (xdrs, &objp->errNo))
    657                                  return FALSE;
    658                          if (!xdr_int (xdrs, &objp->status))
    659                                  return FALSE;
    660 
    661                 } else {
    662                 IXDR_PUT_LONG(buf, objp->wait_return);
    663                 IXDR_PUT_LONG(buf, objp->errNo);
    664                 IXDR_PUT_LONG(buf, objp->status);
    665                 }
    666                  if (!xdr_stop_code (xdrs, &objp->reason))
    667                          return FALSE;
    668                 buf = XDR_INLINE(xdrs,5 * BYTES_PER_XDR_UNIT);
    669                 if (buf == NULL) {
    670                          if (!xdr_int (xdrs, &objp->handle))
    671                                  return FALSE;
    672                          if (!xdr_u_long (xdrs, &objp->PC))
    673                                  return FALSE;
    674                          if (!xdr_u_long (xdrs, &objp->SP))
    675                                  return FALSE;
    676                          if (!xdr_u_long (xdrs, &objp->FP))
    677                                  return FALSE;
    678                          if (!xdr_u_long (xdrs, &objp->thread))
    679                                  return FALSE;
    680                 } else {
    681                         IXDR_PUT_LONG(buf, objp->handle);
    682                         IXDR_PUT_U_LONG(buf, objp->PC);
    683                         IXDR_PUT_U_LONG(buf, objp->SP);
    684                         IXDR_PUT_U_LONG(buf, objp->FP);
    685                         IXDR_PUT_U_LONG(buf, objp->thread);
    686                 }
    687                 return TRUE;
    688         } else if (xdrs->x_op == XDR_DECODE) {
    689                 buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
    690                 if (buf == NULL) {
    691                          if (!xdr_int (xdrs, &objp->wait_return))
    692                                  return FALSE;
    693                          if (!xdr_int (xdrs, &objp->errNo))
    694                                  return FALSE;
    695                          if (!xdr_int (xdrs, &objp->status))
    696                                  return FALSE;
    697 
    698                 } else {
    699                 objp->wait_return = IXDR_GET_LONG(buf);
    700                 objp->errNo = IXDR_GET_LONG(buf);
    701                 objp->status = IXDR_GET_LONG(buf);
    702                 }
    703                  if (!xdr_stop_code (xdrs, &objp->reason))
    704                          return FALSE;
    705                 buf = XDR_INLINE(xdrs,5 * BYTES_PER_XDR_UNIT);
    706                 if (buf == NULL) {
    707                          if (!xdr_int (xdrs, &objp->handle))
    708                                  return FALSE;
    709                          if (!xdr_u_long (xdrs, &objp->PC))
    710                                  return FALSE;
    711                          if (!xdr_u_long (xdrs, &objp->SP))
    712                                  return FALSE;
    713                          if (!xdr_u_long (xdrs, &objp->FP))
    714                                  return FALSE;
    715                          if (!xdr_u_long (xdrs, &objp->thread))
    716                                  return FALSE;
    717                 } else {
    718                         objp->handle = IXDR_GET_LONG(buf);
    719                         objp->PC = IXDR_GET_U_LONG(buf);
    720                         objp->SP = IXDR_GET_U_LONG(buf);
    721                         objp->FP = IXDR_GET_U_LONG(buf);
    722                         objp->thread = IXDR_GET_U_LONG(buf);
    723                 }
    724          return TRUE;
    725         }
    726 
    727          if (!xdr_int (xdrs, &objp->wait_return))
    728                  return FALSE;
    729          if (!xdr_int (xdrs, &objp->errNo))
    730                  return FALSE;
    731          if (!xdr_int (xdrs, &objp->status))
    732                  return FALSE;
    733          if (!xdr_stop_code (xdrs, &objp->reason))
    734                  return FALSE;
    735          if (!xdr_int (xdrs, &objp->handle))
    736                  return FALSE;
    737          if (!xdr_u_long (xdrs, &objp->PC))
    738                  return FALSE;
    739          if (!xdr_u_long (xdrs, &objp->SP))
    740                  return FALSE;
    741          if (!xdr_u_long (xdrs, &objp->FP))
    742                  return FALSE;
    743          if (!xdr_u_long (xdrs, &objp->thread))
    744                  return FALSE;
    745         return TRUE;
    746 }
    747   /* now ptrace() routine. This matches the Sun UNIX ptrace as well as
    748         some additions */
    749 
    750 bool_t
    751 xdr_ptrace_in (XDR *xdrs, ptrace_in *objp)
    752 {
    753         register int32_t *buf;
    754 
    755          if (!xdr_int (xdrs, &objp->pid))
    756                  return FALSE;
    757          if (!xdr_ptrace_addr_data_in (xdrs, &objp->addr))
    758                  return FALSE;
    759          if (!xdr_u_int (xdrs, &objp->data))
    760                  return FALSE;
    761          if (!xdr_u_int (xdrs, &objp->flags))
    762                  return FALSE;
    763         return TRUE;
    764 }
    765 
    766 bool_t
    767 xdr_ptrace_out (XDR *xdrs, ptrace_out *objp)
    768 {
    769         register int32_t *buf;
    770 
    771          if (!xdr_ptrace_addr_data_out (xdrs, &objp->addr))
    772                  return FALSE;
    773          if (!xdr_int (xdrs, &objp->result))
    774                  return FALSE;
    775          if (!xdr_int (xdrs, &objp->errNo))
    776                  return FALSE;
    777         return TRUE;
    778 }
    779 
    780 bool_t
    781 xdr_one_symbol (XDR *xdrs, one_symbol *objp)
    782 {
    783         register int32_t *buf;
    784 
    785          if (!xdr_string (xdrs, &objp->symbolName, ~0))
    786                  return FALSE;
    787          if (!xdr_long (xdrs, &objp->symbolValue))
    788                  return FALSE;
    789         return TRUE;
    790 }
    791 
    792 bool_t
    793 xdr_all_symbols (XDR *xdrs, all_symbols *objp)
    794 {
    795         register int32_t *buf;
    796 
    797          if (!xdr_array (xdrs, (char **)&objp->all_symbols_val, (u_int *) &objp->all_symbols_len, ~0,
    798                 sizeof (one_symbol), (xdrproc_t) xdr_one_symbol))
    799                  return FALSE;
    800         return TRUE;
    801 }
    802 
    803 bool_t
    804 xdr_get_global_symbols_out (XDR *xdrs, get_global_symbols_out *objp)
    805 {
    806         register int32_t *buf;
    807 
    808          if (!xdr_all_symbols (xdrs, &objp->symbols))
    809                  return FALSE;
    810         return TRUE;
    811 }
    812 
    813 bool_t
    814 xdr_get_text_data_in (XDR *xdrs, get_text_data_in *objp)
    815 {
    816         register int32_t *buf;
    817 
    818          if (!xdr_int (xdrs, &objp->pid))
    819                  return FALSE;
    820          if (!xdr_string (xdrs, &objp->actorName, 16))
    821                  return FALSE;
    822         return TRUE;
    823 }
    824 
    825 bool_t
    826 xdr_get_text_data_out (XDR *xdrs, get_text_data_out *objp)
    827 {
    828         register int32_t *buf;
    829 
    830 
    831         if (xdrs->x_op == XDR_ENCODE) {
    832                 buf = XDR_INLINE(xdrs,6 * BYTES_PER_XDR_UNIT);
    833                 if (buf == NULL) {
    834                          if (!xdr_int (xdrs, &objp->result))
    835                                  return FALSE;
    836                          if (!xdr_int (xdrs, &objp->errNo))
    837                                  return FALSE;
    838                          if (!xdr_u_long (xdrs, &objp->textStart))
    839                                  return FALSE;
    840                          if (!xdr_u_long (xdrs, &objp->textSize))
    841                                  return FALSE;
    842                          if (!xdr_u_long (xdrs, &objp->dataStart))
    843                                  return FALSE;
    844                          if (!xdr_u_long (xdrs, &objp->dataSize))
    845                                  return FALSE;
    846                 } else {
    847                         IXDR_PUT_LONG(buf, objp->result);
    848                         IXDR_PUT_LONG(buf, objp->errNo);
    849                         IXDR_PUT_U_LONG(buf, objp->textStart);
    850                         IXDR_PUT_U_LONG(buf, objp->textSize);
    851                         IXDR_PUT_U_LONG(buf, objp->dataStart);
    852                         IXDR_PUT_U_LONG(buf, objp->dataSize);
    853                 }
    854                 return TRUE;
    855         } else if (xdrs->x_op == XDR_DECODE) {
    856                 buf = XDR_INLINE(xdrs,6 * BYTES_PER_XDR_UNIT);
    857                 if (buf == NULL) {
    858                          if (!xdr_int (xdrs, &objp->result))
    859                                  return FALSE;
    860                          if (!xdr_int (xdrs, &objp->errNo))
    861                                  return FALSE;
    862                          if (!xdr_u_long (xdrs, &objp->textStart))
    863                                  return FALSE;
    864                          if (!xdr_u_long (xdrs, &objp->textSize))
    865                                  return FALSE;
    866                          if (!xdr_u_long (xdrs, &objp->dataStart))
    867                                  return FALSE;
    868                          if (!xdr_u_long (xdrs, &objp->dataSize))
    869                                  return FALSE;
    870                 } else {
    871                         objp->result = IXDR_GET_LONG(buf);
    872                         objp->errNo = IXDR_GET_LONG(buf);
    873                         objp->textStart = IXDR_GET_U_LONG(buf);
    874                         objp->textSize = IXDR_GET_U_LONG(buf);
    875                         objp->dataStart = IXDR_GET_U_LONG(buf);
    876                         objp->dataSize = IXDR_GET_U_LONG(buf);
    877                 }
    878          return TRUE;
    879         }
    880 
    881          if (!xdr_int (xdrs, &objp->result))
    882                  return FALSE;
    883          if (!xdr_int (xdrs, &objp->errNo))
    884                  return FALSE;
    885          if (!xdr_u_long (xdrs, &objp->textStart))
    886                  return FALSE;
    887          if (!xdr_u_long (xdrs, &objp->textSize))
    888                  return FALSE;
    889          if (!xdr_u_long (xdrs, &objp->dataStart))
    890                  return FALSE;
    891          if (!xdr_u_long (xdrs, &objp->dataSize))
    892                  return FALSE;
    893         return TRUE;
    894 }
    895 
    896 bool_t
    897 xdr_one_signal (XDR *xdrs, one_signal *objp)
    898 {
    899         register int32_t *buf;
    900 
    901          if (!xdr_u_int (xdrs, &objp->number))
    902                  return FALSE;
    903          if (!xdr_string (xdrs, &objp->name, ~0))
    904                  return FALSE;
    905         return TRUE;
    906 }
    907 
    908 bool_t
    909 xdr_all_signals (XDR *xdrs, all_signals *objp)
    910 {
    911         register int32_t *buf;
    912 
    913          if (!xdr_array (xdrs, (char **)&objp->all_signals_val, (u_int *) &objp->all_signals_len, ~0,
    914                 sizeof (one_signal), (xdrproc_t) xdr_one_signal))
    915                  return FALSE;
    916         return TRUE;
    917 }
    918 
    919 bool_t
    920 xdr_get_signal_names_out (XDR *xdrs, get_signal_names_out *objp)
    921 {
    922         register int32_t *buf;
    923 
    924          if (!xdr_all_signals (xdrs, &objp->signals))
    925                  return FALSE;
    926         return TRUE;
    927 }
    928   /* now define the actual calls we support */
     401#endif /* REMDEB_H */
     402
     403bool_t
     404xdr_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
     423bool_t
     424xdr_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
     438bool_t
     439xdr_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
     460bool_t
     461xdr_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
     474bool_t
     475xdr_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
     486bool_t
     487xdr_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
     507bool_t
     508xdr_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
     594bool_t
     595xdr_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
     604bool_t
     605xdr_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
     618bool_t
     619xdr_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
     630bool_t
     631xdr_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
     647bool_t
     648xdr_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
     657bool_t
     658xdr_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
     667bool_t
     668xdr_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
     774bool_t
     775xdr_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
     790bool_t
     791xdr_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
     804bool_t
     805xdr_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
     816bool_t
     817xdr_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
     829bool_t
     830xdr_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
     839bool_t
     840xdr_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
     851bool_t
     852xdr_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
     921bool_t
     922xdr_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
     933bool_t
     934xdr_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
     946bool_t
     947xdr_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   */
  • c/src/librdbg/src/i386/excep_f.c

    r8e3caa5 r40cf43ea  
    2323   ----------------------------------------------------------------- */
    2424
    25     int
    26 ExcepToSig (Exception_context *ctx)
     25  int
     26ExcepToSig (Exception_context * ctx)
    2727{
    28     int excep = getExcNum (ctx);
    29  
     28  int excep = getExcNum (ctx);
    3029
    31     switch (excep) {
    32      
    33     case I386_EXCEPTION_MATH_COPROC_UNAVAIL:
    34     case I386_EXCEPTION_I386_COPROC_SEG_ERR:
    35     case I386_EXCEPTION_FLOAT_ERROR:
    36     case I386_EXCEPTION_BOUND:
    37         return SIGFPE;
     30  switch (excep) {
    3831
    39     case I386_EXCEPTION_DEBUG:
    40     case I386_EXCEPTION_BREAKPOINT:
    41     case I386_EXCEPTION_ENTER_RDBG:
    42         return SIGTRAP;
     32  case I386_EXCEPTION_MATH_COPROC_UNAVAIL:
     33  case I386_EXCEPTION_I386_COPROC_SEG_ERR:
     34  case I386_EXCEPTION_FLOAT_ERROR:
     35  case I386_EXCEPTION_BOUND:
     36    return SIGFPE;
    4337
    44     case I386_EXCEPTION_OVERFLOW:
    45     case I386_EXCEPTION_DIVIDE_BY_ZERO:
    46     case I386_EXCEPTION_ILLEGAL_INSTR: 
    47         return SIGILL;
     38  case I386_EXCEPTION_DEBUG:
     39  case I386_EXCEPTION_BREAKPOINT:
     40  case I386_EXCEPTION_ENTER_RDBG:
     41    return SIGTRAP;
    4842
    49     case I386_EXCEPTION_SEGMENT_NOT_PRESENT:
    50     case I386_EXCEPTION_STACK_SEGMENT_FAULT:
    51     case I386_EXCEPTION_GENERAL_PROT_ERR:
    52     case I386_EXCEPTION_PAGE_FAULT:
    53         return SIGSEGV;
     43  case I386_EXCEPTION_OVERFLOW:
     44  case I386_EXCEPTION_DIVIDE_BY_ZERO:
     45  case I386_EXCEPTION_ILLEGAL_INSTR:
     46    return SIGILL;
    5447
    55     default:
    56         break;
    57     }
    58     return SIGKILL;
     48  case I386_EXCEPTION_SEGMENT_NOT_PRESENT:
     49  case I386_EXCEPTION_STACK_SEGMENT_FAULT:
     50  case I386_EXCEPTION_GENERAL_PROT_ERR:
     51  case I386_EXCEPTION_PAGE_FAULT:
     52    return SIGSEGV;
     53
     54  default:
     55    break;
     56  }
     57  return SIGKILL;
    5958}
    6059
    61  
    6260/*----- Breakpoint Exception management -----*/
    6361
     
    6765     */
    6866
    69 void
    70 BreakPointExcHdl(CPU_Exception_frame *ctx)
     67  void
     68BreakPointExcHdl (CPU_Exception_frame * ctx)
    7169{
    7270  rtems_status_code status;
    7371  rtems_id continueSemId;
    7472
    75   if ( (justSaveContext) && (ctx->idtIndex == I386_EXCEPTION_ENTER_RDBG) ) {
     73  if ((justSaveContext) && (ctx->idtIndex == I386_EXCEPTION_ENTER_RDBG)) {
    7674    PushSavedExceptCtx (_Thread_Executing->Object.id, ctx);
    7775    justSaveContext = 0;
    78   }
    79   else {
    80     if (ctx->idtIndex != I386_EXCEPTION_DEBUG){
     76  } else {
     77    if (ctx->idtIndex != I386_EXCEPTION_DEBUG) {
    8178      NbSerializedCtx++;
    82       rtems_semaphore_obtain(serializeSemId, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     79      rtems_semaphore_obtain (serializeSemId, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    8380      NbSerializedCtx--;
    8481    }
    85      
     82
    8683    currentTargetThread = _Thread_Executing->Object.id;
    8784
    8885#ifdef DDEBUG
    89     printk("----------------------------------------------------------\n");
    90     printk("Exception %d caught at PC %x by thread %d\n",
    91            ctx->idtIndex,
    92            ctx->eip,
    93            _Thread_Executing->Object.id);
    94     printk("----------------------------------------------------------\n");
    95     printk("Processor execution context at time of the fault was  :\n");
    96     printk("----------------------------------------------------------\n");
    97     printk(" EAX = %x   EBX = %x        ECX = %x        EDX = %x\n",
    98            ctx->eax, ctx->ebx, ctx->ecx, ctx->edx);
    99     printk(" ESI = %x   EDI = %x        EBP = %x        ESP = %x\n",
    100            ctx->esi, ctx->edi, ctx->ebp, ctx->esp0);
    101     printk("----------------------------------------------------------\n");
    102     printk("Error code pushed by processor itself (if not 0) = %x\n",
    103            ctx->faultCode);
    104     printk("----------------------------------------------------------\n\n");
     86    printk ("----------------------------------------------------------\n");
     87    printk ("Exception %d caught at PC %x by thread %d\n",
     88            ctx->idtIndex, ctx->eip, _Thread_Executing->Object.id);
     89    printk ("----------------------------------------------------------\n");
     90    printk ("Processor execution context at time of the fault was  :\n");
     91    printk ("----------------------------------------------------------\n");
     92    printk (" EAX = %x  EBX = %x        ECX = %x        EDX = %x\n",
     93            ctx->eax, ctx->ebx, ctx->ecx, ctx->edx);
     94    printk (" ESI = %x  EDI = %x        EBP = %x        ESP = %x\n",
     95            ctx->esi, ctx->edi, ctx->ebp, ctx->esp0);
     96    printk ("----------------------------------------------------------\n");
     97    printk ("Error code pushed by processor itself (if not 0) = %x\n",
     98            ctx->faultCode);
     99    printk ("----------------------------------------------------------\n\n");
    105100#endif
    106101
    107     status = rtems_semaphore_create (rtems_build_name('D', 'B', 'G', 'c'),
    108                                      0,
    109                                      RTEMS_FIFO |
    110                                      RTEMS_COUNTING_SEMAPHORE |
    111                                      RTEMS_NO_INHERIT_PRIORITY |
    112                                      RTEMS_NO_PRIORITY_CEILING |
    113                                      RTEMS_LOCAL,
    114                                      0,
    115                                      &continueSemId);
     102    status = rtems_semaphore_create (rtems_build_name ('D', 'B', 'G', 'c'),
     103                                     0,
     104                                     RTEMS_FIFO |
     105                                     RTEMS_COUNTING_SEMAPHORE |
     106                                     RTEMS_NO_INHERIT_PRIORITY |
     107                                     RTEMS_NO_PRIORITY_CEILING |
     108                                     RTEMS_LOCAL, 0, &continueSemId);
    116109    if (status != RTEMS_SUCCESSFUL)
    117       rtems_panic ("Can't create continue semaphore: `%s'\n",rtems_status_text(status));
     110      rtems_panic ("Can't create continue semaphore: `%s'\n",
     111                   rtems_status_text (status));
    118112
    119113    PushExceptCtx (_Thread_Executing->Object.id, continueSemId, ctx);
    120  
    121     switch (ctx->idtIndex){
     114
     115    switch (ctx->idtIndex) {
    122116    case I386_EXCEPTION_DEBUG:
    123       DPRINTF((" DEBUG EXCEPTION !!!\n"));
     117      DPRINTF ((" DEBUG EXCEPTION !!!\n"));
    124118      ctx->eflags &= ~EFLAGS_TF;
    125       ExitForSingleStep-- ;
    126       rtems_semaphore_release( wakeupEventSemId );
    127     break;
     119      ExitForSingleStep--;
     120      rtems_semaphore_release (wakeupEventSemId);
     121      break;
    128122
    129123    case I386_EXCEPTION_BREAKPOINT:
    130       DPRINTF((" BREAKPOINT EXCEPTION !!!\n"));
    131       rtems_semaphore_release( wakeupEventSemId );
    132     break;
     124      DPRINTF ((" BREAKPOINT EXCEPTION !!!\n"));
     125      rtems_semaphore_release (wakeupEventSemId);
     126      break;
    133127
    134128    case I386_EXCEPTION_ENTER_RDBG:
    135       DPRINTF((" ENTER RDBG !!!\n"));
    136       rtems_semaphore_release( wakeupEventSemId );
     129      DPRINTF ((" ENTER RDBG !!!\n"));
     130      rtems_semaphore_release (wakeupEventSemId);
    137131      break;
    138132
    139133    default:
    140       DPRINTF((" OTHER EXCEPTION !!!\n"));
    141       rtems_semaphore_release( wakeupEventSemId );
     134      DPRINTF ((" OTHER EXCEPTION !!!\n"));
     135      rtems_semaphore_release (wakeupEventSemId);
    142136      break;
    143137    }
    144138
    145     rtems_semaphore_obtain(continueSemId, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    146    
     139    rtems_semaphore_obtain (continueSemId, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     140
    147141    PopExceptCtx (_Thread_Executing->Object.id);
    148     rtems_semaphore_delete(continueSemId);
     142    rtems_semaphore_delete (continueSemId);
    149143  }
    150144}
    151 
    152 
    153 
  • c/src/librdbg/src/i386/rdbg_f.c

    r8e3caa5 r40cf43ea  
    1313#include <assert.h>
    1414#include <errno.h>
    15 #include <rdbg/reg.h>               
     15#include <rdbg/reg.h>
    1616#include <rdbg/remdeb.h>
    1717#include <rdbg/rdbg.h>
    18 #include <rtems/score/cpu.h>   
    19 #include <rtems/score/thread.h> 
     18#include <rtems/score/cpu.h>
     19#include <rtems/score/thread.h>
    2020
    21 
    22 void
    23 CtxToRegs (const CPU_Exception_frame* ctx, xdr_regs* regs)
     21  void
     22CtxToRegs (const CPU_Exception_frame * ctx, xdr_regs * regs)
    2423{
    25     regs->tabreg [GS]           = 0;
    26     regs->tabreg [FS]           = 0;
    27     regs->tabreg [ES]           = 0;
    28     regs->tabreg [DS]           = 0;
    29     regs->tabreg [EDI]          = ctx->edi;
    30     regs->tabreg [ESI]          = ctx->esi;
    31     regs->tabreg [EBP]          = ctx->ebp;
    32     regs->tabreg [ESP]          = ctx->esp0;
    33     regs->tabreg [EBX]          = ctx->ebx;
    34     regs->tabreg [EDX]          = ctx->edx;
    35     regs->tabreg [ECX]          = ctx->ecx;
    36     regs->tabreg [EAX]          = ctx->eax;
    37     regs->tabreg [TRAPNO]       = ctx->idtIndex;
    38     regs->tabreg [ERR]          = ctx->faultCode;
    39     regs->tabreg [EIP]          = ctx->eip;
    40     regs->tabreg [CS]           = ctx->cs & 0xFFFF;
    41     regs->tabreg [EFL]          = ctx->eflags;
     24  regs->tabreg[GS] = 0;
     25  regs->tabreg[FS] = 0;
     26  regs->tabreg[ES] = 0;
     27  regs->tabreg[DS] = 0;
     28  regs->tabreg[EDI] = ctx->edi;
     29  regs->tabreg[ESI] = ctx->esi;
     30  regs->tabreg[EBP] = ctx->ebp;
     31  regs->tabreg[ESP] = ctx->esp0;
     32  regs->tabreg[EBX] = ctx->ebx;
     33  regs->tabreg[EDX] = ctx->edx;
     34  regs->tabreg[ECX] = ctx->ecx;
     35  regs->tabreg[EAX] = ctx->eax;
     36  regs->tabreg[TRAPNO] = ctx->idtIndex;
     37  regs->tabreg[ERR] = ctx->faultCode;
     38  regs->tabreg[EIP] = ctx->eip;
     39  regs->tabreg[CS] = ctx->cs & 0xFFFF;
     40  regs->tabreg[EFL] = ctx->eflags;
    4241}
    4342
    44 
    45     void
    46 RegsToCtx (const xdr_regs* regs, CPU_Exception_frame* ctx)
     43  void
     44RegsToCtx (const xdr_regs * regs, CPU_Exception_frame * ctx)
    4745{
    48     ctx->edi            = regs->tabreg [EDI];
    49     ctx->esi            = regs->tabreg [ESI];
    50     ctx->ebp            = regs->tabreg [EBP];
    51     ctx->esp0           = regs->tabreg [ESP];
    52     ctx->ebx            = regs->tabreg [EBX];
    53     ctx->edx            = regs->tabreg [EDX];
    54     ctx->ecx            = regs->tabreg [ECX];
    55     ctx->eax            = regs->tabreg [EAX];
    56     ctx->idtIndex       = regs->tabreg [TRAPNO];
    57     ctx->faultCode      = regs->tabreg [ERR];
    58     ctx->eip            = regs->tabreg [EIP];
    59     ctx->cs             = regs->tabreg [CS];
    60     ctx->eflags         = regs->tabreg [EFL];
     46  ctx->edi = regs->tabreg[EDI];
     47  ctx->esi = regs->tabreg[ESI];
     48  ctx->ebp = regs->tabreg[EBP];
     49  ctx->esp0 = regs->tabreg[ESP];
     50  ctx->ebx = regs->tabreg[EBX];
     51  ctx->edx = regs->tabreg[EDX];
     52  ctx->ecx = regs->tabreg[ECX];
     53  ctx->eax = regs->tabreg[EAX];
     54  ctx->idtIndex = regs->tabreg[TRAPNO];
     55  ctx->faultCode = regs->tabreg[ERR];
     56  ctx->eip = regs->tabreg[EIP];
     57  ctx->cs = regs->tabreg[CS];
     58  ctx->eflags = regs->tabreg[EFL];
    6159}
    6260
    63 void
    64 get_ctx_thread( Thread_Control *thread, CPU_Exception_frame* ctx)
     61  void
     62get_ctx_thread (Thread_Control * thread, CPU_Exception_frame * ctx)
    6563{
    66     ctx->edi            = thread->Registers.edi;
    67     ctx->esi            = thread->Registers.esi;
    68     ctx->ebp            = (unsigned32)(thread->Registers.ebp);
    69     ctx->esp0           = (unsigned32)(thread->Registers.esp);
    70     ctx->ebx            = thread->Registers.ebx;
    71     ctx->edx            = 0;
    72     ctx->ecx            = 0;
    73     ctx->eax            = 0;
    74     ctx->idtIndex       = 0;
    75     ctx->faultCode      = 0;
    76     ctx->eip            = *(unsigned int*)(thread->Registers.esp);
    77     ctx->cs             = 0;
    78     ctx->eflags         = thread->Registers.eflags;
     64  ctx->edi = thread->Registers.edi;
     65  ctx->esi = thread->Registers.esi;
     66  ctx->ebp = (unsigned32) (thread->Registers.ebp);
     67  ctx->esp0 = (unsigned32) (thread->Registers.esp);
     68  ctx->ebx = thread->Registers.ebx;
     69  ctx->edx = 0;
     70  ctx->ecx = 0;
     71  ctx->eax = 0;
     72  ctx->idtIndex = 0;
     73  ctx->faultCode = 0;
     74  ctx->eip = *(unsigned int *) (thread->Registers.esp);
     75  ctx->cs = 0;
     76  ctx->eflags = thread->Registers.eflags;
    7977}
    8078
    81 void
    82 set_ctx_thread( Thread_Control *thread, CPU_Exception_frame* ctx)
     79  void
     80set_ctx_thread (Thread_Control * thread, CPU_Exception_frame * ctx)
    8381{
    8482  thread->Registers.edi = ctx->edi;
    85   thread->Registers.esi = ctx->esi;             
    86   thread->Registers.ebp = (void*)(ctx->ebp);           
    87   thread->Registers.esp = (void*)(ctx->esp0);           
    88   thread->Registers.ebx = ctx->ebx;             
    89   thread->Registers.eflags = ctx->eflags;               
     83  thread->Registers.esi = ctx->esi;
     84  thread->Registers.ebp = (void *) (ctx->ebp);
     85  thread->Registers.esp = (void *) (ctx->esp0);
     86  thread->Registers.ebx = ctx->ebx;
     87  thread->Registers.eflags = ctx->eflags;
    9088}
    9189
    92  
    93 
    94 int
    95 Single_Step(CPU_Exception_frame* ctx)
     90  int
     91Single_Step (CPU_Exception_frame * ctx)
    9692{
    97   /* Check if not already set */
    98   if ((ctx->eflags & EFLAGS_TF) != 0  ||  ExitForSingleStep != 0) {
    99     /* Check coherency */
     93  /*
     94   * Check if not already set
     95   */
     96  if ((ctx->eflags & EFLAGS_TF) != 0 || ExitForSingleStep != 0) {
     97    /*
     98     * Check coherency
     99     */
    100100    assert ((ctx->eflags & EFLAGS_TF) != 0);
    101101    assert (ExitForSingleStep != 0);
    102102    return 0;
    103103  }
    104   ctx->eflags |= EFLAGS_TF;     /* eflags */
     104  ctx->eflags |= EFLAGS_TF;     /* eflags */
    105105  ++ExitForSingleStep;
    106  
     106
    107107  return 0;
    108108}
    109109
    110  int
    111 CheckForSingleStep (CPU_Exception_frame* ctx)
     110  int
     111CheckForSingleStep (CPU_Exception_frame * ctx)
    112112{
    113     if (ExitForSingleStep) {
    114             /*
    115              *  This functions can be called both from
    116              *  INT1 and INT3 handlers. In case it is
    117              *  called from INT3, need to clear TF.
    118              */
    119         ctx->eflags &= ~EFLAGS_TF;
    120         ExitForSingleStep = 0;
    121         return 1;
    122     }
    123     return 0;
     113  if (ExitForSingleStep) {
     114    /*
     115     *  This functions can be called both from
     116     *  INT1 and INT3 handlers. In case it is
     117     *  called from INT3, need to clear TF.
     118     */
     119    ctx->eflags &= ~EFLAGS_TF;
     120    ExitForSingleStep = 0;
     121    return 1;
     122  }
     123  return 0;
    124124}
    125125
    126 void
    127 CancelSingleStep (CPU_Exception_frame* ctx)
     126  void
     127CancelSingleStep (CPU_Exception_frame * ctx)
    128128{
    129         /* Cancel scheduled SS */
    130     ctx->eflags &= ~EFLAGS_TF;
    131     ExitForSingleStep-- ;
     129  /*
     130   * Cancel scheduled SS
     131   */
     132  ctx->eflags &= ~EFLAGS_TF;
     133  ExitForSingleStep--;
    132134}
    133135
    134 cpuExcHandlerType old_currentExcHandler;
    135 extern void  rtems_exception_prologue_50();
     136static cpuExcHandlerType old_currentExcHandler;
     137extern void rtems_exception_prologue_50 ();
    136138
    137 void connect_rdbg_exception()
     139  void
     140connect_rdbg_exception ()
    138141{
    139   interrupt_gate_descriptor      *currentIdtEntry;
    140   unsigned                      limit;
    141   unsigned                      level;
     142  interrupt_gate_descriptor *currentIdtEntry;
     143  unsigned limit;
     144  unsigned level;
    142145
    143146  /*
     
    145148   */
    146149  i386_get_info_from_IDTR (&currentIdtEntry, &limit);
    147  
    148   _CPU_ISR_Disable(level);
    149   create_interrupt_gate_descriptor (&currentIdtEntry[50], rtems_exception_prologue_50);
    150   _CPU_ISR_Enable(level);
    151150
    152   old_currentExcHandler = _currentExcHandler;
    153   _currentExcHandler = BreakPointExcHdl ;
     151  _CPU_ISR_Disable (level);
     152  create_interrupt_gate_descriptor (&currentIdtEntry[50],
     153                                    rtems_exception_prologue_50);
     154  _CPU_ISR_Enable (level);
    154155
     156  if (_currentExcHandler != BreakPointExcHdl) {
     157    old_currentExcHandler = _currentExcHandler;
     158    _currentExcHandler = BreakPointExcHdl;
     159  }
    155160}
     161
     162  void
     163disconnect_rdbg_exception ()
     164{
     165  if (_currentExcHandler == BreakPointExcHdl) {
     166    _currentExcHandler = old_currentExcHandler;
     167  }
     168}
  • c/src/librdbg/src/m68k/any/Makefile.am

    r8e3caa5 r40cf43ea  
    7272        $(AWK) -f ./awk.svc THEPROG="remdeb.h" m68k/any/tmpSvc.c \
    7373          > m68k/any/remdeb_svc.c; \
     74        $(SED) -e 's/fprintf.*,/printf(/'  m68k/any/remdeb_svc.c > m68k/any/remdeb_svc.tmp; \
     75        mv m68k/any/remdeb_svc.tmp m68k/any/remdeb_svc.c; \
    7476        rm -f m68k/any/tmpSvc.c )
    7577endif
  • c/src/librdbg/src/m68k/any/remdeb.h

    r8e3caa5 r40cf43ea  
    99#include <rpc/rpc.h>
    1010
    11 
    1211#ifdef __cplusplus
    1312extern "C" {
     
    1918#define RPCGENSRVNAME(a)     a
    2019
    21 enum rpc_type {
    22         SUNRPC = 0,
    23         BADRPCTYPE = 25,
    24 };
    25 typedef enum rpc_type rpc_type;
     20  enum rpc_type {
     21    SUNRPC = 0,
     22    BADRPCTYPE = 25,
     23  };
     24  typedef enum rpc_type rpc_type;
    2625#define NET_SAFE 1400
    2726
    28 struct UDP_MSG {
    29         u_char type;
    30         u_char msg_num;
    31         u_short spec;
    32         long pid;
    33         u_long context;
    34 };
    35 typedef struct UDP_MSG UDP_MSG;
     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;
    3635/*
    3736 * Sun request values for the remote ptrace system call
    3837 */
    3938
    40 
    41 enum 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 };
    94 typedef enum ptracereq ptracereq;
    95 
    96 struct 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 };
    103 typedef struct xdr_regs xdr_regs;
     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;
    104102/* now define register macros to apply to xdr_reg struct */
    105103
    106 #define r_r0   r_dreg[0]       /* r0 for portability */
    107 #define r_sp   r_areg[7]       /* user stack pointer */
     104#define r_r0   r_dreg[0]        /* r0 for portability */
     105#define r_sp   r_areg[7]        /* user stack pointer */
    108106#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 */
     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 */
    112110/* now define the BREAKPOINT mask technique to a long word */
    113 #define SET_BREAK(l)   ((l&0x0000FFFF) | 0x4E4F0000)  /* TRAP 15 */
     111#define SET_BREAK(l)   ((l&0x0000FFFF) | 0x4E4F0000)    /* TRAP 15 */
    114112#define IS_BREAK(l)    (((l) & 0xFFFF0000) == 0x4E4F0000)
    115113#define ORG_BREAK(c,p) (((c) & 0x0000FFFF) | ((p) & 0xFFFF0000))
     
    129127#define MEM_DATA_MAX 256
    130128
    131 struct xdr_mem {
    132         u_long addr;
    133         u_int dataNb;
    134         u_char data[MEM_DATA_MAX];
    135 };
    136 typedef struct xdr_mem xdr_mem;
    137 
    138 enum 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 };
    149 typedef enum break_type break_type;
     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;
    150148#define MAX_THRD_BRK 4
    151149
    152 struct 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 };
    163 typedef struct xdr_break xdr_break;
     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;
    164162#define UTHREAD_MAX 64
    165163#define THREADNAMEMAX 16
    166164
    167 typedef char *thread_name;
    168 
    169 struct KernThread {
    170         u_int threadLi;
    171 };
    172 typedef struct KernThread KernThread;
    173 typedef KernThread *ptThreadList;
    174 
    175 struct thread_list {
    176         u_int nbThread;
    177         ptThreadList threads;
    178 };
    179 typedef struct thread_list thread_list;
    180 
    181 struct 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 };
    195 typedef struct ptrace_addr_data_in ptrace_addr_data_in;
    196 
    197 struct 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 };
    212 typedef struct ptrace_addr_data_out ptrace_addr_data_out;
    213 
    214 typedef struct {
    215         u_int CHAR_DATA_len;
    216         char *CHAR_DATA_val;
    217 } CHAR_DATA;
     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;
    218216#define XRY_MAX_INST_BUFF 128
    219217#define XRY_MAX_INSTANCES 16
    220218#ifndef XRY_MAX_CMD_STR
    221219#define XRY_MAX_CMD_STR 320
    222 #endif  /* REMDEB_H */
    223 
    224 struct xry_inst {
    225         u_char flags;
    226         u_char type;
    227         u_char sub_type;
    228         u_char res_type;
    229         u_long value;
    230         u_long value2;
    231 };
    232 typedef struct xry_inst xry_inst;
    233 
    234 struct instance {
    235         struct xry_inst instances[XRY_MAX_INSTANCES];
    236         u_char buffer[XRY_MAX_INST_BUFF];
    237 };
    238 typedef struct instance instance;
    239 
    240 struct instance_union {
    241         bool_t instances;
    242         union {
    243                 instance inst;
    244                 char *buffer;
    245         } instance_union_u;
    246 };
    247 typedef struct instance_union instance_union;
    248 
    249 typedef char *one_arg;
     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;
    250248#define XRY_MAX_OBJ_NAME 32
    251   /* now open_connex() routine which establishes a connection to server */
    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   /* now close_connex() routine which detaches from server */
    281 
    282 enum close_control {
    283         CLOSE_IGNORE = 0,
    284         CLOSE_KILL = 1,
    285         CLOSE_DETACH = 2,
    286 };
    287 typedef enum close_control close_control;
    288 
    289 struct close_in {
    290         close_control control;
    291 };
    292 typedef struct close_in close_in;
    293   /* now send_signal() routine which sends signals to processes like kill(2) */
    294 
    295 struct signal_in {
    296         int pid;
    297         int sig;
    298 };
    299 typedef struct signal_in signal_in;
    300 
    301 struct signal_out {
    302         int kill_return;
    303         int errNo;
    304 };
    305 typedef struct signal_out signal_out;
    306   /* now wait_info() routine which returns results of polling the wait status
    307         of a process/actor. It may return 0 if running, else pid or -1 */
    308 
    309 enum stop_code {
    310         STOP_ERROR = 0,
    311         STOP_NONE = 1,
    312         STOP_UNKNOWN = 2,
    313         STOP_BREAK = 3,
    314         STOP_STEP = 4,
    315         STOP_SIGNAL = 5,
    316         STOP_TERM_EXIT = 6,
    317         STOP_TERM_SIG = 7,
    318         STOP_DETACHED = 8,
    319         STOP_KILLED = 9,
    320         STOP_SPAWN_FAILED = 10,
    321 };
    322 typedef enum stop_code stop_code;
    323 
    324 struct wait_in {
    325         int pid;
    326 };
    327 typedef struct wait_in wait_in;
    328 
    329 struct wait_out {
    330         int wait_return;
    331         int errNo;
    332         int status;
    333         stop_code reason;
    334         int handle;
    335         u_long PC;
    336         u_long SP;
    337         u_long FP;
    338         u_long thread;
    339 };
    340 typedef struct wait_out wait_out;
    341   /* now ptrace() routine. This matches the Sun UNIX ptrace as well as
    342         some additions */
     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   */
    343351#define PTRFLG_FORCE 1
    344352#define PTRFLG_NON_OWNER 2
     
    346354#define PTRDET_UNOWN 0x100
    347355
    348 struct ptrace_in {
    349         int pid;
    350         ptrace_addr_data_in addr;
    351         u_int data;
    352         u_int flags;
    353 };
    354 typedef struct ptrace_in ptrace_in;
    355 
    356 struct ptrace_out {
    357         ptrace_addr_data_out addr;
    358         int result;
    359         int errNo;
    360 };
    361 typedef struct ptrace_out ptrace_out;
    362 
    363 struct one_symbol {
    364         char *symbolName;
    365         long symbolValue;
    366 };
    367 typedef struct one_symbol one_symbol;
    368 
    369 typedef struct {
    370         u_int all_symbols_len;
    371         one_symbol *all_symbols_val;
    372 } all_symbols;
    373 
    374 struct get_global_symbols_out {
    375         all_symbols symbols;
    376 };
    377 typedef struct get_global_symbols_out get_global_symbols_out;
    378 
    379 struct get_text_data_in {
    380         int pid;
    381         char *actorName;
    382 };
    383 typedef struct get_text_data_in get_text_data_in;
    384 
    385 struct get_text_data_out {
    386         int result;
    387         int errNo;
    388         u_long textStart;
    389         u_long textSize;
    390         u_long dataStart;
    391         u_long dataSize;
    392 };
    393 typedef struct get_text_data_out get_text_data_out;
    394 
    395 struct one_signal {
    396         u_int number;
    397         char *name;
    398 };
    399 typedef struct one_signal one_signal;
    400 
    401 typedef struct {
    402         u_int all_signals_len;
    403         one_signal *all_signals_val;
    404 } all_signals;
    405 
    406 struct get_signal_names_out {
    407         all_signals signals;
    408 };
    409 typedef struct get_signal_names_out get_signal_names_out;
    410   /* now define the actual calls we support */
     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   */
    411421#define REMDEB_H
    412422#endif
     
    417427#if defined(__STDC__) || defined(__cplusplus)
    418428#define OPEN_CONNEX 1
    419 extern  open_out * open_connex_2(open_in *, CLIENT *);
    420 extern  open_out * open_connex_2_svc(open_in *, struct svc_req *);
     429  extern open_out *open_connex_2 (open_in *, CLIENT *);
     430  extern open_out *open_connex_2_svc (open_in *, struct svc_req *);
    421431#define SEND_SIGNAL 2
    422 extern  signal_out * send_signal_2(signal_in *, CLIENT *);
    423 extern  signal_out * send_signal_2_svc(signal_in *, struct svc_req *);
     432  extern signal_out *send_signal_2 (signal_in *, CLIENT *);
     433  extern signal_out *send_signal_2_svc (signal_in *, struct svc_req *);
    424434#define CLOSE_CONNEX 10
    425 extern  void * close_connex_2(close_in *, CLIENT *);
    426 extern  void * close_connex_2_svc(close_in *, struct svc_req *);
     435  extern void *close_connex_2 (close_in *, CLIENT *);
     436  extern void *close_connex_2_svc (close_in *, struct svc_req *);
    427437#define PTRACE 11
    428 extern  ptrace_out * ptrace_2(ptrace_in *, CLIENT *);
    429 extern  ptrace_out * ptrace_2_svc(ptrace_in *, struct svc_req *);
     438  extern ptrace_out *ptrace_2 (ptrace_in *, CLIENT *);
     439  extern ptrace_out *ptrace_2_svc (ptrace_in *, struct svc_req *);
    430440#define WAIT_INFO 13
    431 extern  wait_out * wait_info_2(wait_in *, CLIENT *);
    432 extern  wait_out * wait_info_2_svc(wait_in *, struct svc_req *);
     441  extern wait_out *wait_info_2 (wait_in *, CLIENT *);
     442  extern wait_out *wait_info_2_svc (wait_in *, struct svc_req *);
    433443#define GET_SIGNAL_NAMES 17
    434 extern  get_signal_names_out * get_signal_names_2(void *, CLIENT *);
    435 extern  get_signal_names_out * get_signal_names_2_svc(void *, struct svc_req *);
    436 extern int remotedeb_2_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
    437 
    438 #else /* K&R C */
     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 */
    439450#define OPEN_CONNEX 1
    440 extern  open_out * open_connex_2();
    441 extern  open_out * open_connex_2_svc();
     451  extern open_out *open_connex_2 ();
     452  extern open_out *open_connex_2_svc ();
    442453#define SEND_SIGNAL 2
    443 extern  signal_out * send_signal_2();
    444 extern  signal_out * send_signal_2_svc();
     454  extern signal_out *send_signal_2 ();
     455  extern signal_out *send_signal_2_svc ();
    445456#define CLOSE_CONNEX 10
    446 extern  void * close_connex_2();
    447 extern  void * close_connex_2_svc();
     457  extern void *close_connex_2 ();
     458  extern void *close_connex_2_svc ();
    448459#define PTRACE 11
    449 extern  ptrace_out * ptrace_2();
    450 extern  ptrace_out * ptrace_2_svc();
     460  extern ptrace_out *ptrace_2 ();
     461  extern ptrace_out *ptrace_2_svc ();
    451462#define WAIT_INFO 13
    452 extern  wait_out * wait_info_2();
    453 extern  wait_out * wait_info_2_svc();
     463  extern wait_out *wait_info_2 ();
     464  extern wait_out *wait_info_2_svc ();
    454465#define GET_SIGNAL_NAMES 17
    455 extern  get_signal_names_out * get_signal_names_2();
    456 extern  get_signal_names_out * get_signal_names_2_svc();
    457 extern int remotedeb_2_freeresult ();
    458 #endif /* K&R C */
     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 */
    459470
    460471/* the xdr functions */
    461472
    462473#if defined(__STDC__) || defined(__cplusplus)
    463 extern  bool_t xdr_rpc_type (XDR *, rpc_type*);
    464 extern  bool_t xdr_UDP_MSG (XDR *, UDP_MSG*);
    465 extern  bool_t xdr_ptracereq (XDR *, ptracereq*);
    466 extern  bool_t xdr_xdr_regs (XDR *, xdr_regs*);
    467 extern  bool_t xdr_xdr_mem (XDR *, xdr_mem*);
    468 extern  bool_t xdr_break_type (XDR *, break_type*);
    469 extern  bool_t xdr_xdr_break (XDR *, xdr_break*);
    470 extern  bool_t xdr_thread_name (XDR *, thread_name*);
    471 extern  bool_t xdr_KernThread (XDR *, KernThread*);
    472 extern  bool_t xdr_thread_list (XDR *, thread_list*);
    473 extern  bool_t xdr_ptrace_addr_data_in (XDR *, ptrace_addr_data_in*);
    474 extern  bool_t xdr_ptrace_addr_data_out (XDR *, ptrace_addr_data_out*);
    475 extern  bool_t xdr_CHAR_DATA (XDR *, CHAR_DATA*);
    476 extern  bool_t xdr_xry_inst (XDR *, xry_inst*);
    477 extern  bool_t xdr_instance (XDR *, instance*);
    478 extern  bool_t xdr_instance_union (XDR *, instance_union*);
    479 extern  bool_t xdr_one_arg (XDR *, one_arg*);
    480 extern  bool_t xdr_debug_type (XDR *, debug_type*);
    481 extern  bool_t xdr_open_in (XDR *, open_in*);
    482 extern  bool_t xdr_open_out (XDR *, open_out*);
    483 extern  bool_t xdr_close_control (XDR *, close_control*);
    484 extern  bool_t xdr_close_in (XDR *, close_in*);
    485 extern  bool_t xdr_signal_in (XDR *, signal_in*);
    486 extern  bool_t xdr_signal_out (XDR *, signal_out*);
    487 extern  bool_t xdr_stop_code (XDR *, stop_code*);
    488 extern  bool_t xdr_wait_in (XDR *, wait_in*);
    489 extern  bool_t xdr_wait_out (XDR *, wait_out*);
    490 extern  bool_t xdr_ptrace_in (XDR *, ptrace_in*);
    491 extern  bool_t xdr_ptrace_out (XDR *, ptrace_out*);
    492 extern  bool_t xdr_one_symbol (XDR *, one_symbol*);
    493 extern  bool_t xdr_all_symbols (XDR *, all_symbols*);
    494 extern  bool_t xdr_get_global_symbols_out (XDR *, get_global_symbols_out*);
    495 extern  bool_t xdr_get_text_data_in (XDR *, get_text_data_in*);
    496 extern  bool_t xdr_get_text_data_out (XDR *, get_text_data_out*);
    497 extern  bool_t xdr_one_signal (XDR *, one_signal*);
    498 extern  bool_t xdr_all_signals (XDR *, all_signals*);
    499 extern  bool_t xdr_get_signal_names_out (XDR *, get_signal_names_out*);
    500 
    501 #else /* K&R C */
    502 extern bool_t xdr_rpc_type ();
    503 extern bool_t xdr_UDP_MSG ();
    504 extern bool_t xdr_ptracereq ();
    505 extern bool_t xdr_xdr_regs ();
    506 extern bool_t xdr_xdr_mem ();
    507 extern bool_t xdr_break_type ();
    508 extern bool_t xdr_xdr_break ();
    509 extern bool_t xdr_thread_name ();
    510 extern bool_t xdr_KernThread ();
    511 extern bool_t xdr_thread_list ();
    512 extern bool_t xdr_ptrace_addr_data_in ();
    513 extern bool_t xdr_ptrace_addr_data_out ();
    514 extern bool_t xdr_CHAR_DATA ();
    515 extern bool_t xdr_xry_inst ();
    516 extern bool_t xdr_instance ();
    517 extern bool_t xdr_instance_union ();
    518 extern bool_t xdr_one_arg ();
    519 extern bool_t xdr_debug_type ();
    520 extern bool_t xdr_open_in ();
    521 extern bool_t xdr_open_out ();
    522 extern bool_t xdr_close_control ();
    523 extern bool_t xdr_close_in ();
    524 extern bool_t xdr_signal_in ();
    525 extern bool_t xdr_signal_out ();
    526 extern bool_t xdr_stop_code ();
    527 extern bool_t xdr_wait_in ();
    528 extern bool_t xdr_wait_out ();
    529 extern bool_t xdr_ptrace_in ();
    530 extern bool_t xdr_ptrace_out ();
    531 extern bool_t xdr_one_symbol ();
    532 extern bool_t xdr_all_symbols ();
    533 extern bool_t xdr_get_global_symbols_out ();
    534 extern bool_t xdr_get_text_data_in ();
    535 extern bool_t xdr_get_text_data_out ();
    536 extern bool_t xdr_one_signal ();
    537 extern bool_t xdr_all_signals ();
    538 extern bool_t xdr_get_signal_names_out ();
    539 
    540 #endif /* K&R C */
     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 */
    541552
    542553#ifdef __cplusplus
    543554}
    544555#endif
    545 
    546 #endif /* !_REMDEB_H_RPCGEN */
     556#endif                          /* !_REMDEB_H_RPCGEN */
  • c/src/librdbg/src/m68k/any/remdeb_svc.c

    r8e3caa5 r40cf43ea  
    2323   */
    2424#ifndef XRY_MAX_CMD_STR
    25 #endif  /* REMDEB_H */
    26   /* now open_connex() routine which establishes a connection to server */
    27 #define DEBUGGER_IS_GDB 0x2    /* */
    28   /* now close_connex() routine which detaches from server */
    29   /* now send_signal() routine which sends signals to processes like kill(2) */
    30   /* now wait_info() routine which returns results of polling the wait status
    31         of a process/actor. It may return 0 if running, else pid or -1 */
    32   /* now ptrace() routine. This matches the Sun UNIX ptrace as well as
    33         some additions */
    34   /* now define the actual calls we support */
    35 const char* names [] = {
    36     "NULLPROC", "OPEN_CONNEX", "SEND_SIGNAL", "name3",
    37     "name4", "name5", "name6", "name7",
    38     "name8", "name9", "CLOSE_CONNEX", "PTRACE",
    39     "name12", "WAIT_INFO", "name14", "name15",
    40     "name16", "GET_SIGNAL_NAMES", "name18"
     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   */
     47const 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"
    4153};
    4254
    4355void
    44 remotedeb_2(struct svc_req *rqstp, register SVCXPRT *transp)
     56remotedeb_2 (struct svc_req *rqstp, register SVCXPRT * transp)
    4557{
    46         union {
    47                 open_in open_connex_2_arg;
    48                 signal_in send_signal_2_arg;
    49                 close_in close_connex_2_arg;
    50                 ptrace_in ptrace_2_arg;
    51                 wait_in wait_info_2_arg;
    52         } argument;
    53         char *result;
    54         xdrproc_t _xdr_argument, _xdr_result;
    55         char *(*local)(char *, struct svc_req *);
     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 *);
    5668
    57         DPRINTF (("remotedeb_2: %s (%d)\n",
    58                 (unsigned) rqstp->rq_proc <
    59                 (unsigned) (sizeof names / sizeof names[0]) ?
    60                 names [rqstp->rq_proc] : "???",
    61                 (int) rqstp->rq_proc));
     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));
    6273
    63         switch (rqstp->rq_proc) {
    64         case NULLPROC:
    65                 (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
    66                 return;
     74  switch (rqstp->rq_proc) {
     75  case NULLPROC:
     76    (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *) NULL);
     77    return;
    6778
    68         case OPEN_CONNEX:
    69                 _xdr_argument = (xdrproc_t) xdr_open_in;
    70                 _xdr_result = (xdrproc_t) xdr_open_out;
    71                 local = (char *(*)(char *, struct svc_req *)) open_connex_2_svc;
    72                 break;
     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;
    7384
    74         case SEND_SIGNAL:
    75                 _xdr_argument = (xdrproc_t) xdr_signal_in;
    76                 _xdr_result = (xdrproc_t) xdr_signal_out;
    77                 local = (char *(*)(char *, struct svc_req *)) send_signal_2_svc;
    78                 break;
     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;
    7990
    80         case CLOSE_CONNEX:
    81                 _xdr_argument = (xdrproc_t) xdr_close_in;
    82                 _xdr_result = (xdrproc_t) xdr_void;
    83                 local = (char *(*)(char *, struct svc_req *)) close_connex_2_svc;
    84                 break;
     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;
    8596
    86         case PTRACE:
    87                 _xdr_argument = (xdrproc_t) xdr_ptrace_in;
    88                 _xdr_result = (xdrproc_t) xdr_ptrace_out;
    89                 local = (char *(*)(char *, struct svc_req *)) ptrace_2_svc;
    90                 break;
     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;
    91102
    92         case WAIT_INFO:
    93                 _xdr_argument = (xdrproc_t) xdr_wait_in;
    94                 _xdr_result = (xdrproc_t) xdr_wait_out;
    95                 local = (char *(*)(char *, struct svc_req *)) wait_info_2_svc;
    96                 break;
     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;
    97108
    98         case GET_SIGNAL_NAMES:
    99                 _xdr_argument = (xdrproc_t) xdr_void;
    100                 _xdr_result = (xdrproc_t) xdr_get_signal_names_out;
    101                 local = (char *(*)(char *, struct svc_req *)) get_signal_names_2_svc;
    102                 break;
     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;
    103114
    104         default:
    105                 svcerr_noproc (transp);
    106                 return;
    107         }
    108         memset ((char *)&argument, 0, sizeof (argument));
    109         if (!svc_getargs (transp, _xdr_argument, (caddr_t) &argument)) {
    110                 svcerr_decode (transp);
    111                 return;
    112         }
    113         result = (*local)((char *)&argument, rqstp);
    114         if (result != NULL && !svc_sendreply(transp, _xdr_result, result)) {
    115                 svcerr_systemerr (transp);
    116         }
    117         if (!svc_freeargs (transp, _xdr_argument, (caddr_t) &argument)) {
    118                 fprintf (stderr, "unable to free arguments");
    119                 exit (1);
    120         }
    121         return;
     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;
    122133}
  • c/src/librdbg/src/m68k/any/remdeb_xdr.c

    r8e3caa5 r40cf43ea  
    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 }
     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}
     37
    3738/*
    3839 * Sun request values for the remote ptrace system call
    3940 */
    4041
    41 
    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;
    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 }
     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; 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
    149146  /*
    150147   * Memory data for read/write text or data. The size is in data. The target
     
    154151   * become too small if this value gets incremented.
    155152   */
    156 bool_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 
    169 bool_t
    170 xdr_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 
    179 bool_t
    180 xdr_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 
    294 bool_t
    295 xdr_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 
    304 bool_t
    305 xdr_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 }
    313 bool_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 
    321 bool_t
    322 xdr_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 
    371 bool_t
    372 xdr_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 
    429 bool_t
    430 xdr_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 }
     153bool_t
     154xdr_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
     167bool_t
     168xdr_break_type (XDR * xdrs, break_type * objp)
     169{
     170  register int32_t *buf;