1 /* nbdkit
2 * Copyright (C) 2013-2020 Red Hat Inc.
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 *
name_of_thread_model(int model)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
lock_init_thread_model(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
lock_connection(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
unlock_connection(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
lock_request(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
unlock_request()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
lock_unload(void)128 lock_unload (void)
129 {
130 if (pthread_rwlock_wrlock (&unload_prevention_lock))
131 abort ();
132 }
133
134 void
unlock_unload(void)135 unlock_unload (void)
136 {
137 if (pthread_rwlock_unlock (&unload_prevention_lock))
138 abort ();
139 }
140