sys/kern/lwkt_rwlock.c

   1 /*
   2  * LWKT_RWLOCK.C (MP SAFE)
   3  *
   4  * Copyright (c) 2003,2004 The DragonFly Project.  All rights reserved.
   5  *
   6  * This code is derived from software contributed to The DragonFly Project
   7  * by Matthew Dillon <dillon@backplane.com>
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  *
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  * 3. Neither the name of The DragonFly Project nor the names of its
  20  *    contributors may be used to endorse or promote products derived
  21  *    from this software without specific, prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  26  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  27  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  28  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  29  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  30  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  31  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  32  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  33  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  * Implements simple shared/exclusive locks using LWKT.
  37  *
  38  * $DragonFly: src/sys/kern/Attic/lwkt_rwlock.c,v 1.7 2005/04/20 17:03:35 dillon Exp $
  39  */
  40
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43 #include <sys/kernel.h>
  44 #include <sys/proc.h>
  45 #include <sys/rtprio.h>
  46 #include <sys/queue.h>
  47
  48 /*
  49  * lwkt_rwlock_init() (MP SAFE)
  50  *
  51  * NOTE! called from low level boot, we cannot do anything fancy.
  52  */
  53 void
  54 lwkt_rwlock_init(lwkt_rwlock_t lock)
  55 {
  56     lwkt_wait_init(&lock->rw_wait);
  57     lock->rw_owner = NULL;
  58     lock->rw_count = 0;
  59     lock->rw_requests = 0;
  60 }
  61
  62 /*
  63  * lwkt_rwlock_uninit() (MP SAFE)
  64  */
  65 void
  66 lwkt_rwlock_uninit(lwkt_rwlock_t lock)
  67 {
  68     /* empty */
  69 }
  70
  71 /*
  72  * lwkt_exlock() (MP SAFE)
  73  */
  74 void
  75 lwkt_exlock(lwkt_rwlock_t lock, const char *wmesg)
  76 {
  77     lwkt_tokref ilock;
  78     int gen;
  79
  80     lwkt_gettoken(&ilock, &lock->rw_token);
  81     gen = lock->rw_wait.wa_gen;
  82     while (lock->rw_owner != curthread) {
  83         if (lock->rw_owner == NULL && lock->rw_count == 0) {
  84             lock->rw_owner = curthread;
  85             break;
  86         }
  87         ++lock->rw_requests;
  88         lwkt_block(&lock->rw_wait, wmesg, &gen);
  89         --lock->rw_requests;
  90     }
  91     ++lock->rw_count;
  92     lwkt_reltoken(&ilock);
  93 }
  94
  95 /*
  96  * lwkt_shlock() (MP SAFE)
  97  */
  98 void
  99 lwkt_shlock(lwkt_rwlock_t lock, const char *wmesg)
 100 {
 101     lwkt_tokref ilock;
 102     int gen;
 103
 104     lwkt_gettoken(&ilock, &lock->rw_token);
 105     gen = lock->rw_wait.wa_gen;
 106     while (lock->rw_owner != NULL) {
 107         ++lock->rw_requests;
 108         lwkt_block(&lock->rw_wait, wmesg, &gen);
 109         --lock->rw_requests;
 110     }
 111     ++lock->rw_count;
 112     lwkt_reltoken(&ilock);
 113 }
 114
 115 /*
 116  * lwkt_exunlock() (MP SAFE)
 117  */
 118 void
 119 lwkt_exunlock(lwkt_rwlock_t lock)
 120 {
 121     lwkt_tokref ilock;
 122
 123     lwkt_gettoken(&ilock, &lock->rw_token);
 124     KASSERT(lock->rw_owner != NULL, ("lwkt_exunlock: shared lock"));
 125     KASSERT(lock->rw_owner == curthread, ("lwkt_exunlock: not owner"));
 126     if (--lock->rw_count == 0) {
 127         lock->rw_owner = NULL;
 128         if (lock->rw_requests)
 129             lwkt_signal(&lock->rw_wait, 1);
 130     }
 131     lwkt_reltoken(&ilock);
 132 }
 133
 134 /*
 135  * lwkt_shunlock() (MP SAFE)
 136  */
 137 void
 138 lwkt_shunlock(lwkt_rwlock_t lock)
 139 {
 140     lwkt_tokref ilock;
 141
 142     lwkt_gettoken(&ilock, &lock->rw_token);
 143     KASSERT(lock->rw_owner == NULL, ("lwkt_shunlock: exclusive lock"));
 144     if (--lock->rw_count == 0) {
 145         if (lock->rw_requests)
 146             lwkt_signal(&lock->rw_wait, 1);
 147     }
 148     lwkt_reltoken(&ilock);
 149 }
 150