server/locks.c

   1 /* nbdkit
   2  * Copyright Red Hat
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  * * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *
  11  * * Redistributions in binary form must reproduce the above copyright
  12  * notice, this list of conditions and the following disclaimer in the
  13  * documentation and/or other materials provided with the distribution.
  14  *
  15  * * Neither the name of Red Hat nor the names of its contributors may be
  16  * used to endorse or promote products derived from this software without
  17  * specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  21  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  22  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RED HAT OR
  23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  26  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  27  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  28  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  29  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 #include <config.h>
  34
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37
  38 #include "internal.h"
  39
  40 /* Note that the plugin's thread model cannot change after being
  41  * loaded, so caching it here is safe.
  42  */
  43 unsigned thread_model = -1;
  44
  45 static pthread_mutex_t connection_lock = PTHREAD_MUTEX_INITIALIZER;
  46 static pthread_mutex_t all_requests_lock = PTHREAD_MUTEX_INITIALIZER;
  47 static pthread_rwlock_t unload_prevention_lock = PTHREAD_RWLOCK_INITIALIZER;
  48
  49 /* Map thread model to string; use only from single-threaded context */
  50 const char *
  51 name_of_thread_model (int model)
  52 {
  53   static char buf[] = "-2147483648 # unknown thread model!";
  54
  55   switch (model) {
  56   case NBDKIT_THREAD_MODEL_SERIALIZE_CONNECTIONS:
  57     return "serialize_connections";
  58   case NBDKIT_THREAD_MODEL_SERIALIZE_ALL_REQUESTS:
  59     return "serialize_all_requests";
  60   case NBDKIT_THREAD_MODEL_SERIALIZE_REQUESTS:
  61     return "serialize_requests";
  62   case NBDKIT_THREAD_MODEL_PARALLEL:
  63     return "parallel";
  64   }
  65   snprintf (buf, sizeof buf, "%d # unknown thread model!", model);
  66   return buf;
  67 }
  68
  69 void
  70 lock_init_thread_model (void)
  71 {
  72   thread_model = top->thread_model (top);
  73   debug ("using thread model: %s", name_of_thread_model (thread_model));
  74   assert (thread_model <= NBDKIT_THREAD_MODEL_PARALLEL);
  75 }
  76
  77 void
  78 lock_connection (void)
  79 {
  80   if (thread_model <= NBDKIT_THREAD_MODEL_SERIALIZE_CONNECTIONS &&
  81       pthread_mutex_lock (&connection_lock))
  82     abort ();
  83 }
  84
  85 void
  86 unlock_connection (void)
  87 {
  88   if (thread_model <= NBDKIT_THREAD_MODEL_SERIALIZE_CONNECTIONS &&
  89       pthread_mutex_unlock (&connection_lock))
  90     abort ();
  91 }
  92
  93 void
  94 lock_request (void)
  95 {
  96   struct connection *conn = threadlocal_get_conn ();
  97
  98   if (thread_model <= NBDKIT_THREAD_MODEL_SERIALIZE_ALL_REQUESTS &&
  99       pthread_mutex_lock (&all_requests_lock))
 100     abort ();
 101
 102   if (conn && thread_model <= NBDKIT_THREAD_MODEL_SERIALIZE_REQUESTS &&
 103       pthread_mutex_lock (&conn->request_lock))
 104     abort ();
 105
 106   if (pthread_rwlock_rdlock (&unload_prevention_lock))
 107     abort ();
 108 }
 109
 110 void
 111 unlock_request ()
 112 {
 113   struct connection *conn = threadlocal_get_conn ();
 114
 115   if (pthread_rwlock_unlock (&unload_prevention_lock))
 116     abort ();
 117
 118   if (conn && thread_model <= NBDKIT_THREAD_MODEL_SERIALIZE_REQUESTS &&
 119       pthread_mutex_unlock (&conn->request_lock))
 120     abort ();
 121
 122   if (thread_model <= NBDKIT_THREAD_MODEL_SERIALIZE_ALL_REQUESTS &&
 123       pthread_mutex_unlock (&all_requests_lock))
 124     abort ();
 125 }
 126
 127 void
 128 lock_unload (void)
 129 {
 130   if (pthread_rwlock_wrlock (&unload_prevention_lock))
 131     abort ();
 132 }
 133
 134 void
 135 unlock_unload (void)
 136 {
 137   if (pthread_rwlock_unlock (&unload_prevention_lock))
 138     abort ();
 139 }