[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.30 and 1.31

version 1.30, 2008/01/05 12:31:39 version 1.31, 2008/03/27 19:11:05
Line 62  __KERNEL_RCSID(0, "$NetBSD$");
Line 62  __KERNEL_RCSID(0, "$NetBSD$");
 #include <sys/atomic.h>  #include <sys/atomic.h>
 #include <sys/intr.h>  #include <sys/intr.h>
 #include <sys/lock.h>  #include <sys/lock.h>
   #include <sys/pool.h>
   
 #include <dev/lockstat.h>  #include <dev/lockstat.h>
   
Line 278  syncobj_t mutex_syncobj = {
Line 279  syncobj_t mutex_syncobj = {
         (void *)mutex_owner,          (void *)mutex_owner,
 };  };
   
   /* Mutex cache */
   #define MUTEX_OBJ_MAGIC 0x5aa3c85d
   struct kmutexobj {
           kmutex_t        mo_lock;
           void            *mo_chain;
           u_int           mo_magic;
           u_int           mo_refcnt;
   };
   
   static int      mutex_obj_ctor(void *, void *, int);
   
   static pool_cache_t     mutex_obj_cache;
   
 /*  /*
  * mutex_dump:   * mutex_dump:
  *   *
Line 911  mutex_spin_retry(kmutex_t *mtx)
Line 925  mutex_spin_retry(kmutex_t *mtx)
 #endif  /* MULTIPROCESSOR */  #endif  /* MULTIPROCESSOR */
 }  }
 #endif  /* defined(__HAVE_SPIN_MUTEX_STUBS) || defined(FULL) */  #endif  /* defined(__HAVE_SPIN_MUTEX_STUBS) || defined(FULL) */
   
   /*
    * mutex_obj_init:
    *
    *      Initialize the mutex object store.
    */
   void
   mutex_obj_init(void)
   {
   
           mutex_obj_cache = pool_cache_init(sizeof(struct kmutexobj),
               coherency_unit, 0, 0, "mutex", NULL, IPL_NONE, mutex_obj_ctor,
               NULL, NULL);
   }
   
   /*
    * mutex_obj_ctor:
    *
    *      Initialize a new lock for the cache.
    */
   static int
   mutex_obj_ctor(void *arg, void *obj, int flags)
   {
           struct kmutexobj * mo = obj;
   
           mo->mo_magic = MUTEX_OBJ_MAGIC;
           mo->mo_chain = NULL;
   
           return 0;
   }
   
   /*
    * mutex_obj_alloc:
    *
    *      Allocate a single lock object.
    */
   kmutex_t *
   mutex_obj_alloc(kmutex_type_t type, int ipl)
   {
           struct kmutexobj *mo;
   
           mo = pool_cache_get(mutex_obj_cache, PR_WAITOK);
           mutex_init(&mo->mo_lock, type, ipl);
           mo->mo_refcnt = 1;
   
           return (kmutex_t *)mo;
   }
   
   /*
    * mutex_obj_hold:
    *
    *      Add a single reference to a lock object.  A reference to the object
    *      must already be held, and must be held across this call.
    */
   void
   mutex_obj_hold(kmutex_t *lock)
   {
           struct kmutexobj *mo = (struct kmutexobj *)lock;
   
           KASSERT(mo->mo_magic == MUTEX_OBJ_MAGIC);
           KASSERT(mo->mo_refcnt > 0);
   
           atomic_inc_uint(&mo->mo_refcnt);
   }
   
   /*
    * mutex_obj_free:
    *
    *      Drop a reference from a lock object.  If the last reference is being
    *      dropped, free the object and return true.  Otherwise, return false.
    */
   bool
   mutex_obj_free(kmutex_t *lock)
   {
           struct kmutexobj *mo = (struct kmutexobj *)lock;
   
           KASSERT(mo->mo_magic == MUTEX_OBJ_MAGIC);
           KASSERT(mo->mo_refcnt > 0);
           KASSERT(mo->mo_chain == NULL);
   
           if (atomic_dec_uint_nv(&mo->mo_refcnt) > 0) {
                   return false;
           }
           mutex_destroy(&mo->mo_lock);
           pool_cache_put(mutex_obj_cache, mo);
           return true;
   }

Legend:
Removed from v.1.30  
changed lines
  Added in v.1.31

CVSweb <webmaster@jp.NetBSD.org>