Changeset 40cf43ea in rtems for c/src/librdbg/src/ptrace.c


Ignore:
Timestamp:
Feb 1, 2002, 5:00:01 PM (20 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.
File:
1 edited

Legend:

Unmodified
Added
Removed
  • c/src/librdbg/src/ptrace.c

    r8e3caa5 r40cf43ea  
    2020extern rtems_id wakeupEventSemId;
    2121extern rtems_id eventTaskId;
     22extern rtems_id debugId;
    2223extern Exception_context *FirstCtx;
    2324extern Exception_context *LastCtx;
     
    2526extern unsigned int NbExceptCtx;
    2627
    27 
    28 
    29 /* --------------------------------------------------------------------
    30    return a pointer to the Thread Control structure of the specified
    31    Id
    32    -------------------------------------------------------------------- */
    33 
    34 Thread_Control *Thread_Get_RDBG (
    35   Objects_Id           Id
    36 )
     28/*
     29 * return a pointer to the Thread Control structure of the specified
     30 * Id
     31 */
     32
     33  Thread_Control *
     34Thread_Get_RDBG (Objects_Id Id)
    3735{
    3836  unsigned index;
    3937
    40   if ( Id <_Objects_Information_table[OBJECTS_RTEMS_TASKS]->maximum_id &&
    41        Id >_Objects_Information_table[OBJECTS_RTEMS_TASKS]->minimum_id) {
     38  if (Id < _Objects_Information_table[OBJECTS_RTEMS_TASKS]->maximum_id &&
     39      Id > _Objects_Information_table[OBJECTS_RTEMS_TASKS]->minimum_id) {
    4240
    4341    index = Id - _Objects_Information_table[OBJECTS_RTEMS_TASKS]->minimum_id;
    44     if ( _Objects_Information_table[OBJECTS_RTEMS_TASKS]->local_table[1+index] != NULL) {
    45       return (Thread_Control *)(_Objects_Information_table[OBJECTS_RTEMS_TASKS]->local_table[1+index]);
     42    if (_Objects_Information_table[OBJECTS_RTEMS_TASKS]->local_table[1 + index] != NULL) {
     43      return (Thread_Control*) (_Objects_Information_table[OBJECTS_RTEMS_TASKS]->local_table[1 + index]);
    4644    }
    4745  }
    48  
    49   if ( Id <_Objects_Information_table[OBJECTS_POSIX_THREADS]->maximum_id &&
    50        Id >_Objects_Information_table[OBJECTS_POSIX_THREADS]->minimum_id) {
     46
     47  if (Id < _Objects_Information_table[OBJECTS_POSIX_THREADS]->maximum_id &&
     48      Id > _Objects_Information_table[OBJECTS_POSIX_THREADS]->minimum_id) {
    5149
    5250    index = Id - _Objects_Information_table[OBJECTS_POSIX_THREADS]->minimum_id;
    53     if ( _Objects_Information_table[OBJECTS_POSIX_THREADS]->local_table[1+index] != NULL)
    54       return (Thread_Control *)(_Objects_Information_table[OBJECTS_POSIX_THREADS]->local_table[1+index]);
     51    if (_Objects_Information_table[OBJECTS_POSIX_THREADS]->
     52        local_table[1 + index] != NULL)
     53      return (Thread_Control*) (_Objects_Information_table[OBJECTS_POSIX_THREADS]->local_table[1 + index]);
    5554  }
    5655
     
    5958}
    6059
    61 
    62 /* --------------------------------------------------------------------
    63    Memory read
    64    -------------------------------------------------------------------- */
    65 
    66 int
    67 safeMemRead(void *src, void *dest, int nbBytes){
     60  int
     61safeMemRead (void *src, void *dest, int nbBytes)
     62{
    6863
    6964  /*
     
    7368   */
    7469
    75   memcpy(dest, src, nbBytes);
     70  memcpy (dest, src, nbBytes);
    7671  return 0;
    7772}
    7873
    79 /* --------------------------------------------------------------------
    80    Memory write
    81    -------------------------------------------------------------------- */
    82 int
    83 safeMemWrite(void *src, void * dest, int nbBytes){
     74  int
     75safeMemWrite (void *src, void *dest, int nbBytes)
     76{
    8477
    8578  /*
     
    8881   * TBD
    8982   */
    90  
    91   memcpy(dest, src, nbBytes);
    92   return 0; 
     83
     84  memcpy (dest, src, nbBytes);
     85  return 0;
    9386}
    9487
    95 /* --------------------------------------------------------------------
    96    Ptrace
    97    -------------------------------------------------------------------- */
    98 
    99 int
    100 ptrace (int request, int pid, char* addr, int data, char* addr2)
    101  {
    102    int diag;
    103    errno = 0 ;
    104    if (pid != 1) {
    105      errno = ESRCH;
    106      return -1;
    107    }
    108    switch (request) {
    109 
    110    case RPT_SINGLESTEP:{
    111      Exception_context *ctx;
    112 
    113      if (CannotRestart == 1){
    114        setErrno(EIO);
    115        return -1;
    116      }
    117      
    118      if ((ctx = GetExceptCtx (currentTargetThread)) != NULL) {
    119        Single_Step(ctx->ctx);
    120        rtems_semaphore_release( ctx->semaphoreId );
    121        return 0;
    122      }
    123      break;
    124    }
    125 
    126    case RPT_PEEKTEXT:
    127    case RPT_PEEKDATA: {
    128      diag = safeMemRead(addr, &data, sizeof data);
    129      if (diag == 0) return data;
    130    mem_error:
    131      return -1;
    132    }
    133 
    134    case RPT_POKETEXT: {
    135      diag = safeMemWrite(&data, addr, sizeof data);
    136 
    137      /*
    138       * We must flush the INSTR and DATA cache to be sure the
    139       * opcode modification is taken into account, because
    140       * the breakpoint opcode is written via the data cache
    141       * while execution code is fetched via the instruction
    142       * cache
    143       */
    144      
    145      if (diag == 0) {
    146        copyback_data_cache_and_invalidate_instr_cache(addr, sizeof data);
    147        return 0;
    148      }
    149      goto mem_error;
    150    }
    151    case RPT_POKEDATA: {
    152      diag = safeMemWrite(&data, addr, sizeof data);
    153      if (diag == 0) return 0;
    154      goto mem_error;
    155    }
    156    case RPT_CONT: {
    157      Exception_context *ctx;
    158 
    159      if (CannotRestart == 1){
    160        setErrno (EIO);
    161        return -1;
    162      }
    163              
    164      ctx = GetExceptCtx (currentTargetThread);
    165 
    166      if (!isRdbgException(ctx)) {
    167        CannotRestart = 1;
    168        setErrno (EIO);
    169        return -1;
    170      }
    171 
    172      assert (data == 0);
    173      assert (ExitForSingleStep == 0);
    174 
    175      rtems_semaphore_release( serializeSemId );
    176 
    177      if ((ctx = GetExceptCtx (currentTargetThread)) != NULL) {
    178        rtems_semaphore_release( ctx->semaphoreId );
    179      }
    180      return 0;
    181    }
    182      
    183    case RPT_ATTACH:
    184      return 0;
    185      
    186    case RPT_DETACH:{
    187      Exception_context *ctx;
    188      
    189      if (NbExceptCtx || NbSerializedCtx) {
    190        ctx = FirstCtx;
    191        rtems_task_delete(eventTaskId);
    192        rtems_semaphore_delete(serializeSemId);
    193        rtems_semaphore_delete(wakeupEventSemId);
    194      }
    195      return 0;
    196    }
    197      
    198    case RPT_GETREGS:{
    199      Exception_context *ctx;
    200 
    201      if ((ctx = GetExceptCtx (currentTargetThread)) != NULL) {
    202        CtxToRegs (ctx->ctx, (xdr_regs*) addr);
    203        return 0;
    204      }
    205      break;
    206    }
    207 
    208    case RPT_SETREGS:{
    209      Exception_context *ctx;
    210 
    211      if ((ctx = GetExceptCtx (currentTargetThread)) != NULL) {
    212        RegsToCtx ((xdr_regs*) addr, ctx->ctx);
    213        return 0;
    214      }
    215      break;
    216    }
    217  
    218    case RPT_READTEXT:
    219    case RPT_READDATA: {
    220      diag = safeMemRead(addr, addr2, data);
    221      if (diag == 0) return 0;
    222      goto mem_error;
    223    }
    224    case RPT_WRITETEXT:
    225    case RPT_WRITEDATA: {
    226      diag = safeMemWrite(addr2, addr, data);
    227      if (diag == 0) return 0;
    228      goto mem_error;
    229    }
    230    
    231    case RPT_GETTARGETTHREAD:
    232      if (!NbExceptCtx) {
    233        errno = EBUSY;
    234        return -1;
    235      }       
    236      return currentTargetThread;
    237 
    238    case RPT_SETTARGETTHREAD:
    239      if (!NbExceptCtx) {
    240        errno = EBUSY;
    241        return -1;
    242      }
    243      currentTargetThread = data;
    244      return 0;
    245      
    246    case RPT_GETTHREADNAME: {
    247      return TgtGetThreadName (NULL, (unsigned)(data), (char *) addr);
    248    }   
    249    
    250    case RPT_THREADLIST: {
    251      int count = TgtThreadList (NULL, (unsigned*) addr, UTHREAD_MAX
    252                                 * sizeof (unsigned));
    253      if (count < 0) {   
    254        errno = EINVAL; 
    255        return -1;       
    256      } 
    257      return count;
    258    }   
    259 
    260    case RPT_SETTHREADREGS: {
    261      Exception_context *ctx;
    262      CPU_Exception_frame Ectx;
    263      Thread_Control *thread;
    264      rtems_id id;
    265          
    266      rtems_task_ident(RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &id);
    267      if (data == (unsigned)id)
    268        break;
    269      
    270      if ((ctx = GetExceptCtx (data)) != NULL) {
    271        RegsToCtx ((xdr_regs*) addr, ctx->ctx);
    272        return 0;
    273      }
    274      thread = Thread_Get_RDBG ((Objects_Id)(data));
    275      if (thread != NULL) {
    276        RegsToCtx ((xdr_regs*) addr, &Ectx);
    277        set_ctx_thread (thread, &Ectx);
    278        return 0;
    279      }
    280      break;
    281    }
    282 
    283    case RPT_GETTHREADREGS: {
    284      Exception_context *ctx;
    285      CPU_Exception_frame Ectx;
    286      Thread_Control *thread;
    287      rtems_id id;
    288          
    289      rtems_task_ident(RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &id);
    290      if (data == (unsigned)id){
    291        justSaveContext = 1;
    292        enterRdbg();
    293        CtxToRegs (&(SavedContext), (xdr_regs*) addr);
    294        return 0;
    295      }
    296      
    297      if ((ctx = GetExceptCtx (data)) != NULL) {
    298        CtxToRegs (ctx->ctx, (xdr_regs*) addr);
    299        return 0;
    300      }
    301      thread = Thread_Get_RDBG ((Objects_Id)(data));
    302      if (thread != NULL) {
    303        get_ctx_thread (thread, &Ectx);
    304        CtxToRegs (&Ectx, (xdr_regs*) addr);
    305        return 0;
    306      }       
    307      break;
    308    }
    309    
    310    case RPT_KILL:
    311      TotalReboot = 1;
    312      return 0;
    313 
    314    case RPT_TRACEME:
    315    case RPT_PEEKUSER:
    316    case RPT_POKEUSER:
    317    case RPT_GETFPREGS:
    318    case RPT_SETFPREGS:
    319    case RPT_GETFPAREGS:
    320    case RPT_SETFPAREGS:
    321    case RPT_SYSCALL:
    322    case RPT_DUMPCORE:
    323    case RPT_GETUCODE:
    324    case RPT_THREADSUSPEND:
    325    case RPT_THREADRESUME:
    326    case RPT_SETTHREADNAME:
    327    default:
    328      break;
    329    }
    330    errno = EINVAL;
    331    return -1;
     88  int
     89ptrace (int request, int pid, char *addr, int data, char *addr2)
     90{
     91  int diag;
     92  errno = 0;
     93  if (pid != 1) {
     94    errno = ESRCH;
     95    return -1;
     96  }
     97  switch (request) {
     98
     99  case RPT_SINGLESTEP:{
     100      Exception_context *ctx;
     101
     102      if (CannotRestart == 1) {
     103        setErrno (EIO);
     104        return -1;
     105      }
     106
     107      if ((ctx = GetExceptCtx (currentTargetThread)) != NULL) {
     108        Single_Step (ctx->ctx);
     109        rtems_semaphore_release (ctx->semaphoreId);
     110        return 0;
     111      }
     112      break;
     113    }
     114
     115  case RPT_PEEKTEXT:
     116  case RPT_PEEKDATA:{
     117      diag = safeMemRead (addr, &data, sizeof data);
     118      if (diag == 0)
     119        return data;
     120    mem_error:
     121      return -1;
     122    }
     123
     124  case RPT_POKETEXT:{
     125      diag = safeMemWrite (&data, addr, sizeof data);
     126
     127      /*
     128       * We must flush the INSTR and DATA cache to be sure the
     129       * opcode modification is taken into account, because
     130       * the breakpoint opcode is written via the data cache
     131       * while execution code is fetched via the instruction
     132       * cache
     133       */
     134
     135      if (diag == 0) {
     136        copyback_data_cache_and_invalidate_instr_cache (addr, sizeof data);
     137        return 0;
     138      }
     139      goto mem_error;
     140    }
     141  case RPT_POKEDATA:{
     142      diag = safeMemWrite (&data, addr, sizeof data);
     143      if (diag == 0)
     144        return 0;
     145      goto mem_error;
     146    }
     147  case RPT_CONT:{
     148      Exception_context *ctx;
     149
     150      if (CannotRestart == 1) {
     151        setErrno (EIO);
     152        return -1;
     153      }
     154
     155      ctx = GetExceptCtx (currentTargetThread);
     156      if (ctx == NULL)
     157        ctx = GetExceptCtx (debugId);
     158
     159      if (ctx != NULL) {
     160
     161        if (!isRdbgException (ctx)) {
     162          CannotRestart = 1;
     163          setErrno (EIO);
     164          return -1;
     165        }
     166
     167        assert (data == 0);
     168        assert (ExitForSingleStep == 0);
     169
     170        rtems_semaphore_release (ctx->semaphoreId);
     171      }
     172      rtems_semaphore_release (serializeSemId);
     173      return 0;
     174    }
     175
     176  case RPT_ATTACH:
     177    return 0;
     178
     179  case RPT_DETACH:{
     180      Exception_context *ctx;
     181
     182      if (NbExceptCtx || NbSerializedCtx) {
     183        ctx = FirstCtx;
     184        rtems_task_delete (eventTaskId);
     185        rtems_semaphore_delete (serializeSemId);
     186        rtems_semaphore_delete (wakeupEventSemId);
     187      }
     188      return 0;
     189    }
     190
     191  case RPT_GETREGS:{
     192      Exception_context *ctx;
     193
     194      if ((ctx = GetExceptCtx (currentTargetThread)) != NULL) {
     195        CtxToRegs (ctx->ctx, (xdr_regs *) addr);
     196        return 0;
     197      }
     198      break;
     199    }
     200
     201  case RPT_SETREGS:{
     202      Exception_context *ctx;
     203
     204      if ((ctx = GetExceptCtx (currentTargetThread)) != NULL) {
     205        RegsToCtx ((xdr_regs *) addr, ctx->ctx);
     206        return 0;
     207      }
     208      break;
     209    }
     210
     211  case RPT_READTEXT:
     212  case RPT_READDATA:{
     213      diag = safeMemRead (addr, addr2, data);
     214      if (diag == 0)
     215        return 0;
     216      goto mem_error;
     217    }
     218  case RPT_WRITETEXT:
     219  case RPT_WRITEDATA:{
     220      diag = safeMemWrite (addr2, addr, data);
     221      if (diag == 0)
     222        return 0;
     223      goto mem_error;
     224    }
     225
     226  case RPT_GETTARGETTHREAD:
     227    if (!NbExceptCtx) {
     228      errno = EBUSY;
     229      return -1;
     230    }
     231    return currentTargetThread;
     232
     233  case RPT_SETTARGETTHREAD:
     234    if (!NbExceptCtx) {
     235      errno = EBUSY;
     236      return -1;
     237    }
     238    currentTargetThread = data;
     239    return 0;
     240
     241  case RPT_GETTHREADNAME:{
     242      return TgtGetThreadName (NULL, (unsigned) (data), (char *) addr);
     243    }
     244
     245  case RPT_THREADLIST:{
     246      int count = TgtThreadList (NULL, (unsigned *) addr, UTHREAD_MAX
     247                                 * sizeof (unsigned));
     248      if (count < 0) {
     249        errno = EINVAL;
     250        return -1;
     251      }
     252      return count;
     253    }
     254
     255  case RPT_SETTHREADREGS:{
     256      Exception_context *ctx;
     257      CPU_Exception_frame Ectx;
     258      Thread_Control *thread;
     259      rtems_id id;
     260
     261      rtems_task_ident (RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &id);
     262      if (data == (unsigned) id)
     263        break;
     264
     265      if ((ctx = GetExceptCtx (data)) != NULL) {
     266        RegsToCtx ((xdr_regs *) addr, ctx->ctx);
     267        return 0;
     268      }
     269      thread = Thread_Get_RDBG ((Objects_Id) (data));
     270      if (thread != NULL) {
     271        RegsToCtx ((xdr_regs *) addr, &Ectx);
     272        set_ctx_thread (thread, &Ectx);
     273        return 0;
     274      }
     275      break;
     276    }
     277
     278  case RPT_GETTHREADREGS:{
     279      Exception_context *ctx;
     280      CPU_Exception_frame Ectx;
     281      Thread_Control *thread;
     282      rtems_id id;
     283
     284      rtems_task_ident (RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &id);
     285      if (data == (unsigned) id) {
     286        justSaveContext = 1;
     287        enterRdbg ();
     288        CtxToRegs (&(SavedContext), (xdr_regs *) addr);
     289        return 0;
     290      }
     291
     292      if ((ctx = GetExceptCtx (data)) != NULL) {
     293        CtxToRegs (ctx->ctx, (xdr_regs *) addr);
     294        return 0;
     295      }
     296      thread = Thread_Get_RDBG ((Objects_Id) (data));
     297      if (thread != NULL) {
     298        get_ctx_thread (thread, &Ectx);
     299        CtxToRegs (&Ectx, (xdr_regs *) addr);
     300        return 0;
     301      }
     302      break;
     303    }
     304
     305  case RPT_KILL:
     306    TotalReboot = 1;
     307    return 0;
     308
     309  case RPT_TRACEME:
     310  case RPT_PEEKUSER:
     311  case RPT_POKEUSER:
     312  case RPT_GETFPREGS:
     313  case RPT_SETFPREGS:
     314  case RPT_GETFPAREGS:
     315  case RPT_SETFPAREGS:
     316  case RPT_SYSCALL:
     317  case RPT_DUMPCORE:
     318  case RPT_GETUCODE:
     319  case RPT_THREADSUSPEND:
     320  case RPT_THREADRESUME:
     321  case RPT_SETTHREADNAME:
     322  default:
     323    break;
     324  }
     325  errno = EINVAL;
     326  return -1;
    332327}
Note: See TracChangeset for help on using the changeset viewer.