1 /* 2 This file is part of drd, a thread error detector. 3 4 Copyright (C) 2006-2013 Bart Van Assche <bvanassche (at) acm.org>. 5 6 This program is free software; you can redistribute it and/or 7 modify it under the terms of the GNU General Public License as 8 published by the Free Software Foundation; either version 2 of the 9 License, or (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 19 02111-1307, USA. 20 21 The GNU General Public License is contained in the file COPYING. 22 */ 23 24 25 #include "drd_clientobj.h" 26 #include "drd_cond.h" 27 #include "drd_error.h" 28 #include "drd_mutex.h" 29 #include "pub_tool_errormgr.h" /* VG_(maybe_record_error)() */ 30 #include "pub_tool_libcassert.h" /* tl_assert() */ 31 #include "pub_tool_libcbase.h" /* VG_(memcmp)() */ 32 #include "pub_tool_libcprint.h" /* VG_(printf)() */ 33 #include "pub_tool_machine.h" /* VG_(get_IP)() */ 34 #include "pub_tool_threadstate.h" /* VG_(get_running_tid)() */ 35 36 37 /* Local functions. */ 38 39 static void DRD_(cond_cleanup)(struct cond_info* p); 40 41 42 /* Local variables. */ 43 44 static Bool DRD_(s_report_signal_unlocked) = True; 45 static Bool DRD_(s_trace_cond); 46 47 48 /* Function definitions. */ 49 50 void DRD_(cond_set_report_signal_unlocked)(const Bool r) 51 { 52 DRD_(s_report_signal_unlocked) = r; 53 } 54 55 void DRD_(cond_set_trace)(const Bool trace_cond) 56 { 57 DRD_(s_trace_cond) = trace_cond; 58 } 59 60 static 61 void DRD_(cond_initialize)(struct cond_info* const p, const Addr cond) 62 { 63 tl_assert(cond != 0); 64 tl_assert(p->a1 == cond); 65 tl_assert(p->type == ClientCondvar); 66 67 p->cleanup = (void(*)(DrdClientobj*))(DRD_(cond_cleanup)); 68 p->delete_thread = 0; 69 p->waiter_count = 0; 70 p->mutex = 0; 71 } 72 73 /** 74 * Free the memory that was allocated by cond_initialize(). Called by 75 * DRD_(clientobj_remove)(). 76 */ 77 static void DRD_(cond_cleanup)(struct cond_info* p) 78 { 79 tl_assert(p); 80 if (p->mutex) 81 { 82 struct mutex_info* q; 83 q = &(DRD_(clientobj_get)(p->mutex, ClientMutex)->mutex); 84 { 85 CondDestrErrInfo cde = { 86 DRD_(thread_get_running_tid)(), 87 p->a1, 88 q ? q->a1 : 0, 89 q ? q->owner : DRD_INVALID_THREADID 90 }; 91 VG_(maybe_record_error)(VG_(get_running_tid)(), 92 CondDestrErr, 93 VG_(get_IP)(VG_(get_running_tid)()), 94 "Destroying condition variable that is being" 95 " waited upon", 96 &cde); 97 } 98 } 99 } 100 101 /** 102 * Report that the synchronization object at address 'addr' is of the 103 * wrong type. 104 */ 105 static void wrong_type(const Addr addr) 106 { 107 GenericErrInfo gei = { 108 .tid = DRD_(thread_get_running_tid)(), 109 .addr = addr, 110 }; 111 VG_(maybe_record_error)(VG_(get_running_tid)(), 112 GenericErr, 113 VG_(get_IP)(VG_(get_running_tid)()), 114 "wrong type of synchronization object", 115 &gei); 116 } 117 118 static struct cond_info* cond_get_or_allocate(const Addr cond) 119 { 120 struct cond_info *p; 121 122 tl_assert(offsetof(DrdClientobj, cond) == 0); 123 p = &(DRD_(clientobj_get)(cond, ClientCondvar)->cond); 124 if (p) 125 return p; 126 127 if (DRD_(clientobj_present)(cond, cond + 1)) 128 { 129 wrong_type(cond); 130 return 0; 131 } 132 133 p = &(DRD_(clientobj_add)(cond, ClientCondvar)->cond); 134 DRD_(cond_initialize)(p, cond); 135 return p; 136 } 137 138 struct cond_info* DRD_(cond_get)(const Addr cond) 139 { 140 tl_assert(offsetof(DrdClientobj, cond) == 0); 141 return &(DRD_(clientobj_get)(cond, ClientCondvar)->cond); 142 } 143 144 /** Called before pthread_cond_init(). */ 145 void DRD_(cond_pre_init)(const Addr cond) 146 { 147 struct cond_info* p; 148 149 if (DRD_(s_trace_cond)) 150 DRD_(trace_msg)("[%d] cond_init cond 0x%lx", 151 DRD_(thread_get_running_tid)(), cond); 152 153 p = DRD_(cond_get)(cond); 154 155 if (p) { 156 CondErrInfo cei = { .tid = DRD_(thread_get_running_tid)(), .cond = cond }; 157 VG_(maybe_record_error)(VG_(get_running_tid)(), 158 CondErr, 159 VG_(get_IP)(VG_(get_running_tid)()), 160 "initialized twice", 161 &cei); 162 } 163 164 cond_get_or_allocate(cond); 165 } 166 167 /** Called after pthread_cond_destroy(). */ 168 void DRD_(cond_post_destroy)(const Addr cond, const Bool destroy_succeeded) 169 { 170 struct cond_info* p; 171 172 if (DRD_(s_trace_cond)) 173 DRD_(trace_msg)("[%d] cond_destroy cond 0x%lx", 174 DRD_(thread_get_running_tid)(), cond); 175 176 p = DRD_(cond_get)(cond); 177 if (p == 0) 178 { 179 CondErrInfo cei = { .tid = DRD_(thread_get_running_tid)(), .cond = cond }; 180 VG_(maybe_record_error)(VG_(get_running_tid)(), 181 CondErr, 182 VG_(get_IP)(VG_(get_running_tid)()), 183 "not a condition variable", 184 &cei); 185 return; 186 } 187 188 if (p->waiter_count != 0) 189 { 190 CondErrInfo cei = { .tid = DRD_(thread_get_running_tid)(), .cond = cond }; 191 VG_(maybe_record_error)(VG_(get_running_tid)(), 192 CondErr, 193 VG_(get_IP)(VG_(get_running_tid)()), 194 "destruction of condition variable being waited" 195 " upon", 196 &cei); 197 } 198 199 if (destroy_succeeded) 200 DRD_(clientobj_remove)(p->a1, ClientCondvar); 201 } 202 203 /** 204 * Called before pthread_cond_wait(). Note: before this function is called, 205 * mutex_unlock() has already been called from drd_clientreq.c. 206 */ 207 void DRD_(cond_pre_wait)(const Addr cond, const Addr mutex) 208 { 209 struct cond_info* p; 210 struct mutex_info* q; 211 212 if (DRD_(s_trace_cond)) 213 DRD_(trace_msg)("[%d] cond_pre_wait cond 0x%lx", 214 DRD_(thread_get_running_tid)(), cond); 215 216 p = cond_get_or_allocate(cond); 217 if (!p) 218 { 219 CondErrInfo cei = { .tid = DRD_(thread_get_running_tid)(), .cond = cond }; 220 VG_(maybe_record_error)(VG_(get_running_tid)(), 221 CondErr, 222 VG_(get_IP)(VG_(get_running_tid)()), 223 "not a condition variable", 224 &cei); 225 return; 226 } 227 228 if (p->waiter_count == 0) 229 { 230 p->mutex = mutex; 231 } 232 else if (p->mutex != mutex) 233 { 234 CondWaitErrInfo cwei 235 = { .tid = DRD_(thread_get_running_tid)(), 236 .cond = cond, .mutex1 = p->mutex, .mutex2 = mutex }; 237 VG_(maybe_record_error)(VG_(get_running_tid)(), 238 CondWaitErr, 239 VG_(get_IP)(VG_(get_running_tid)()), 240 "Inconsistent association of condition variable" 241 " and mutex", 242 &cwei); 243 } 244 tl_assert(p->mutex); 245 q = DRD_(mutex_get)(p->mutex); 246 if (q 247 && q->owner == DRD_(thread_get_running_tid)() && q->recursion_count > 0) 248 { 249 const ThreadId vg_tid = VG_(get_running_tid)(); 250 MutexErrInfo MEI = { DRD_(thread_get_running_tid)(), 251 q->a1, q->recursion_count, q->owner }; 252 VG_(maybe_record_error)(vg_tid, 253 MutexErr, 254 VG_(get_IP)(vg_tid), 255 "Mutex locked recursively", 256 &MEI); 257 } 258 else if (q == 0) 259 { 260 DRD_(not_a_mutex)(p->mutex); 261 } 262 263 ++p->waiter_count; 264 } 265 266 /** 267 * Called after pthread_cond_wait(). 268 */ 269 void DRD_(cond_post_wait)(const Addr cond) 270 { 271 struct cond_info* p; 272 273 if (DRD_(s_trace_cond)) 274 DRD_(trace_msg)("[%d] cond_post_wait cond 0x%lx", 275 DRD_(thread_get_running_tid)(), cond); 276 277 p = DRD_(cond_get)(cond); 278 if (!p) 279 { 280 CondDestrErrInfo cde = { 281 DRD_(thread_get_running_tid)(), cond, 0, DRD_INVALID_THREADID 282 }; 283 VG_(maybe_record_error)(VG_(get_running_tid)(), 284 CondDestrErr, 285 VG_(get_IP)(VG_(get_running_tid)()), 286 "condition variable has been destroyed while" 287 " being waited upon", 288 &cde); 289 return; 290 } 291 292 if (p->waiter_count > 0) 293 { 294 --p->waiter_count; 295 if (p->waiter_count == 0) 296 { 297 p->mutex = 0; 298 } 299 } 300 } 301 302 static void cond_signal(const DrdThreadId tid, struct cond_info* const cond_p) 303 { 304 const ThreadId vg_tid = VG_(get_running_tid)(); 305 const DrdThreadId drd_tid = DRD_(VgThreadIdToDrdThreadId)(vg_tid); 306 307 tl_assert(cond_p); 308 309 if (cond_p->waiter_count > 0) 310 { 311 if (DRD_(s_report_signal_unlocked) 312 && ! DRD_(mutex_is_locked_by)(cond_p->mutex, drd_tid)) 313 { 314 /* 315 * A signal is sent while the associated mutex has not been locked. 316 * This can indicate but is not necessarily a race condition. 317 */ 318 CondRaceErrInfo cei = { .tid = DRD_(thread_get_running_tid)(), 319 .cond = cond_p->a1, 320 .mutex = cond_p->mutex, 321 }; 322 VG_(maybe_record_error)(vg_tid, 323 CondRaceErr, 324 VG_(get_IP)(vg_tid), 325 "CondErr", 326 &cei); 327 } 328 } 329 else 330 { 331 /* 332 * No other thread is waiting for the signal, hence the signal will 333 * be lost. This is normal in a POSIX threads application. 334 */ 335 } 336 } 337 338 static void not_initialized(Addr const cond) 339 { 340 CondErrInfo cei = { .tid = DRD_(thread_get_running_tid)(), .cond = cond }; 341 VG_(maybe_record_error)(VG_(get_running_tid)(), 342 CondErr, 343 VG_(get_IP)(VG_(get_running_tid)()), 344 "condition variable has not been initialized", 345 &cei); 346 } 347 348 /** Called before pthread_cond_signal(). */ 349 void DRD_(cond_pre_signal)(Addr const cond) 350 { 351 struct cond_info* p; 352 353 p = DRD_(cond_get)(cond); 354 if (DRD_(s_trace_cond)) 355 DRD_(trace_msg)("[%d] cond_signal cond 0x%lx", 356 DRD_(thread_get_running_tid)(), cond); 357 358 tl_assert(DRD_(pthread_cond_initializer)); 359 if (!p && VG_(memcmp)((void*)cond, (void*)DRD_(pthread_cond_initializer), 360 DRD_(pthread_cond_initializer_size)) != 0) 361 { 362 not_initialized(cond); 363 return; 364 } 365 366 if (!p) 367 p = cond_get_or_allocate(cond); 368 369 cond_signal(DRD_(thread_get_running_tid)(), p); 370 } 371 372 /** Called before pthread_cond_broadcast(). */ 373 void DRD_(cond_pre_broadcast)(Addr const cond) 374 { 375 struct cond_info* p; 376 377 if (DRD_(s_trace_cond)) 378 DRD_(trace_msg)("[%d] cond_broadcast cond 0x%lx", 379 DRD_(thread_get_running_tid)(), cond); 380 381 p = DRD_(cond_get)(cond); 382 tl_assert(DRD_(pthread_cond_initializer)); 383 if (!p && VG_(memcmp)((void*)cond, (void*)DRD_(pthread_cond_initializer), 384 DRD_(pthread_cond_initializer_size)) != 0) 385 { 386 not_initialized(cond); 387 return; 388 } 389 390 if (!p) 391 p = cond_get_or_allocate(cond); 392 393 cond_signal(DRD_(thread_get_running_tid)(), p); 394 } 395
