sys/kern/lwkt_rwlock.c

   1 /*
   2  * LWKT_RWLOCK.C (MP SAFE)
   3  *
   4  * Copyright (c) 2003-2006 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.11 2006/05/21 20:23:25 dillon Exp $
  39  */
  40
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43 #include <sys/kernel.h>
  44 #include <sys/spinlock.h>
  45 #include <sys/proc.h>
  46 #include <sys/rtprio.h>
  47 #include <sys/queue.h>
  48 #include <sys/thread2.h>
  49 #include <sys/spinlock2.h>
  50
  51 /*
  52  * lwkt_rwlock_init() (MP SAFE)
  53  *
  54  * NOTE! called from low level boot, we cannot do anything fancy.
  55  */
  56 void
  57 lwkt_rwlock_init(lwkt_rwlock_t lock)
  58 {
  59     lwkt_wait_init(&lock->rw_wait);
  60     lock->rw_owner = NULL;
  61     lock->rw_count = 0;
  62     lock->rw_requests = 0;
  63 }
  64
  65 /*
  66  * lwkt_rwlock_uninit() (MP SAFE)
  67  */
  68 void
  69 lwkt_rwlock_uninit(lwkt_rwlock_t lock)
  70 {
  71     /* empty */
  72 }
  73
  74 /*
  75  * lwkt_exlock() (MP SAFE)
  76  *
  77  * NOTE: We need to use a critical section in addition to the token to
  78  * interlock against IPI lwkt_schedule calls which may manipulate the
  79  * rw_wait structure's list.  This is because the IPI runs in the context of
  80  * the current thread and thus cannot use any token calls (if it did the
  81  * token would just share with the thread's token and not provide any
  82  * protection).  This needs a rewrite.
  83  */
  84 void
  85 lwkt_exlock(lwkt_rwlock_t lock, const char *wmesg)
  86 {
  87     int gen;
  88
  89     spin_lock_wr(&lock->rw_spinlock);
  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         spin_unlock_wr(&lock->rw_spinlock);
  98         lwkt_block(&lock->rw_wait, wmesg, &gen);
  99         spin_lock_wr(&lock->rw_spinlock);
 100         --lock->rw_requests;
 101     }
 102     ++lock->rw_count;
 103     spin_unlock_wr(&lock->rw_spinlock);
 104 }
 105
 106 /*
 107  * lwkt_shlock() (MP SAFE)
 108  */
 109 void
 110 lwkt_shlock(lwkt_rwlock_t lock, const char *wmesg)
 111 {
 112     int gen;
 113
 114     spin_lock_wr(&lock->rw_spinlock);
 115     gen = lock->rw_wait.wa_gen;
 116     while (lock->rw_owner != NULL) {
 117         ++lock->rw_requests;
 118         spin_unlock_wr(&lock->rw_spinlock);
 119         lwkt_block(&lock->rw_wait, wmesg, &gen);
 120         spin_lock_wr(&lock->rw_spinlock);
 121         --lock->rw_requests;
 122     }
 123     ++lock->rw_count;
 124     spin_unlock_wr(&lock->rw_spinlock);
 125 }
 126
 127 /*
 128  * lwkt_exunlock() (MP SAFE)
 129  */
 130 void
 131 lwkt_exunlock(lwkt_rwlock_t lock)
 132 {
 133     KASSERT(lock->rw_owner != NULL, ("lwkt_exunlock: shared lock"));
 134     KASSERT(lock->rw_owner == curthread, ("lwkt_exunlock: not owner"));
 135     spin_lock_wr(&lock->rw_spinlock);
 136     if (--lock->rw_count == 0) {
 137         lock->rw_owner = NULL;
 138         if (lock->rw_requests) {
 139             spin_unlock_wr(&lock->rw_spinlock);
 140             lwkt_signal(&lock->rw_wait, 1);
 141             return;
 142         }
 143     }
 144     spin_unlock_wr(&lock->rw_spinlock);
 145 }
 146
 147 /*
 148  * lwkt_shunlock() (MP SAFE)
 149  */
 150 void
 151 lwkt_shunlock(lwkt_rwlock_t lock)
 152 {
 153     KASSERT(lock->rw_owner == NULL, ("lwkt_shunlock: exclusive lock"));
 154     spin_lock_wr(&lock->rw_spinlock);
 155     if (--lock->rw_count == 0) {
 156         if (lock->rw_requests) {
 157             spin_unlock_wr(&lock->rw_spinlock);
 158             lwkt_signal(&lock->rw_wait, 1);
 159             return;
 160         }
 161     }
 162     spin_unlock_wr(&lock->rw_spinlock);
 163 }
 164