clang/test/Analysis/pthreadlock.c

   1 // RUN: %clang_analyze_cc1 -analyzer-checker=alpha.unix.PthreadLock -verify %s
   2
   3 // Tests performing normal locking patterns and wrong locking orders
   4
   5 #include "Inputs/system-header-simulator-for-pthread-lock.h"
   6
   7 pthread_mutex_t mtx1, mtx2;
   8 pthread_mutex_t *pmtx;
   9 lck_mtx_t lck1, lck2;
  10 lck_grp_t grp1;
  11 lck_rw_t rw;
  12
  13 #define NULL 0
  14
  15 void
  16 ok1(void)
  17 {
  18         pthread_mutex_lock(&mtx1); // no-warning
  19 }
  20
  21 void
  22 ok2(void)
  23 {
  24         pthread_mutex_unlock(&mtx1); // no-warning
  25 }
  26
  27 void
  28 ok3(void)
  29 {
  30         pthread_mutex_lock(&mtx1);      // no-warning
  31         pthread_mutex_unlock(&mtx1);    // no-warning
  32         pthread_mutex_lock(&mtx1);      // no-warning
  33         pthread_mutex_unlock(&mtx1);    // no-warning
  34 }
  35
  36 void
  37 ok4(void)
  38 {
  39         pthread_mutex_lock(&mtx1);      // no-warning
  40         pthread_mutex_unlock(&mtx1);    // no-warning
  41         pthread_mutex_lock(&mtx2);      // no-warning
  42         pthread_mutex_unlock(&mtx2);    // no-warning
  43 }
  44
  45 void
  46 ok5(void)
  47 {
  48         if (pthread_mutex_trylock(&mtx1) == 0)  // no-warning
  49                 pthread_mutex_unlock(&mtx1);    // no-warning
  50 }
  51
  52 void
  53 ok6(void)
  54 {
  55         lck_mtx_lock(&lck1);            // no-warning
  56 }
  57
  58 void
  59 ok7(void)
  60 {
  61         if (lck_mtx_try_lock(&lck1) != 0)       // no-warning
  62                 lck_mtx_unlock(&lck1);          // no-warning
  63 }
  64
  65 void
  66 ok8(void)
  67 {
  68         pthread_mutex_lock(&mtx1);      // no-warning
  69         pthread_mutex_lock(&mtx2);      // no-warning
  70         pthread_mutex_unlock(&mtx2);    // no-warning
  71         pthread_mutex_unlock(&mtx1);    // no-warning
  72 }
  73
  74 void
  75 ok9(void)
  76 {
  77         pthread_mutex_unlock(&mtx1);            // no-warning
  78         if (pthread_mutex_trylock(&mtx1) == 0)  // no-warning
  79                 pthread_mutex_unlock(&mtx1);    // no-warning
  80 }
  81
  82 void
  83 ok10(void)
  84 {
  85         if (pthread_mutex_trylock(&mtx1) != 0)  // no-warning
  86                 pthread_mutex_lock(&mtx1);      // no-warning
  87         pthread_mutex_unlock(&mtx1);            // no-warning
  88 }
  89
  90 void
  91 ok11(void)
  92 {
  93         pthread_mutex_destroy(&mtx1);   // no-warning
  94 }
  95
  96 void
  97 ok12(void)
  98 {
  99         pthread_mutex_destroy(&mtx1);   // no-warning
 100         pthread_mutex_destroy(&mtx2);   // no-warning
 101 }
 102
 103 void
 104 ok13(void)
 105 {
 106         pthread_mutex_unlock(&mtx1);    // no-warning
 107         pthread_mutex_destroy(&mtx1);   // no-warning
 108 }
 109
 110 void
 111 ok14(void)
 112 {
 113         pthread_mutex_unlock(&mtx1);    // no-warning
 114         pthread_mutex_destroy(&mtx1);   // no-warning
 115         pthread_mutex_unlock(&mtx2);    // no-warning
 116         pthread_mutex_destroy(&mtx2);   // no-warning
 117 }
 118
 119 void
 120 ok15(void)
 121 {
 122         pthread_mutex_lock(&mtx1);      // no-warning
 123         pthread_mutex_unlock(&mtx1);    // no-warning
 124         pthread_mutex_destroy(&mtx1);   // no-warning
 125 }
 126
 127 void
 128 ok16(void)
 129 {
 130         pthread_mutex_init(&mtx1, NULL);        // no-warning
 131 }
 132
 133 void
 134 ok17(void)
 135 {
 136         pthread_mutex_init(&mtx1, NULL);        // no-warning
 137         pthread_mutex_init(&mtx2, NULL);        // no-warning
 138 }
 139
 140 void
 141 ok18(void)
 142 {
 143         pthread_mutex_destroy(&mtx1);           // no-warning
 144         pthread_mutex_init(&mtx1, NULL);        // no-warning
 145 }
 146
 147 void
 148 ok19(void)
 149 {
 150         pthread_mutex_destroy(&mtx1);           // no-warning
 151         pthread_mutex_init(&mtx1, NULL);        // no-warning
 152         pthread_mutex_destroy(&mtx2);           // no-warning
 153         pthread_mutex_init(&mtx2, NULL);        // no-warning
 154 }
 155
 156 void
 157 ok20(void)
 158 {
 159         pthread_mutex_unlock(&mtx1);            // no-warning
 160         pthread_mutex_destroy(&mtx1);           // no-warning
 161         pthread_mutex_init(&mtx1, NULL);        // no-warning
 162         pthread_mutex_destroy(&mtx1);           // no-warning
 163         pthread_mutex_init(&mtx1, NULL);        // no-warning
 164 }
 165
 166 void
 167 ok21(void) {
 168   pthread_mutex_lock(pmtx);    // no-warning
 169   pthread_mutex_unlock(pmtx);  // no-warning
 170 }
 171
 172 void
 173 ok22(void) {
 174   pthread_mutex_lock(pmtx);    // no-warning
 175   pthread_mutex_unlock(pmtx);  // no-warning
 176   pthread_mutex_lock(pmtx);    // no-warning
 177   pthread_mutex_unlock(pmtx);  // no-warning
 178 }
 179
 180 void ok23(void) {
 181   if (pthread_mutex_destroy(&mtx1) != 0) // no-warning
 182     pthread_mutex_destroy(&mtx1);        // no-warning
 183 }
 184
 185 void ok24(void) {
 186   if (pthread_mutex_destroy(&mtx1) != 0) // no-warning
 187     pthread_mutex_lock(&mtx1);           // no-warning
 188 }
 189
 190 void ok25(void) {
 191   if (pthread_mutex_destroy(&mtx1) != 0) // no-warning
 192     pthread_mutex_unlock(&mtx1);         // no-warning
 193 }
 194
 195 void ok26(void) {
 196   pthread_mutex_unlock(&mtx1);           // no-warning
 197   if (pthread_mutex_destroy(&mtx1) != 0) // no-warning
 198     pthread_mutex_lock(&mtx1);           // no-warning
 199 }
 200
 201 void ok27(void) {
 202   pthread_mutex_unlock(&mtx1);           // no-warning
 203   if (pthread_mutex_destroy(&mtx1) != 0) // no-warning
 204     pthread_mutex_lock(&mtx1);           // no-warning
 205   else
 206     pthread_mutex_init(&mtx1, NULL); // no-warning
 207 }
 208
 209 void ok28(void) {
 210   if (pthread_mutex_destroy(&mtx1) != 0) { // no-warning
 211     pthread_mutex_lock(&mtx1);             // no-warning
 212     pthread_mutex_unlock(&mtx1);           // no-warning
 213     pthread_mutex_destroy(&mtx1);          // no-warning
 214   }
 215 }
 216
 217 void ok29(void) {
 218   lck_rw_lock_shared(&rw);
 219   lck_rw_unlock_shared(&rw);
 220   lck_rw_lock_exclusive(&rw); // no-warning
 221   lck_rw_unlock_exclusive(&rw); // no-warning
 222 }
 223
 224 void escape_mutex(pthread_mutex_t *m);
 225 void ok30(void) {
 226   pthread_mutex_t local_mtx;
 227   pthread_mutex_init(&local_mtx, NULL);
 228   pthread_mutex_lock(&local_mtx);
 229   escape_mutex(&local_mtx);
 230   pthread_mutex_lock(&local_mtx); // no-warning
 231   pthread_mutex_unlock(&local_mtx);
 232   pthread_mutex_destroy(&local_mtx);
 233 }
 234
 235 void ok31(void) {
 236   pthread_mutex_t local_mtx;
 237   pthread_mutex_init(&local_mtx, NULL);
 238   pthread_mutex_lock(&local_mtx);
 239   fake_system_function_that_takes_a_mutex(&local_mtx);
 240   pthread_mutex_lock(&local_mtx); // no-warning
 241   pthread_mutex_unlock(&local_mtx);
 242   pthread_mutex_destroy(&local_mtx);
 243 }
 244
 245 void
 246 bad1(void)
 247 {
 248         pthread_mutex_lock(&mtx1);      // no-warning
 249         pthread_mutex_lock(&mtx1);      // expected-warning{{This lock has already been acquired}}
 250 }
 251
 252 void
 253 bad2(void)
 254 {
 255         pthread_mutex_lock(&mtx1);      // no-warning
 256         pthread_mutex_unlock(&mtx1);    // no-warning
 257         pthread_mutex_lock(&mtx1);      // no-warning
 258         pthread_mutex_lock(&mtx1);      // expected-warning{{This lock has already been acquired}}
 259 }
 260
 261 void
 262 bad3(void)
 263 {
 264         pthread_mutex_lock(&mtx1);      // no-warning
 265         pthread_mutex_lock(&mtx2);      // no-warning
 266         pthread_mutex_unlock(&mtx1);    // expected-warning{{This was not the most recently acquired lock}}
 267         pthread_mutex_unlock(&mtx2);
 268 }
 269
 270 void
 271 bad4(void)
 272 {
 273         if (pthread_mutex_trylock(&mtx1)) // no-warning
 274                 return;
 275         pthread_mutex_lock(&mtx2);      // no-warning
 276         pthread_mutex_unlock(&mtx1);    // expected-warning{{This was not the most recently acquired lock}}
 277 }
 278
 279 void
 280 bad5(void)
 281 {
 282         lck_mtx_lock(&lck1);    // no-warning
 283         lck_mtx_lock(&lck1);    // expected-warning{{This lock has already been acquired}}
 284 }
 285
 286 void
 287 bad6(void)
 288 {
 289         lck_mtx_lock(&lck1);    // no-warning
 290         lck_mtx_unlock(&lck1);  // no-warning
 291         lck_mtx_lock(&lck1);    // no-warning
 292         lck_mtx_lock(&lck1);    // expected-warning{{This lock has already been acquired}}
 293 }
 294
 295 void
 296 bad7(void)
 297 {
 298         lck_mtx_lock(&lck1);    // no-warning
 299         lck_mtx_lock(&lck2);    // no-warning
 300         lck_mtx_unlock(&lck1);  // expected-warning{{This was not the most recently acquired lock}}
 301         lck_mtx_unlock(&lck2);
 302 }
 303
 304 void
 305 bad8(void)
 306 {
 307         if (lck_mtx_try_lock(&lck1) == 0) // no-warning
 308                 return;
 309         lck_mtx_lock(&lck2);            // no-warning
 310         lck_mtx_unlock(&lck1);          // expected-warning{{This was not the most recently acquired lock}}
 311 }
 312
 313 void
 314 bad9(void)
 315 {
 316         lck_mtx_unlock(&lck1);          // no-warning
 317         lck_mtx_unlock(&lck1);          // expected-warning{{This lock has already been unlocked}}
 318 }
 319
 320 void
 321 bad10(void)
 322 {
 323         lck_mtx_lock(&lck1);            // no-warning
 324         lck_mtx_unlock(&lck1);          // no-warning
 325         lck_mtx_unlock(&lck1);          // expected-warning{{This lock has already been unlocked}}
 326 }
 327
 328 static void
 329 bad11_sub(pthread_mutex_t *lock)
 330 {
 331         lck_mtx_unlock(lock);           // expected-warning{{This lock has already been unlocked}}
 332 }
 333
 334 void
 335 bad11(int i)
 336 {
 337         lck_mtx_lock(&lck1);            // no-warning
 338         lck_mtx_unlock(&lck1);          // no-warning
 339         if (i < 5)
 340                 bad11_sub(&lck1);
 341 }
 342
 343 void
 344 bad12(void)
 345 {
 346         pthread_mutex_lock(&mtx1);      // no-warning
 347         pthread_mutex_unlock(&mtx1);    // no-warning
 348         pthread_mutex_lock(&mtx1);      // no-warning
 349         pthread_mutex_unlock(&mtx1);    // no-warning
 350         pthread_mutex_unlock(&mtx1);    // expected-warning{{This lock has already been unlocked}}
 351 }
 352
 353 void
 354 bad13(void)
 355 {
 356         pthread_mutex_lock(&mtx1);      // no-warning
 357         pthread_mutex_unlock(&mtx1);    // no-warning
 358         pthread_mutex_lock(&mtx2);      // no-warning
 359         pthread_mutex_unlock(&mtx2);    // no-warning
 360         pthread_mutex_unlock(&mtx1);    // expected-warning{{This lock has already been unlocked}}
 361 }
 362
 363 void
 364 bad14(void)
 365 {
 366         pthread_mutex_lock(&mtx1);      // no-warning
 367         pthread_mutex_lock(&mtx2);      // no-warning
 368         pthread_mutex_unlock(&mtx2);    // no-warning
 369         pthread_mutex_unlock(&mtx1);    // no-warning
 370         pthread_mutex_unlock(&mtx2);    // expected-warning{{This lock has already been unlocked}}
 371 }
 372
 373 void
 374 bad15(void)
 375 {
 376         pthread_mutex_lock(&mtx1);      // no-warning
 377         pthread_mutex_lock(&mtx2);      // no-warning
 378         pthread_mutex_unlock(&mtx2);    // no-warning
 379         pthread_mutex_unlock(&mtx1);    // no-warning
 380         pthread_mutex_lock(&mtx1);      // no-warning
 381         pthread_mutex_unlock(&mtx2);    // expected-warning{{This lock has already been unlocked}}
 382 }
 383
 384 void
 385 bad16(void)
 386 {
 387         pthread_mutex_destroy(&mtx1);   // no-warning
 388         pthread_mutex_lock(&mtx1);      // expected-warning{{This lock has already been destroyed}}
 389 }
 390
 391 void
 392 bad17(void)
 393 {
 394         pthread_mutex_destroy(&mtx1);   // no-warning
 395         pthread_mutex_unlock(&mtx1);    // expected-warning{{This lock has already been destroyed}}
 396 }
 397
 398 void
 399 bad18(void)
 400 {
 401         pthread_mutex_destroy(&mtx1);   // no-warning
 402         pthread_mutex_destroy(&mtx1);   // expected-warning{{This lock has already been destroyed}}
 403 }
 404
 405 void
 406 bad19(void)
 407 {
 408         pthread_mutex_lock(&mtx1);      // no-warning
 409         pthread_mutex_destroy(&mtx1);   // expected-warning{{This lock is still locked}}
 410 }
 411
 412 void
 413 bad20(void)
 414 {
 415         lck_mtx_destroy(&mtx1, &grp1);  // no-warning
 416         lck_mtx_lock(&mtx1);            // expected-warning{{This lock has already been destroyed}}
 417 }
 418
 419 void
 420 bad21(void)
 421 {
 422         lck_mtx_destroy(&mtx1, &grp1);  // no-warning
 423         lck_mtx_unlock(&mtx1);          // expected-warning{{This lock has already been destroyed}}
 424 }
 425
 426 void
 427 bad22(void)
 428 {
 429         lck_mtx_destroy(&mtx1, &grp1);  // no-warning
 430         lck_mtx_destroy(&mtx1, &grp1);  // expected-warning{{This lock has already been destroyed}}
 431 }
 432
 433 void
 434 bad23(void)
 435 {
 436         lck_mtx_lock(&mtx1);            // no-warning
 437         lck_mtx_destroy(&mtx1, &grp1);  // expected-warning{{This lock is still locked}}
 438 }
 439
 440 void
 441 bad24(void)
 442 {
 443         pthread_mutex_init(&mtx1, NULL);        // no-warning
 444         pthread_mutex_init(&mtx1, NULL);        // expected-warning{{This lock has already been initialized}}
 445 }
 446
 447 void
 448 bad25(void)
 449 {
 450         pthread_mutex_lock(&mtx1);              // no-warning
 451         pthread_mutex_init(&mtx1, NULL);        // expected-warning{{This lock is still being held}}
 452 }
 453
 454 void
 455 bad26(void)
 456 {
 457         pthread_mutex_unlock(&mtx1);            // no-warning
 458         pthread_mutex_init(&mtx1, NULL);        // expected-warning{{This lock has already been initialized}}
 459 }
 460
 461 void bad27(void) {
 462   pthread_mutex_unlock(&mtx1);            // no-warning
 463   int ret = pthread_mutex_destroy(&mtx1); // no-warning
 464   if (ret != 0)                           // no-warning
 465     pthread_mutex_lock(&mtx1);            // no-warning
 466   else
 467     pthread_mutex_unlock(&mtx1); // expected-warning{{This lock has already been destroyed}}
 468 }
 469
 470 void bad28(void) {
 471   pthread_mutex_unlock(&mtx1);            // no-warning
 472   int ret = pthread_mutex_destroy(&mtx1); // no-warning
 473   if (ret != 0)                           // no-warning
 474     pthread_mutex_lock(&mtx1);            // no-warning
 475   else
 476     pthread_mutex_lock(&mtx1); // expected-warning{{This lock has already been destroyed}}
 477 }
 478
 479 void bad29(void) {
 480   pthread_mutex_lock(&mtx1);             // no-warning
 481   pthread_mutex_unlock(&mtx1);           // no-warning
 482   if (pthread_mutex_destroy(&mtx1) != 0) // no-warning
 483     pthread_mutex_init(&mtx1, NULL);     // expected-warning{{This lock has already been initialized}}
 484   else
 485     pthread_mutex_init(&mtx1, NULL); // no-warning
 486 }
 487
 488 void bad30(void) {
 489   pthread_mutex_lock(&mtx1);             // no-warning
 490   pthread_mutex_unlock(&mtx1);           // no-warning
 491   if (pthread_mutex_destroy(&mtx1) != 0) // no-warning
 492     pthread_mutex_init(&mtx1, NULL);     // expected-warning{{This lock has already been initialized}}
 493   else
 494     pthread_mutex_destroy(&mtx1); // expected-warning{{This lock has already been destroyed}}
 495 }
 496
 497 void bad31(void) {
 498   int ret = pthread_mutex_destroy(&mtx1); // no-warning
 499   pthread_mutex_lock(&mtx1);              // expected-warning{{This lock has already been destroyed}}
 500   if (ret != 0)
 501     pthread_mutex_lock(&mtx1);
 502 }
 503
 504 void bad32(void) {
 505   lck_rw_lock_shared(&rw);
 506   lck_rw_unlock_exclusive(&rw); // FIXME: warn - should be shared?
 507   lck_rw_lock_exclusive(&rw);
 508   lck_rw_unlock_shared(&rw); // FIXME: warn - should be exclusive?
 509 }
 510
 511 void bad33(void) {
 512   pthread_mutex_lock(pmtx);
 513   fake_system_function();
 514   pthread_mutex_lock(pmtx); // expected-warning{{This lock has already been acquired}}
 515 }
 516
 517 void nocrash1(pthread_mutex_t *mutex) {
 518   int ret = pthread_mutex_destroy(mutex);
 519   if (ret == 0) // no crash
 520     ;
 521 }