[BACK]Return to kern_mutex.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / kern

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

Diff for /src/sys/kern/kern_mutex.c between version 1.22 and 1.23

version 1.22, 2007/11/07 00:23:22 version 1.23, 2007/11/21 10:19:10
Line 78  __KERNEL_RCSID(0, "$NetBSD$");
Line 78  __KERNEL_RCSID(0, "$NetBSD$");
  */   */
   
 #define MUTEX_WANTLOCK(mtx)                                     \  #define MUTEX_WANTLOCK(mtx)                                     \
     LOCKDEBUG_WANTLOCK(MUTEX_GETID(mtx),                        \      LOCKDEBUG_WANTLOCK(MUTEX_DEBUG_P(mtx), (mtx),               \
         (uintptr_t)__builtin_return_address(0), 0)          (uintptr_t)__builtin_return_address(0), 0)
 #define MUTEX_LOCKED(mtx)                                       \  #define MUTEX_LOCKED(mtx)                                       \
     LOCKDEBUG_LOCKED(MUTEX_GETID(mtx),                          \      LOCKDEBUG_LOCKED(MUTEX_DEBUG_P(mtx), (mtx),                 \
         (uintptr_t)__builtin_return_address(0), 0)          (uintptr_t)__builtin_return_address(0), 0)
 #define MUTEX_UNLOCKED(mtx)                                     \  #define MUTEX_UNLOCKED(mtx)                                     \
     LOCKDEBUG_UNLOCKED(MUTEX_GETID(mtx),                        \      LOCKDEBUG_UNLOCKED(MUTEX_DEBUG_P(mtx), (mtx),               \
         (uintptr_t)__builtin_return_address(0), 0)          (uintptr_t)__builtin_return_address(0), 0)
 #define MUTEX_ABORT(mtx, msg)                                   \  #define MUTEX_ABORT(mtx, msg)                                   \
     mutex_abort(mtx, __func__, msg)      mutex_abort(mtx, __func__, msg)
Line 154  do {         \
Line 154  do {         \
   
 #define MUTEX_OWNER(owner)                                              \  #define MUTEX_OWNER(owner)                                              \
         (owner & MUTEX_THREAD)          (owner & MUTEX_THREAD)
 #define MUTEX_OWNED(owner)                                              \  
         (owner != 0)  
 #define MUTEX_HAS_WAITERS(mtx)                                          \  #define MUTEX_HAS_WAITERS(mtx)                                          \
         (((int)(mtx)->mtx_owner & MUTEX_BIT_WAITERS) != 0)          (((int)(mtx)->mtx_owner & MUTEX_BIT_WAITERS) != 0)
   
 #define MUTEX_INITIALIZE_ADAPTIVE(mtx, id)                              \  #define MUTEX_INITIALIZE_ADAPTIVE(mtx, dodebug)                         \
 do {                                                                    \  do {                                                                    \
         (mtx)->mtx_id = (id);                                           \          if (dodebug)                                                    \
                   (mtx)->mtx_owner |= MUTEX_BIT_DEBUG;                    \
 } while (/* CONSTCOND */ 0);  } while (/* CONSTCOND */ 0);
   
 #define MUTEX_INITIALIZE_SPIN(mtx, id, ipl)                             \  #define MUTEX_INITIALIZE_SPIN(mtx, dodebug, ipl)                        \
 do {                                                                    \  do {                                                                    \
         (mtx)->mtx_owner = MUTEX_BIT_SPIN;                              \          (mtx)->mtx_owner = MUTEX_BIT_SPIN;                              \
           if (dodebug)                                                    \
                   (mtx)->mtx_owner |= MUTEX_BIT_DEBUG;                    \
         (mtx)->mtx_ipl = makeiplcookie((ipl));                          \          (mtx)->mtx_ipl = makeiplcookie((ipl));                          \
         (mtx)->mtx_id = (id);                                           \  
         __cpu_simple_lock_init(&(mtx)->mtx_lock);                       \          __cpu_simple_lock_init(&(mtx)->mtx_lock);                       \
 } while (/* CONSTCOND */ 0)  } while (/* CONSTCOND */ 0)
   
 #define MUTEX_DESTROY(mtx)                                              \  #define MUTEX_DESTROY(mtx)                                              \
 do {                                                                    \  do {                                                                    \
         (mtx)->mtx_owner = MUTEX_THREAD;                                \          (mtx)->mtx_owner = MUTEX_THREAD;                                \
         (mtx)->mtx_id = -1;                                             \  
 } while (/* CONSTCOND */ 0);  } while (/* CONSTCOND */ 0);
   
 #define MUTEX_SPIN_P(mtx)               \  #define MUTEX_SPIN_P(mtx)               \
Line 183  do {         \
Line 182  do {         \
 #define MUTEX_ADAPTIVE_P(mtx)           \  #define MUTEX_ADAPTIVE_P(mtx)           \
     (((mtx)->mtx_owner & MUTEX_BIT_SPIN) == 0)      (((mtx)->mtx_owner & MUTEX_BIT_SPIN) == 0)
   
 #define MUTEX_GETID(mtx)                ((mtx)->mtx_id)  #define MUTEX_DEBUG_P(mtx)      (((mtx)->mtx_owner & MUTEX_BIT_DEBUG) != 0)
   #if defined(LOCKDEBUG)
   #define MUTEX_OWNED(owner)              (((owner) & ~MUTEX_BIT_DEBUG) != 0)
   #define MUTEX_INHERITDEBUG(new, old)    (new) |= (old) & MUTEX_BIT_DEBUG
   #else /* defined(LOCKDEBUG) */
   #define MUTEX_OWNED(owner)              ((owner) != 0)
   #define MUTEX_INHERITDEBUG(new, old)    /* nothing */
   #endif /* defined(LOCKDEBUG) */
   
 static inline int  static inline int
 MUTEX_ACQUIRE(kmutex_t *mtx, uintptr_t curthread)  MUTEX_ACQUIRE(kmutex_t *mtx, uintptr_t curthread)
 {  {
         int rv;          int rv;
         rv = MUTEX_CAS(&mtx->mtx_owner, 0UL, curthread);          uintptr_t old = 0;
           uintptr_t new = curthread;
   
           MUTEX_INHERITDEBUG(old, mtx->mtx_owner);
           MUTEX_INHERITDEBUG(new, old);
           rv = MUTEX_CAS(&mtx->mtx_owner, old, new);
         MUTEX_RECEIVE(mtx);          MUTEX_RECEIVE(mtx);
         return rv;          return rv;
 }  }
Line 206  MUTEX_SET_WAITERS(kmutex_t *mtx, uintptr
Line 217  MUTEX_SET_WAITERS(kmutex_t *mtx, uintptr
 static inline void  static inline void
 MUTEX_RELEASE(kmutex_t *mtx)  MUTEX_RELEASE(kmutex_t *mtx)
 {  {
           uintptr_t new;
   
         MUTEX_GIVE(mtx);          MUTEX_GIVE(mtx);
         mtx->mtx_owner = 0;          new = 0;
           MUTEX_INHERITDEBUG(new, mtx->mtx_owner);
           mtx->mtx_owner = new;
 }  }
   
 static inline void  static inline void
Line 291  void
Line 306  void
 mutex_abort(kmutex_t *mtx, const char *func, const char *msg)  mutex_abort(kmutex_t *mtx, const char *func, const char *msg)
 {  {
   
         LOCKDEBUG_ABORT(MUTEX_GETID(mtx), mtx, (MUTEX_SPIN_P(mtx) ?          LOCKDEBUG_ABORT(mtx, (MUTEX_SPIN_P(mtx) ?
             &mutex_spin_lockops : &mutex_adaptive_lockops), func, msg);              &mutex_spin_lockops : &mutex_adaptive_lockops), func, msg);
         /* NOTREACHED */          /* NOTREACHED */
 }  }
Line 308  mutex_abort(kmutex_t *mtx, const char *f
Line 323  mutex_abort(kmutex_t *mtx, const char *f
 void  void
 mutex_init(kmutex_t *mtx, kmutex_type_t type, int ipl)  mutex_init(kmutex_t *mtx, kmutex_type_t type, int ipl)
 {  {
         u_int id;          bool dodebug;
   
         memset(mtx, 0, sizeof(*mtx));          memset(mtx, 0, sizeof(*mtx));
   
Line 333  mutex_init(kmutex_t *mtx, kmutex_type_t 
Line 348  mutex_init(kmutex_t *mtx, kmutex_type_t 
   
         switch (type) {          switch (type) {
         case MUTEX_NODEBUG:          case MUTEX_NODEBUG:
                 id = LOCKDEBUG_ALLOC(mtx, NULL,                  dodebug = LOCKDEBUG_ALLOC(mtx, NULL,
                     (uintptr_t)__builtin_return_address(0));                      (uintptr_t)__builtin_return_address(0));
                 MUTEX_INITIALIZE_SPIN(mtx, id, ipl);                  MUTEX_INITIALIZE_SPIN(mtx, dodebug, ipl);
                 break;                  break;
         case MUTEX_ADAPTIVE:          case MUTEX_ADAPTIVE:
                 id = LOCKDEBUG_ALLOC(mtx, &mutex_adaptive_lockops,                  dodebug = LOCKDEBUG_ALLOC(mtx, &mutex_adaptive_lockops,
                     (uintptr_t)__builtin_return_address(0));                      (uintptr_t)__builtin_return_address(0));
                 MUTEX_INITIALIZE_ADAPTIVE(mtx, id);                  MUTEX_INITIALIZE_ADAPTIVE(mtx, dodebug);
                 break;                  break;
         case MUTEX_SPIN:          case MUTEX_SPIN:
                 id = LOCKDEBUG_ALLOC(mtx, &mutex_spin_lockops,                  dodebug = LOCKDEBUG_ALLOC(mtx, &mutex_spin_lockops,
                     (uintptr_t)__builtin_return_address(0));                      (uintptr_t)__builtin_return_address(0));
                 MUTEX_INITIALIZE_SPIN(mtx, id, ipl);                  MUTEX_INITIALIZE_SPIN(mtx, dodebug, ipl);
                 break;                  break;
         default:          default:
                 panic("mutex_init: impossible type");                  panic("mutex_init: impossible type");
Line 369  mutex_destroy(kmutex_t *mtx)
Line 384  mutex_destroy(kmutex_t *mtx)
                 MUTEX_ASSERT(mtx, !__SIMPLELOCK_LOCKED_P(&mtx->mtx_lock));                  MUTEX_ASSERT(mtx, !__SIMPLELOCK_LOCKED_P(&mtx->mtx_lock));
         }          }
   
         LOCKDEBUG_FREE(mtx, MUTEX_GETID(mtx));          LOCKDEBUG_FREE(MUTEX_DEBUG_P(mtx), mtx);
         MUTEX_DESTROY(mtx);          MUTEX_DESTROY(mtx);
 }  }
   

Legend:
Removed from v.1.22  
changed lines
  Added in v.1.23

CVSweb <webmaster@jp.NetBSD.org>