[BACK]Return to pthread_dbg.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / lib / libpthread_dbg

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/lib/libpthread_dbg/Attic/pthread_dbg.c between version 1.31 and 1.32

version 1.31, 2006/05/14 02:16:36 version 1.32, 2006/12/24 03:47:53
Line 276  td_thr_info(td_thread_t *thread, td_thre
Line 276  td_thr_info(td_thread_t *thread, td_thre
             thread->addr + offsetof(struct __pthread_st, pt_unblockgen),              thread->addr + offsetof(struct __pthread_st, pt_unblockgen),
             &tmp1, sizeof(tmp1))) != 0)              &tmp1, sizeof(tmp1))) != 0)
                 return val;                  return val;
   #ifdef PTHREAD_SA
         if (tmp != tmp1)          if (tmp != tmp1)
                 tmp = _PT_STATE_BLOCKED_SYS;                  tmp = _PT_STATE_BLOCKED_SYS;
   #endif
         else if ((val = READ(thread->proc,          else if ((val = READ(thread->proc,
                       thread->addr + offsetof(struct __pthread_st, pt_state),                        thread->addr + offsetof(struct __pthread_st, pt_state),
                       &tmp, sizeof(tmp))) != 0)                        &tmp, sizeof(tmp))) != 0)
Line 286  td_thr_info(td_thread_t *thread, td_thre
Line 288  td_thr_info(td_thread_t *thread, td_thre
         case PT_STATE_RUNNING:          case PT_STATE_RUNNING:
                 info->thread_state = TD_STATE_RUNNING;                  info->thread_state = TD_STATE_RUNNING;
                 break;                  break;
   #ifdef PTHREAD_SA
         case PT_STATE_RUNNABLE:          case PT_STATE_RUNNABLE:
                 info->thread_state = TD_STATE_RUNNABLE;                  info->thread_state = TD_STATE_RUNNABLE;
                 break;                  break;
Line 298  td_thr_info(td_thread_t *thread, td_thre
Line 301  td_thr_info(td_thread_t *thread, td_thre
         case PT_STATE_SUSPENDED:          case PT_STATE_SUSPENDED:
                 info->thread_state = TD_STATE_SUSPENDED;                  info->thread_state = TD_STATE_SUSPENDED;
                 break;                  break;
   #endif
         case PT_STATE_ZOMBIE:          case PT_STATE_ZOMBIE:
                 info->thread_state = TD_STATE_ZOMBIE;                  info->thread_state = TD_STATE_ZOMBIE;
                 break;                  break;
Line 305  td_thr_info(td_thread_t *thread, td_thre
Line 309  td_thr_info(td_thread_t *thread, td_thre
                 info->thread_state = TD_STATE_UNKNOWN;                  info->thread_state = TD_STATE_UNKNOWN;
         }          }
   
   #ifdef PTHREAD_SA
         if ((val = READ(thread->proc,          if ((val = READ(thread->proc,
             thread->addr + offsetof(struct __pthread_st, pt_type),              thread->addr + offsetof(struct __pthread_st, pt_type),
             &tmp, sizeof(tmp))) != 0)              &tmp, sizeof(tmp))) != 0)
Line 320  td_thr_info(td_thread_t *thread, td_thre
Line 325  td_thr_info(td_thread_t *thread, td_thre
         default:          default:
                 info->thread_type = TD_TYPE_UNKNOWN;                  info->thread_type = TD_TYPE_UNKNOWN;
         }          }
   #endif
   
         if ((val = READ(thread->proc,          if ((val = READ(thread->proc,
             thread->addr + offsetof(struct __pthread_st, pt_stack),              thread->addr + offsetof(struct __pthread_st, pt_stack),
Line 393  int
Line 399  int
 td_thr_getregs(td_thread_t *thread, int regset, void *buf)  td_thr_getregs(td_thread_t *thread, int regset, void *buf)
 {  {
         int tmp, tmp1, val;          int tmp, tmp1, val;
   #ifdef PTHREAD_SA
         caddr_t addr;          caddr_t addr;
         ucontext_t uc;          ucontext_t uc;
   #endif
   
         if ((val = READ(thread->proc,          if ((val = READ(thread->proc,
             thread->addr + offsetof(struct __pthread_st, pt_blockgen),              thread->addr + offsetof(struct __pthread_st, pt_blockgen),
Line 404  td_thr_getregs(td_thread_t *thread, int 
Line 412  td_thr_getregs(td_thread_t *thread, int 
             thread->addr + offsetof(struct __pthread_st, pt_unblockgen),              thread->addr + offsetof(struct __pthread_st, pt_unblockgen),
             &tmp1, sizeof(tmp1))) != 0)              &tmp1, sizeof(tmp1))) != 0)
                 return val;                  return val;
   #ifdef PTHREAD_SA
         if (tmp != tmp1)          if (tmp != tmp1)
                 tmp = _PT_STATE_BLOCKED_SYS;                  tmp = _PT_STATE_BLOCKED_SYS;
         else if ((val = READ(thread->proc,          else
   #endif
           if ((val = READ(thread->proc,
                       thread->addr + offsetof(struct __pthread_st, pt_state),                        thread->addr + offsetof(struct __pthread_st, pt_state),
                       &tmp, sizeof(tmp))) != 0)                        &tmp, sizeof(tmp))) != 0)
                 return val;                  return val;
Line 421  td_thr_getregs(td_thread_t *thread, int 
Line 432  td_thr_getregs(td_thread_t *thread, int 
                 if (val != 0)                  if (val != 0)
                         return val;                          return val;
                 break;                  break;
   #ifdef PTHREAD_SA
         case PT_STATE_RUNNABLE:          case PT_STATE_RUNNABLE:
         case PT_STATE_SUSPENDED:          case PT_STATE_SUSPENDED:
         case PT_STATE_BLOCKED_QUEUE:          case PT_STATE_BLOCKED_QUEUE:
Line 470  td_thr_getregs(td_thread_t *thread, int 
Line 482  td_thr_getregs(td_thread_t *thread, int 
                 }                  }
                 break;                  break;
         case _PT_STATE_BLOCKED_SYS:          case _PT_STATE_BLOCKED_SYS:
   #endif
         case PT_STATE_ZOMBIE:          case PT_STATE_ZOMBIE:
         default:          default:
                 return TD_ERR_BADTHREAD;                  return TD_ERR_BADTHREAD;
Line 482  int
Line 495  int
 td_thr_setregs(td_thread_t *thread, int regset, void *buf)  td_thr_setregs(td_thread_t *thread, int regset, void *buf)
 {  {
         int val, tmp, tmp1;          int val, tmp, tmp1;
   #ifdef PTHREAD_SA
         caddr_t addr;          caddr_t addr;
         ucontext_t uc;          ucontext_t uc;
   #endif
   
         if ((val = READ(thread->proc,          if ((val = READ(thread->proc,
             thread->addr + offsetof(struct __pthread_st, pt_blockgen),              thread->addr + offsetof(struct __pthread_st, pt_blockgen),
Line 493  td_thr_setregs(td_thread_t *thread, int 
Line 508  td_thr_setregs(td_thread_t *thread, int 
             thread->addr + offsetof(struct __pthread_st, pt_unblockgen),              thread->addr + offsetof(struct __pthread_st, pt_unblockgen),
             &tmp1, sizeof(tmp1))) != 0)              &tmp1, sizeof(tmp1))) != 0)
                 return val;                  return val;
   #ifdef PTHREAD_SA
         if (tmp != tmp1)          if (tmp != tmp1)
                 tmp = _PT_STATE_BLOCKED_SYS;                  tmp = _PT_STATE_BLOCKED_SYS;
         else if ((val = READ(thread->proc,          else
   #endif
           if ((val = READ(thread->proc,
                       thread->addr + offsetof(struct __pthread_st, pt_state),                        thread->addr + offsetof(struct __pthread_st, pt_state),
                       &tmp, sizeof(tmp))) != 0)                        &tmp, sizeof(tmp))) != 0)
                 return val;                  return val;
Line 510  td_thr_setregs(td_thread_t *thread, int 
Line 528  td_thr_setregs(td_thread_t *thread, int 
                 if (val != 0)                  if (val != 0)
                         return val;                          return val;
                 break;                  break;
   #ifdef PTHREAD_SA
         case PT_STATE_RUNNABLE:          case PT_STATE_RUNNABLE:
         case PT_STATE_SUSPENDED:          case PT_STATE_SUSPENDED:
         case PT_STATE_BLOCKED_QUEUE:          case PT_STATE_BLOCKED_QUEUE:
Line 565  td_thr_setregs(td_thread_t *thread, int 
Line 584  td_thr_setregs(td_thread_t *thread, int 
   
                 break;                  break;
         case _PT_STATE_BLOCKED_SYS:          case _PT_STATE_BLOCKED_SYS:
   #endif
         case PT_STATE_ZOMBIE:          case PT_STATE_ZOMBIE:
         default:          default:
                 return TD_ERR_BADTHREAD;                  return TD_ERR_BADTHREAD;
Line 1087  td_thr_suspend(td_thread_t *thread)
Line 1107  td_thr_suspend(td_thread_t *thread)
         if (tmp != PT_MAGIC)          if (tmp != PT_MAGIC)
                 return TD_ERR_BADTHREAD;                  return TD_ERR_BADTHREAD;
   
   #ifdef PTHREAD_SA
         val = READ(thread->proc,          val = READ(thread->proc,
             thread->addr + offsetof(struct __pthread_st, pt_type),              thread->addr + offsetof(struct __pthread_st, pt_type),
             &tmp, sizeof(tmp));              &tmp, sizeof(tmp));
Line 1094  td_thr_suspend(td_thread_t *thread)
Line 1115  td_thr_suspend(td_thread_t *thread)
                 return val;                  return val;
         if (tmp != PT_THREAD_NORMAL)          if (tmp != PT_THREAD_NORMAL)
                 return TD_ERR_BADTHREAD;                  return TD_ERR_BADTHREAD;
   #endif
   
         /* find the thread's current state */          /* find the thread's current state */
         if ((val = READ(thread->proc,          if ((val = READ(thread->proc,
Line 1104  td_thr_suspend(td_thread_t *thread)
Line 1126  td_thr_suspend(td_thread_t *thread)
             thread->addr + offsetof(struct __pthread_st, pt_unblockgen),              thread->addr + offsetof(struct __pthread_st, pt_unblockgen),
             &tmp1, sizeof(tmp1))) != 0)              &tmp1, sizeof(tmp1))) != 0)
                 return val;                  return val;
   #ifdef PTHREAD_SA
         if (tmp != tmp1)          if (tmp != tmp1)
                 tmp = _PT_STATE_BLOCKED_SYS;                  tmp = _PT_STATE_BLOCKED_SYS;
         else if ((val = READ(thread->proc,          else
   #endif
           if ((val = READ(thread->proc,
                       thread->addr + offsetof(struct __pthread_st, pt_state),                        thread->addr + offsetof(struct __pthread_st, pt_state),
                       &tmp, sizeof(tmp))) != 0)                        &tmp, sizeof(tmp))) != 0)
                 return val;                  return val;
Line 1208  td_thr_suspend(td_thread_t *thread)
Line 1233  td_thr_suspend(td_thread_t *thread)
                 nthread->lwp = thread->lwp;                  nthread->lwp = thread->lwp;
                 thread->lwp = -1;                  thread->lwp = -1;
                 break;                  break;
   #ifdef PTHREAD_SA
         case PT_STATE_RUNNABLE:          case PT_STATE_RUNNABLE:
                 /* remove from runq */                  /* remove from runq */
                 DPTQ_REMOVE(thread->proc->runqaddr, thread->addr, pt_runq);                  DPTQ_REMOVE(thread->proc->runqaddr, thread->addr, pt_runq);
Line 1235  td_thr_suspend(td_thread_t *thread)
Line 1261  td_thr_suspend(td_thread_t *thread)
         case PT_STATE_SUSPENDED:          case PT_STATE_SUSPENDED:
                 /* don't do anything */                  /* don't do anything */
                 return 0;                  return 0;
   #endif
         case PT_STATE_ZOMBIE:          case PT_STATE_ZOMBIE:
         case PT_STATE_DEAD:          case PT_STATE_DEAD:
                 /* suspending these isn't meaningful */                  /* suspending these isn't meaningful */
Line 1244  td_thr_suspend(td_thread_t *thread)
Line 1271  td_thr_suspend(td_thread_t *thread)
         }          }
   
         DPTQ_INSERT_TAIL(thread->proc->suspqaddr, thread->addr, pt_runq);          DPTQ_INSERT_TAIL(thread->proc->suspqaddr, thread->addr, pt_runq);
   #ifdef PTHREAD_SA
         tmp = PT_STATE_SUSPENDED;          tmp = PT_STATE_SUSPENDED;
         val = WRITE(thread->proc, thread->addr +          val = WRITE(thread->proc, thread->addr +
             offsetof(struct __pthread_st, pt_state),              offsetof(struct __pthread_st, pt_state),
             &tmp, sizeof(tmp));              &tmp, sizeof(tmp));
         if (val != 0)          if (val != 0)
                 return val;                  return val;
   #endif
   
         return 0;          return 0;
 }  }
Line 1287  td_thr_resume(td_thread_t *thread)
Line 1316  td_thr_resume(td_thread_t *thread)
             thread->addr + offsetof(struct __pthread_st, pt_unblockgen),              thread->addr + offsetof(struct __pthread_st, pt_unblockgen),
             &tmp1, sizeof(tmp1))) != 0)              &tmp1, sizeof(tmp1))) != 0)
                 return val;                  return val;
   #ifdef PTHREAD_SA
         if (tmp != tmp1)          if (tmp != tmp1)
                 tmp = _PT_STATE_BLOCKED_SYS;                  tmp = _PT_STATE_BLOCKED_SYS;
         else if ((val = READ(thread->proc,          else
   #endif
           if ((val = READ(thread->proc,
                       thread->addr + offsetof(struct __pthread_st, pt_state),                        thread->addr + offsetof(struct __pthread_st, pt_state),
                       &tmp, sizeof(tmp))) != 0)                        &tmp, sizeof(tmp))) != 0)
                 return val;                  return val;
   
   #ifdef PTHREAD_SA
         if (tmp == PT_STATE_SUSPENDED) {          if (tmp == PT_STATE_SUSPENDED) {
                 DPTQ_REMOVE(thread->proc->suspqaddr, thread->addr, pt_runq);                  DPTQ_REMOVE(thread->proc->suspqaddr, thread->addr, pt_runq);
                 /* emulate pthread__sched */                  /* emulate pthread__sched */
Line 1303  td_thr_resume(td_thread_t *thread)
Line 1336  td_thr_resume(td_thread_t *thread)
                     &tmp, sizeof(tmp));                      &tmp, sizeof(tmp));
                 DPTQ_INSERT_TAIL(thread->proc->runqaddr, thread->addr, pt_runq);                  DPTQ_INSERT_TAIL(thread->proc->runqaddr, thread->addr, pt_runq);
         }          }
   #endif
   
         return 0;          return 0;
 }  }
Legend:
Removed from v.1.31  
changed lines
  Added in v.1.32
CVSweb <webmaster@jp.NetBSD.org>