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.8 2005/06/20 07:31:05 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 #include <sys/thread2.h>
  48
  49 /*
  50  * lwkt_rwlock_init() (MP SAFE)
  51  *
  52  * NOTE! called from low level boot, we cannot do anything fancy.
  53  */
  54 void
  55 lwkt_rwlock_init(lwkt_rwlock_t lock)
  56 {
  57     lwkt_wait_init(&lock->rw_wait);
  58     lock->rw_owner = NULL;
  59     lock->rw_count = 0;
  60     lock->rw_requests = 0;
  61 }
  62
  63 /*
  64  * lwkt_rwlock_uninit() (MP SAFE)
  65  */
  66 void
  67 lwkt_rwlock_uninit(lwkt_rwlock_t lock)
  68 {
  69     /* empty */
  70 }
  71
  72 /*
  73  * lwkt_exlock() (MP SAFE)
  74  *
  75  * NOTE: We need to use a critical section in addition to the token to
  76  * interlock against IPI lwkt_schedule calls which may manipulate the
  77  * rw_wait structure's list.  This is because the IPI runs in the context of
  78  * the current thread and thus cannot use any token calls (if it did the
  79  * token would just share with the thread's token and not provide any
  80  * protection).  This needs a rewrite.
  81  */
  82 void
  83 lwkt_exlock(lwkt_rwlock_t lock, const char *wmesg)
  84 {
  85     lwkt_tokref ilock;
  86     int gen;
  87
  88     lwkt_gettoken(&ilock, &lock->rw_token);
  89     crit_enter();
  90     gen = lock->rw_wait.wa_gen;
  91     while (lock->rw_owner != curthread) {
  92         if (lock->rw_owner == NULL && lock->rw_count == 0) {
  93             lock->rw_owner = curthread;
  94             break;
  95         }
  96         ++lock->rw_requests;
  97         lwkt_block(&lock->rw_wait, wmesg, &gen);
  98         --lock->rw_requests;
  99     }
 100     ++lock->rw_count;
 101     lwkt_reltoken(&ilock);
 102     crit_exit();
 103 }
 104
 105 /*
 106  * lwkt_shlock() (MP SAFE)
 107  */
 108 void
 109 lwkt_shlock(lwkt_rwlock_t lock, const char *wmesg)
 110 {
 111     lwkt_tokref ilock;
 112     int gen;
 113
 114     lwkt_gettoken(&ilock, &lock->rw_token);
 115     crit_enter();
 116     gen = lock->rw_wait.wa_gen;
 117     while (lock->rw_owner != NULL) {
 118         ++lock->rw_requests;
 119         lwkt_block(&lock->rw_wait, wmesg, &gen);
 120         --lock->rw_requests;
 121     }
 122     ++lock->rw_count;
 123     lwkt_reltoken(&ilock);
 124     crit_exit();
 125 }
 126
 127 /*
 128  * lwkt_exunlock() (MP SAFE)
 129  */
 130 void
 131 lwkt_exunlock(lwkt_rwlock_t lock)
 132 {
 133     lwkt_tokref ilock;
 134
 135     lwkt_gettoken(&ilock, &lock->rw_token);
 136     crit_enter();
 137     KASSERT(lock->rw_owner != NULL, ("lwkt_exunlock: shared lock"));
 138     KASSERT(lock->rw_owner == curthread, ("lwkt_exunlock: not owner"));
 139     if (--lock->rw_count == 0) {
 140         lock->rw_owner = NULL;
 141         if (lock->rw_requests)
 142             lwkt_signal(&lock->rw_wait, 1);
 143     }
 144     lwkt_reltoken(&ilock);
 145     crit_exit();
 146 }
 147
 148 /*
 149  * lwkt_shunlock() (MP SAFE)
 150  */
 151 void
 152 lwkt_shunlock(lwkt_rwlock_t lock)
 153 {
 154     lwkt_tokref ilock;
 155
 156     lwkt_gettoken(&ilock, &lock->rw_token);
 157     crit_enter();
 158     KASSERT(lock->rw_owner == NULL, ("lwkt_shunlock: exclusive lock"));
 159     if (--lock->rw_count == 0) {
 160         if (lock->rw_requests)
 161             lwkt_signal(&lock->rw_wait, 1);
 162     }
 163     lwkt_reltoken(&ilock);
 164     crit_exit();
 165 }
 166