Print this page
11506 smatch resync


  32 #include "smatch_slist.h"
  33 
  34 static int my_id;
  35 
  36 static int func_has_transition;
  37 
  38 STATE(locked);
  39 STATE(start_state);
  40 STATE(unlocked);
  41 STATE(impossible);
  42 
  43 enum action {
  44         LOCK,
  45         UNLOCK,
  46 };
  47 
  48 enum return_type {
  49         ret_any,
  50         ret_non_zero,
  51         ret_zero,

  52         ret_negative,
  53         ret_positive,
  54 };
  55 
  56 #define RETURN_VAL -1
  57 #define NO_ARG -2
  58 
  59 struct lock_info {
  60         const char *function;
  61         enum action action;
  62         const char *name;
  63         int arg;
  64         enum return_type return_type;
  65 };
  66 
  67 static struct lock_info wine_lock_table[] = {
  68         {"create_window_handle", LOCK, "create_window_handle", RETURN_VAL, ret_non_zero},
  69         {"WIN_GetPtr", LOCK, "create_window_handle", RETURN_VAL, ret_non_zero},
  70         {"WIN_ReleasePtr", UNLOCK, "create_window_handle", 0, ret_any},
  71         {"EnterCriticalSection", LOCK, "CriticalSection", 0, ret_any},


 134         {"spin_unlock_irqrestore",     UNLOCK, "spin_lock", 0, ret_any},
 135         {"_spin_lock_irqsave",         LOCK,   "spin_lock", 0, ret_any},
 136         {"_spin_unlock_irqrestore",    UNLOCK, "spin_lock", 0, ret_any},
 137         {"__spin_lock_irqsave",        LOCK,   "spin_lock", 0, ret_any},
 138         {"__spin_unlock_irqrestore",   UNLOCK, "spin_lock", 0, ret_any},
 139         {"_raw_spin_lock_irqsave",     LOCK,   "spin_lock", 0, ret_any},
 140         {"_raw_spin_unlock_irqrestore", UNLOCK, "spin_lock", 0, ret_any},
 141         {"__raw_spin_lock_irqsave",    LOCK,   "spin_lock", 0, ret_any},
 142         {"__raw_spin_unlock_irqrestore", UNLOCK, "spin_lock", 0, ret_any},
 143         {"spin_lock_irqsave_nested",   LOCK,   "spin_lock", 0, ret_any},
 144         {"_spin_lock_irqsave_nested",  LOCK,   "spin_lock", 0, ret_any},
 145         {"__spin_lock_irqsave_nested", LOCK,   "spin_lock", 0, ret_any},
 146         {"_raw_spin_lock_irqsave_nested", LOCK, "spin_lock", 0, ret_any},
 147         {"spin_lock_bh",               LOCK,   "spin_lock", 0, ret_any},
 148         {"spin_unlock_bh",             UNLOCK, "spin_lock", 0, ret_any},
 149         {"_spin_lock_bh",              LOCK,   "spin_lock", 0, ret_any},
 150         {"_spin_unlock_bh",            UNLOCK, "spin_lock", 0, ret_any},
 151         {"__spin_lock_bh",             LOCK,   "spin_lock", 0, ret_any},
 152         {"__spin_unlock_bh",           UNLOCK, "spin_lock", 0, ret_any},
 153 
 154         {"spin_trylock",               LOCK,   "spin_lock", 0, ret_non_zero},
 155         {"_spin_trylock",              LOCK,   "spin_lock", 0, ret_non_zero},
 156         {"__spin_trylock",             LOCK,   "spin_lock", 0, ret_non_zero},
 157         {"raw_spin_trylock",           LOCK,   "spin_lock", 0, ret_non_zero},
 158         {"_raw_spin_trylock",          LOCK,   "spin_lock", 0, ret_non_zero},
 159         {"spin_trylock_irq",           LOCK,   "spin_lock", 0, ret_non_zero},
 160         {"spin_trylock_irqsave",       LOCK,   "spin_lock", 0, ret_non_zero},
 161         {"spin_trylock_bh",            LOCK,   "spin_lock", 0, ret_non_zero},
 162         {"_spin_trylock_bh",           LOCK,   "spin_lock", 0, ret_non_zero},
 163         {"__spin_trylock_bh",          LOCK,   "spin_lock", 0, ret_non_zero},
 164         {"__raw_spin_trylock",         LOCK,   "spin_lock", 0, ret_non_zero},
 165         {"_atomic_dec_and_lock",       LOCK,   "spin_lock", 1, ret_non_zero},
 166 
 167         {"read_lock",                 LOCK,   "read_lock", 0, ret_any},
 168         {"read_unlock",               UNLOCK, "read_lock", 0, ret_any},
 169         {"_read_lock",                LOCK,   "read_lock", 0, ret_any},
 170         {"_read_unlock",              UNLOCK, "read_lock", 0, ret_any},
 171         {"__read_lock",               LOCK,   "read_lock", 0, ret_any},
 172         {"__read_unlock",             UNLOCK, "read_lock", 0, ret_any},
 173         {"_raw_read_lock",            LOCK,   "read_lock", 0, ret_any},
 174         {"_raw_read_unlock",          UNLOCK, "read_lock", 0, ret_any},
 175         {"__raw_read_lock",           LOCK,   "read_lock", 0, ret_any},
 176         {"__raw_read_unlock",         UNLOCK, "read_lock", 0, ret_any},
 177         {"read_lock_irq",             LOCK,   "read_lock", 0, ret_any},
 178         {"read_unlock_irq" ,          UNLOCK, "read_lock", 0, ret_any},
 179         {"_read_lock_irq",            LOCK,   "read_lock", 0, ret_any},
 180         {"_read_unlock_irq",          UNLOCK, "read_lock", 0, ret_any},
 181         {"__read_lock_irq",           LOCK,   "read_lock", 0, ret_any},
 182         {"__read_unlock_irq",         UNLOCK, "read_lock", 0, ret_any},
 183         {"read_lock_irqsave",         LOCK,   "read_lock", 0, ret_any},
 184         {"read_unlock_irqrestore",    UNLOCK, "read_lock", 0, ret_any},
 185         {"_read_lock_irqsave",        LOCK,   "read_lock", 0, ret_any},
 186         {"_read_unlock_irqrestore",   UNLOCK, "read_lock", 0, ret_any},
 187         {"__read_lock_irqsave",       LOCK,   "read_lock", 0, ret_any},
 188         {"__read_unlock_irqrestore",  UNLOCK, "read_lock", 0, ret_any},
 189         {"read_lock_bh",              LOCK,   "read_lock", 0, ret_any},
 190         {"read_unlock_bh",            UNLOCK, "read_lock", 0, ret_any},
 191         {"_read_lock_bh",             LOCK,   "read_lock", 0, ret_any},
 192         {"_read_unlock_bh",           UNLOCK, "read_lock", 0, ret_any},
 193         {"__read_lock_bh",            LOCK,   "read_lock", 0, ret_any},
 194         {"__read_unlock_bh",          UNLOCK, "read_lock", 0, ret_any},
 195         {"_raw_read_lock_bh",         LOCK,   "read_lock", 0, ret_any},
 196         {"_raw_read_unlock_bh",       UNLOCK, "read_lock", 0, ret_any},
 197         {"__raw_read_lock_bh",        LOCK,   "read_lock", 0, ret_any},
 198         {"__raw_read_unlock_bh",      UNLOCK, "read_lock", 0, ret_any},
 199 
 200         {"generic__raw_read_trylock", LOCK,   "read_lock", 0, ret_non_zero},
 201         {"read_trylock",              LOCK,   "read_lock", 0, ret_non_zero},
 202         {"_read_trylock",             LOCK,   "read_lock", 0, ret_non_zero},
 203         {"raw_read_trylock",          LOCK,   "read_lock", 0, ret_non_zero},
 204         {"_raw_read_trylock",         LOCK,   "read_lock", 0, ret_non_zero},
 205         {"__raw_read_trylock",        LOCK,   "read_lock", 0, ret_non_zero},
 206         {"__read_trylock",            LOCK,   "read_lock", 0, ret_non_zero},
 207 
 208         {"write_lock",                LOCK,   "write_lock", 0, ret_any},
 209         {"write_unlock",              UNLOCK, "write_lock", 0, ret_any},
 210         {"_write_lock",               LOCK,   "write_lock", 0, ret_any},
 211         {"_write_unlock",             UNLOCK, "write_lock", 0, ret_any},
 212         {"__write_lock",              LOCK,   "write_lock", 0, ret_any},
 213         {"__write_unlock",            UNLOCK, "write_lock", 0, ret_any},
 214         {"write_lock_irq",            LOCK,   "write_lock", 0, ret_any},
 215         {"write_unlock_irq",          UNLOCK, "write_lock", 0, ret_any},
 216         {"_write_lock_irq",           LOCK,   "write_lock", 0, ret_any},
 217         {"_write_unlock_irq",         UNLOCK, "write_lock", 0, ret_any},
 218         {"__write_lock_irq",          LOCK,   "write_lock", 0, ret_any},
 219         {"__write_unlock_irq",        UNLOCK, "write_lock", 0, ret_any},
 220         {"write_lock_irqsave",        LOCK,   "write_lock", 0, ret_any},
 221         {"write_unlock_irqrestore",   UNLOCK, "write_lock", 0, ret_any},
 222         {"_write_lock_irqsave",       LOCK,   "write_lock", 0, ret_any},
 223         {"_write_unlock_irqrestore",  UNLOCK, "write_lock", 0, ret_any},
 224         {"__write_lock_irqsave",      LOCK,   "write_lock", 0, ret_any},
 225         {"__write_unlock_irqrestore", UNLOCK, "write_lock", 0, ret_any},
 226         {"write_lock_bh",             LOCK,   "write_lock", 0, ret_any},
 227         {"write_unlock_bh",           UNLOCK, "write_lock", 0, ret_any},
 228         {"_write_lock_bh",            LOCK,   "write_lock", 0, ret_any},
 229         {"_write_unlock_bh",          UNLOCK, "write_lock", 0, ret_any},
 230         {"__write_lock_bh",           LOCK,   "write_lock", 0, ret_any},
 231         {"__write_unlock_bh",         UNLOCK, "write_lock", 0, ret_any},
 232         {"_raw_write_lock",           LOCK,   "write_lock", 0, ret_any},
 233         {"__raw_write_lock",          LOCK,   "write_lock", 0, ret_any},
 234         {"_raw_write_unlock",         UNLOCK, "write_lock", 0, ret_any},
 235         {"__raw_write_unlock",        UNLOCK, "write_lock", 0, ret_any},
 236 
 237         {"write_trylock",             LOCK,   "write_lock", 0, ret_non_zero},
 238         {"_write_trylock",            LOCK,   "write_lock", 0, ret_non_zero},
 239         {"raw_write_trylock",         LOCK,   "write_lock", 0, ret_non_zero},
 240         {"_raw_write_trylock",        LOCK,   "write_lock", 0, ret_non_zero},
 241         {"__write_trylock",           LOCK,   "write_lock", 0, ret_non_zero},
 242         {"__raw_write_trylock",       LOCK,   "write_lock", 0, ret_non_zero},
 243 
 244         {"down",               LOCK,   "sem", 0, ret_any},
 245         {"up",                 UNLOCK, "sem", 0, ret_any},
 246         {"down_trylock",       LOCK,   "sem", 0, ret_zero},
 247         {"down_timeout",       LOCK,   "sem", 0, ret_zero},
 248         {"down_interruptible", LOCK,   "sem", 0, ret_zero},
 249 












 250         {"mutex_lock",                      LOCK,   "mutex", 0, ret_any},

 251         {"mutex_unlock",                    UNLOCK, "mutex", 0, ret_any},
 252         {"mutex_lock_nested",               LOCK,   "mutex", 0, ret_any},

 253 
 254         {"mutex_lock_interruptible",        LOCK,   "mutex", 0, ret_zero},
 255         {"mutex_lock_interruptible_nested", LOCK,   "mutex", 0, ret_zero},
 256         {"mutex_lock_killable",             LOCK,   "mutex", 0, ret_zero},
 257         {"mutex_lock_killable_nested",      LOCK,   "mutex", 0, ret_zero},
 258 
 259         {"mutex_trylock",                   LOCK,   "mutex", 0, ret_non_zero},
 260 
 261         {"raw_local_irq_disable", LOCK,   "irq", NO_ARG, ret_any},
 262         {"raw_local_irq_enable",  UNLOCK, "irq", NO_ARG, ret_any},
 263         {"spin_lock_irq",         LOCK,   "irq", NO_ARG, ret_any},
 264         {"spin_unlock_irq",       UNLOCK, "irq", NO_ARG, ret_any},
 265         {"_spin_lock_irq",        LOCK,   "irq", NO_ARG, ret_any},
 266         {"_spin_unlock_irq",      UNLOCK, "irq", NO_ARG, ret_any},
 267         {"__spin_lock_irq",       LOCK,   "irq", NO_ARG, ret_any},
 268         {"__spin_unlock_irq",     UNLOCK, "irq", NO_ARG, ret_any},
 269         {"_raw_spin_lock_irq",    LOCK,   "irq", NO_ARG, ret_any},
 270         {"_raw_spin_unlock_irq",  UNLOCK, "irq", NO_ARG, ret_any},
 271         {"__raw_spin_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
 272         {"spin_trylock_irq",      LOCK,   "irq", NO_ARG, ret_non_zero},
 273         {"read_lock_irq",         LOCK,   "irq", NO_ARG, ret_any},
 274         {"read_unlock_irq",       UNLOCK, "irq", NO_ARG, ret_any},
 275         {"_read_lock_irq",        LOCK,   "irq", NO_ARG, ret_any},
 276         {"_read_unlock_irq",      UNLOCK, "irq", NO_ARG, ret_any},
 277         {"__read_lock_irq",       LOCK,   "irq", NO_ARG, ret_any},
 278         {"__read_unlock_irq",     UNLOCK, "irq", NO_ARG, ret_any},
 279         {"write_lock_irq",        LOCK,   "irq", NO_ARG, ret_any},
 280         {"write_unlock_irq",      UNLOCK, "irq", NO_ARG, ret_any},
 281         {"_write_lock_irq",       LOCK,   "irq", NO_ARG, ret_any},
 282         {"_write_unlock_irq",     UNLOCK, "irq", NO_ARG, ret_any},
 283         {"__write_lock_irq",      LOCK,   "irq", NO_ARG, ret_any},
 284         {"__write_unlock_irq",    UNLOCK, "irq", NO_ARG, ret_any},
 285 
 286         {"arch_local_irq_save",        LOCK,   "irqsave", RETURN_VAL, ret_any},
 287         {"arch_local_irq_restore",     UNLOCK, "irqsave", 0, ret_any},
 288         {"__raw_local_irq_save",       LOCK,   "irqsave", RETURN_VAL, ret_any},
 289         {"raw_local_irq_restore",      UNLOCK, "irqsave", 0, ret_any},
 290         {"spin_lock_irqsave_nested",   LOCK,   "irqsave", RETURN_VAL, ret_any},
 291         {"spin_lock_irqsave",          LOCK,   "irqsave", RETURN_VAL, ret_any},
 292         {"spin_lock_irqsave",          LOCK,   "irqsave", 1, ret_any},
 293         {"spin_unlock_irqrestore",     UNLOCK, "irqsave", 1, ret_any},
 294         {"_spin_lock_irqsave_nested",  LOCK,   "irqsave", RETURN_VAL, ret_any},
 295         {"_spin_lock_irqsave",         LOCK,   "irqsave", RETURN_VAL, ret_any},
 296         {"_spin_lock_irqsave",         LOCK,   "irqsave", 1, ret_any},
 297         {"_spin_unlock_irqrestore",    UNLOCK, "irqsave", 1, ret_any},
 298         {"__spin_lock_irqsave_nested", LOCK,   "irqsave", 1, ret_any},
 299         {"__spin_lock_irqsave",        LOCK,   "irqsave", 1, ret_any},
 300         {"__spin_unlock_irqrestore",   UNLOCK, "irqsave", 1, ret_any},
 301         {"_raw_spin_lock_irqsave",     LOCK,   "irqsave", RETURN_VAL, ret_any},
 302         {"_raw_spin_lock_irqsave",     LOCK,   "irqsave", 1, ret_any},
 303         {"_raw_spin_unlock_irqrestore",UNLOCK, "irqsave", 1, ret_any},
 304         {"__raw_spin_lock_irqsave",    LOCK,   "irqsave", RETURN_VAL, ret_any},
 305         {"__raw_spin_unlock_irqrestore",UNLOCK, "irqsave", 1, ret_any},
 306         {"_raw_spin_lock_irqsave_nested", LOCK, "irqsave", RETURN_VAL, ret_any},
 307         {"spin_trylock_irqsave",       LOCK,   "irqsave", 1, ret_non_zero},
 308         {"read_lock_irqsave",          LOCK,   "irqsave", RETURN_VAL, ret_any},
 309         {"read_lock_irqsave",          LOCK,   "irqsave", 1, ret_any},
 310         {"read_unlock_irqrestore",     UNLOCK, "irqsave", 1, ret_any},
 311         {"_read_lock_irqsave",         LOCK,   "irqsave", RETURN_VAL, ret_any},
 312         {"_read_lock_irqsave",         LOCK,   "irqsave", 1, ret_any},
 313         {"_read_unlock_irqrestore",    UNLOCK, "irqsave", 1, ret_any},
 314         {"__read_lock_irqsave",        LOCK,   "irqsave", RETURN_VAL, ret_any},
 315         {"__read_unlock_irqrestore",   UNLOCK, "irqsave", 1, ret_any},
 316         {"write_lock_irqsave",         LOCK,   "irqsave", RETURN_VAL, ret_any},
 317         {"write_lock_irqsave",         LOCK,   "irqsave", 1, ret_any},
 318         {"write_unlock_irqrestore",    UNLOCK, "irqsave", 1, ret_any},
 319         {"_write_lock_irqsave",        LOCK,   "irqsave", RETURN_VAL, ret_any},
 320         {"_write_lock_irqsave",        LOCK,   "irqsave", 1, ret_any},
 321         {"_write_unlock_irqrestore",   UNLOCK, "irqsave", 1, ret_any},
 322         {"__write_lock_irqsave",       LOCK,   "irqsave", RETURN_VAL, ret_any},
 323         {"__write_unlock_irqrestore",  UNLOCK, "irqsave", 1, ret_any},
 324 
 325         {"local_bh_disable",    LOCK,   "bottom_half", NO_ARG, ret_any},
 326         {"_local_bh_disable",   LOCK,   "bottom_half", NO_ARG, ret_any},
 327         {"__local_bh_disable",  LOCK,   "bottom_half", NO_ARG, ret_any},


 331         {"spin_lock_bh",        LOCK,   "bottom_half", NO_ARG, ret_any},
 332         {"spin_unlock_bh",      UNLOCK, "bottom_half", NO_ARG, ret_any},
 333         {"_spin_lock_bh",       LOCK,   "bottom_half", NO_ARG, ret_any},
 334         {"_spin_unlock_bh",     UNLOCK, "bottom_half", NO_ARG, ret_any},
 335         {"__spin_lock_bh",      LOCK,   "bottom_half", NO_ARG, ret_any},
 336         {"__spin_unlock_bh",    UNLOCK, "bottom_half", NO_ARG, ret_any},
 337         {"read_lock_bh",        LOCK,   "bottom_half", NO_ARG, ret_any},
 338         {"read_unlock_bh",      UNLOCK, "bottom_half", NO_ARG, ret_any},
 339         {"_read_lock_bh",       LOCK,   "bottom_half", NO_ARG, ret_any},
 340         {"_read_unlock_bh",     UNLOCK, "bottom_half", NO_ARG, ret_any},
 341         {"__read_lock_bh",      LOCK,   "bottom_half", NO_ARG, ret_any},
 342         {"__read_unlock_bh",    UNLOCK, "bottom_half", NO_ARG, ret_any},
 343         {"_raw_read_lock_bh",   LOCK,   "bottom_half", NO_ARG, ret_any},
 344         {"_raw_read_unlock_bh", UNLOCK, "bottom_half", NO_ARG, ret_any},
 345         {"write_lock_bh",       LOCK,   "bottom_half", NO_ARG, ret_any},
 346         {"write_unlock_bh",     UNLOCK, "bottom_half", NO_ARG, ret_any},
 347         {"_write_lock_bh",      LOCK,   "bottom_half", NO_ARG, ret_any},
 348         {"_write_unlock_bh",    UNLOCK, "bottom_half", NO_ARG, ret_any},
 349         {"__write_lock_bh",     LOCK,   "bottom_half", NO_ARG, ret_any},
 350         {"__write_unlock_bh",   UNLOCK, "bottom_half", NO_ARG, ret_any},
 351         {"spin_trylock_bh",     LOCK,   "bottom_half", NO_ARG, ret_non_zero},
 352         {"_spin_trylock_bh",    LOCK,   "bottom_half", NO_ARG, ret_non_zero},
 353         {"__spin_trylock_bh",   LOCK,   "bottom_half", NO_ARG, ret_non_zero},
 354 
 355         {"ffs_mutex_lock",        LOCK,   "mutex", 0, ret_zero},
 356 };
 357 
 358 static struct lock_info *lock_table;
 359 
 360 static struct tracker_list *starts_locked;
 361 static struct tracker_list *starts_unlocked;
 362 
 363 struct locks_on_return {
 364         int line;
 365         struct tracker_list *locked;
 366         struct tracker_list *unlocked;
 367         struct tracker_list *impossible;
 368         struct range_list *return_values;
 369 };
 370 DECLARE_PTR_LIST(return_list, struct locks_on_return);
 371 static struct return_list *all_returns;
 372 
 373 static char *make_full_name(const char *lock, const char *var)


 430         if (is_locked && is_unlocked)
 431                 return &undefined;
 432         if (is_locked)
 433                 return &locked;
 434         if (is_unlocked)
 435                 return &unlocked;
 436         return &undefined;
 437 }
 438 
 439 static struct smatch_state *unmatched_state(struct sm_state *sm)
 440 {
 441         return &start_state;
 442 }
 443 
 444 static void pre_merge_hook(struct sm_state *sm)
 445 {
 446         if (is_impossible_path())
 447                 set_state(my_id, sm->name, sm->sym, &impossible);
 448 }
 449 









 450 static void do_lock(const char *name)
 451 {
 452         struct sm_state *sm;
 453 
 454         if (__inline_fn)
 455                 return;
 456 
 457         sm = get_sm_state(my_id, name, NULL);
 458         if (!sm)
 459                 add_tracker(&starts_unlocked, my_id, name, NULL);
 460         if (sm && slist_has_state(sm->possible, &locked) &&
 461                         strcmp(name, "bottom_half:") != 0)
 462                 sm_error("double lock '%s'", name);
 463         if (sm)
 464                 func_has_transition = TRUE;
 465         set_state(my_id, name, NULL, &locked);
 466 }
 467 
 468 static void do_lock_failed(const char *name)
 469 {
 470         struct sm_state *sm;
 471 
 472         if (__inline_fn)
 473                 return;
 474 
 475         sm = get_sm_state(my_id, name, NULL);
 476         if (!sm)
 477                 add_tracker(&starts_unlocked, my_id, name, NULL);
 478         set_state(my_id, name, NULL, &unlocked);
 479 }
 480 
 481 static void do_unlock(const char *name)


 727                         if (i++)
 728                                 sm_printf("               ");
 729                         sm_printf("line %d\n", tmp->line);
 730                         add_line(&printed, tmp->line);
 731                         continue;
 732                 }
 733                 if (in_tracker_list(tmp->locked, lock->owner, lock->name, lock->sym))
 734                         continue;
 735                 if (start == &unlocked) {
 736                         if (i++)
 737                                 sm_printf("               ");
 738                         sm_printf("line %d\n", tmp->line);
 739                         add_line(&printed, tmp->line);
 740                 }
 741         } END_FOR_EACH_PTR(tmp);
 742 }
 743 
 744 static int matches_return_type(struct range_list *rl, enum return_type type)
 745 {
 746         sval_t zero_sval = ll_to_sval(0);

 747 
 748         /* All these double negatives are super ugly!  */
 749 
 750         switch (type) {
 751         case ret_zero:
 752                 return !possibly_true_rl(rl, SPECIAL_NOTEQUAL, alloc_rl(zero_sval, zero_sval));


 753         case ret_non_zero:
 754                 return !possibly_true_rl(rl, SPECIAL_EQUAL, alloc_rl(zero_sval, zero_sval));
 755         case ret_negative:
 756                 return !possibly_true_rl(rl, SPECIAL_GTE, alloc_rl(zero_sval, zero_sval));
 757         case ret_positive:
 758                 return !possibly_true_rl(rl, '<', alloc_rl(zero_sval, zero_sval));
 759         case ret_any:
 760         default:
 761                 return 1;
 762         }
 763 }
 764 
 765 static int match_held(struct tracker *lock, struct locks_on_return *this_return, struct smatch_state *start)
 766 {
 767         if (in_tracker_list(this_return->impossible, lock->owner, lock->name, lock->sym))
 768                 return 0;
 769         if (in_tracker_list(this_return->unlocked, lock->owner, lock->name, lock->sym))
 770                 return 0;
 771         if (in_tracker_list(this_return->locked, lock->owner, lock->name, lock->sym))
 772                 return 1;


 889         if (__inline_fn)
 890                 return;
 891 
 892         if (func_has_transition)
 893                 check_consistency(sym);
 894 }
 895 
 896 static void match_after_func(struct symbol *sym)
 897 {
 898         if (__inline_fn)
 899                 return;
 900         clear_lists();
 901 }
 902 
 903 static void register_lock(int index)
 904 {
 905         struct lock_info *lock = &lock_table[index];
 906         void *idx = INT_PTR(index);
 907 
 908         if (lock->return_type == ret_non_zero) {
 909                 return_implies_state(lock->function, valid_ptr_min, valid_ptr_max, &match_lock_held, idx);
 910                 return_implies_state(lock->function, 0, 0, &match_lock_failed, idx);
 911         } else if (lock->return_type == ret_any && lock->arg == RETURN_VAL) {
 912                 add_function_assign_hook(lock->function, &match_returns_locked, idx);
 913         } else if (lock->return_type == ret_any) {
 914                 add_function_hook(lock->function, &match_lock_unlock, idx);
 915         } else if (lock->return_type == ret_zero) {
 916                 return_implies_state(lock->function, 0, 0, &match_lock_held, idx);
 917                 return_implies_state(lock->function, -4095, -1, &match_lock_failed, idx);



 918         }
 919 }
 920 
 921 static void load_table(struct lock_info *_lock_table, int size)
 922 {
 923         int i;
 924 
 925         lock_table = _lock_table;
 926 
 927         for (i = 0; i < size; i++) {
 928                 if (lock_table[i].action == LOCK)
 929                         register_lock(i);
 930                 else
 931                         add_function_hook(lock_table[i].function, &match_lock_unlock, INT_PTR(i));
 932         }
 933 }
 934 
 935 /* print_held_locks() is used in check_call_tree.c */
 936 void print_held_locks(void)
 937 {




  32 #include "smatch_slist.h"
  33 
  34 static int my_id;
  35 
  36 static int func_has_transition;
  37 
  38 STATE(locked);
  39 STATE(start_state);
  40 STATE(unlocked);
  41 STATE(impossible);
  42 
  43 enum action {
  44         LOCK,
  45         UNLOCK,
  46 };
  47 
  48 enum return_type {
  49         ret_any,
  50         ret_non_zero,
  51         ret_zero,
  52         ret_one,
  53         ret_negative,
  54         ret_positive,
  55 };
  56 
  57 #define RETURN_VAL -1
  58 #define NO_ARG -2
  59 
  60 struct lock_info {
  61         const char *function;
  62         enum action action;
  63         const char *name;
  64         int arg;
  65         enum return_type return_type;
  66 };
  67 
  68 static struct lock_info wine_lock_table[] = {
  69         {"create_window_handle", LOCK, "create_window_handle", RETURN_VAL, ret_non_zero},
  70         {"WIN_GetPtr", LOCK, "create_window_handle", RETURN_VAL, ret_non_zero},
  71         {"WIN_ReleasePtr", UNLOCK, "create_window_handle", 0, ret_any},
  72         {"EnterCriticalSection", LOCK, "CriticalSection", 0, ret_any},


 135         {"spin_unlock_irqrestore",     UNLOCK, "spin_lock", 0, ret_any},
 136         {"_spin_lock_irqsave",         LOCK,   "spin_lock", 0, ret_any},
 137         {"_spin_unlock_irqrestore",    UNLOCK, "spin_lock", 0, ret_any},
 138         {"__spin_lock_irqsave",        LOCK,   "spin_lock", 0, ret_any},
 139         {"__spin_unlock_irqrestore",   UNLOCK, "spin_lock", 0, ret_any},
 140         {"_raw_spin_lock_irqsave",     LOCK,   "spin_lock", 0, ret_any},
 141         {"_raw_spin_unlock_irqrestore", UNLOCK, "spin_lock", 0, ret_any},
 142         {"__raw_spin_lock_irqsave",    LOCK,   "spin_lock", 0, ret_any},
 143         {"__raw_spin_unlock_irqrestore", UNLOCK, "spin_lock", 0, ret_any},
 144         {"spin_lock_irqsave_nested",   LOCK,   "spin_lock", 0, ret_any},
 145         {"_spin_lock_irqsave_nested",  LOCK,   "spin_lock", 0, ret_any},
 146         {"__spin_lock_irqsave_nested", LOCK,   "spin_lock", 0, ret_any},
 147         {"_raw_spin_lock_irqsave_nested", LOCK, "spin_lock", 0, ret_any},
 148         {"spin_lock_bh",               LOCK,   "spin_lock", 0, ret_any},
 149         {"spin_unlock_bh",             UNLOCK, "spin_lock", 0, ret_any},
 150         {"_spin_lock_bh",              LOCK,   "spin_lock", 0, ret_any},
 151         {"_spin_unlock_bh",            UNLOCK, "spin_lock", 0, ret_any},
 152         {"__spin_lock_bh",             LOCK,   "spin_lock", 0, ret_any},
 153         {"__spin_unlock_bh",           UNLOCK, "spin_lock", 0, ret_any},
 154 
 155         {"spin_trylock",               LOCK,   "spin_lock", 0, ret_one},
 156         {"_spin_trylock",              LOCK,   "spin_lock", 0, ret_one},
 157         {"__spin_trylock",             LOCK,   "spin_lock", 0, ret_one},
 158         {"raw_spin_trylock",           LOCK,   "spin_lock", 0, ret_one},
 159         {"_raw_spin_trylock",          LOCK,   "spin_lock", 0, ret_one},
 160         {"spin_trylock_irq",           LOCK,   "spin_lock", 0, ret_one},
 161         {"spin_trylock_irqsave",       LOCK,   "spin_lock", 0, ret_one},
 162         {"spin_trylock_bh",            LOCK,   "spin_lock", 0, ret_one},
 163         {"_spin_trylock_bh",           LOCK,   "spin_lock", 0, ret_one},
 164         {"__spin_trylock_bh",          LOCK,   "spin_lock", 0, ret_one},
 165         {"__raw_spin_trylock",         LOCK,   "spin_lock", 0, ret_one},
 166         {"_atomic_dec_and_lock",       LOCK,   "spin_lock", 1, ret_one},
 167 
 168         {"read_lock",                 LOCK,   "read_lock", 0, ret_any},
 169         {"read_unlock",               UNLOCK, "read_lock", 0, ret_any},
 170         {"_read_lock",                LOCK,   "read_lock", 0, ret_any},
 171         {"_read_unlock",              UNLOCK, "read_lock", 0, ret_any},
 172         {"__read_lock",               LOCK,   "read_lock", 0, ret_any},
 173         {"__read_unlock",             UNLOCK, "read_lock", 0, ret_any},
 174         {"_raw_read_lock",            LOCK,   "read_lock", 0, ret_any},
 175         {"_raw_read_unlock",          UNLOCK, "read_lock", 0, ret_any},
 176         {"__raw_read_lock",           LOCK,   "read_lock", 0, ret_any},
 177         {"__raw_read_unlock",         UNLOCK, "read_lock", 0, ret_any},
 178         {"read_lock_irq",             LOCK,   "read_lock", 0, ret_any},
 179         {"read_unlock_irq" ,          UNLOCK, "read_lock", 0, ret_any},
 180         {"_read_lock_irq",            LOCK,   "read_lock", 0, ret_any},
 181         {"_read_unlock_irq",          UNLOCK, "read_lock", 0, ret_any},
 182         {"__read_lock_irq",           LOCK,   "read_lock", 0, ret_any},
 183         {"__read_unlock_irq",         UNLOCK, "read_lock", 0, ret_any},
 184         {"read_lock_irqsave",         LOCK,   "read_lock", 0, ret_any},
 185         {"read_unlock_irqrestore",    UNLOCK, "read_lock", 0, ret_any},
 186         {"_read_lock_irqsave",        LOCK,   "read_lock", 0, ret_any},
 187         {"_read_unlock_irqrestore",   UNLOCK, "read_lock", 0, ret_any},
 188         {"__read_lock_irqsave",       LOCK,   "read_lock", 0, ret_any},
 189         {"__read_unlock_irqrestore",  UNLOCK, "read_lock", 0, ret_any},
 190         {"read_lock_bh",              LOCK,   "read_lock", 0, ret_any},
 191         {"read_unlock_bh",            UNLOCK, "read_lock", 0, ret_any},
 192         {"_read_lock_bh",             LOCK,   "read_lock", 0, ret_any},
 193         {"_read_unlock_bh",           UNLOCK, "read_lock", 0, ret_any},
 194         {"__read_lock_bh",            LOCK,   "read_lock", 0, ret_any},
 195         {"__read_unlock_bh",          UNLOCK, "read_lock", 0, ret_any},
 196         {"_raw_read_lock_bh",         LOCK,   "read_lock", 0, ret_any},
 197         {"_raw_read_unlock_bh",       UNLOCK, "read_lock", 0, ret_any},
 198         {"__raw_read_lock_bh",        LOCK,   "read_lock", 0, ret_any},
 199         {"__raw_read_unlock_bh",      UNLOCK, "read_lock", 0, ret_any},
 200 
 201         {"generic__raw_read_trylock", LOCK,   "read_lock", 0, ret_one},
 202         {"read_trylock",              LOCK,   "read_lock", 0, ret_one},
 203         {"_read_trylock",             LOCK,   "read_lock", 0, ret_one},
 204         {"raw_read_trylock",          LOCK,   "read_lock", 0, ret_one},
 205         {"_raw_read_trylock",         LOCK,   "read_lock", 0, ret_one},
 206         {"__raw_read_trylock",        LOCK,   "read_lock", 0, ret_one},
 207         {"__read_trylock",            LOCK,   "read_lock", 0, ret_one},
 208 
 209         {"write_lock",                LOCK,   "write_lock", 0, ret_any},
 210         {"write_unlock",              UNLOCK, "write_lock", 0, ret_any},
 211         {"_write_lock",               LOCK,   "write_lock", 0, ret_any},
 212         {"_write_unlock",             UNLOCK, "write_lock", 0, ret_any},
 213         {"__write_lock",              LOCK,   "write_lock", 0, ret_any},
 214         {"__write_unlock",            UNLOCK, "write_lock", 0, ret_any},
 215         {"write_lock_irq",            LOCK,   "write_lock", 0, ret_any},
 216         {"write_unlock_irq",          UNLOCK, "write_lock", 0, ret_any},
 217         {"_write_lock_irq",           LOCK,   "write_lock", 0, ret_any},
 218         {"_write_unlock_irq",         UNLOCK, "write_lock", 0, ret_any},
 219         {"__write_lock_irq",          LOCK,   "write_lock", 0, ret_any},
 220         {"__write_unlock_irq",        UNLOCK, "write_lock", 0, ret_any},
 221         {"write_lock_irqsave",        LOCK,   "write_lock", 0, ret_any},
 222         {"write_unlock_irqrestore",   UNLOCK, "write_lock", 0, ret_any},
 223         {"_write_lock_irqsave",       LOCK,   "write_lock", 0, ret_any},
 224         {"_write_unlock_irqrestore",  UNLOCK, "write_lock", 0, ret_any},
 225         {"__write_lock_irqsave",      LOCK,   "write_lock", 0, ret_any},
 226         {"__write_unlock_irqrestore", UNLOCK, "write_lock", 0, ret_any},
 227         {"write_lock_bh",             LOCK,   "write_lock", 0, ret_any},
 228         {"write_unlock_bh",           UNLOCK, "write_lock", 0, ret_any},
 229         {"_write_lock_bh",            LOCK,   "write_lock", 0, ret_any},
 230         {"_write_unlock_bh",          UNLOCK, "write_lock", 0, ret_any},
 231         {"__write_lock_bh",           LOCK,   "write_lock", 0, ret_any},
 232         {"__write_unlock_bh",         UNLOCK, "write_lock", 0, ret_any},
 233         {"_raw_write_lock",           LOCK,   "write_lock", 0, ret_any},
 234         {"__raw_write_lock",          LOCK,   "write_lock", 0, ret_any},
 235         {"_raw_write_unlock",         UNLOCK, "write_lock", 0, ret_any},
 236         {"__raw_write_unlock",        UNLOCK, "write_lock", 0, ret_any},
 237 
 238         {"write_trylock",             LOCK,   "write_lock", 0, ret_one},
 239         {"_write_trylock",            LOCK,   "write_lock", 0, ret_one},
 240         {"raw_write_trylock",         LOCK,   "write_lock", 0, ret_one},
 241         {"_raw_write_trylock",        LOCK,   "write_lock", 0, ret_one},
 242         {"__write_trylock",           LOCK,   "write_lock", 0, ret_one},
 243         {"__raw_write_trylock",       LOCK,   "write_lock", 0, ret_one},
 244 
 245         {"down",               LOCK,   "sem", 0, ret_any},
 246         {"up",                 UNLOCK, "sem", 0, ret_any},
 247         {"down_trylock",       LOCK,   "sem", 0, ret_zero},
 248         {"down_timeout",       LOCK,   "sem", 0, ret_zero},
 249         {"down_interruptible", LOCK,   "sem", 0, ret_zero},
 250 
 251 
 252         {"down_write",          LOCK,   "rw_sem", 0, ret_any},
 253         {"downgrade_write",     UNLOCK, "rw_sem", 0, ret_any},
 254         {"downgrade_write",     LOCK,   "read_sem", 0, ret_any},
 255         {"up_write",            UNLOCK, "rw_sem", 0, ret_any},
 256         {"down_write_trylock",  LOCK,   "rw_sem", 0, ret_one},
 257         {"down_write_killable", LOCK,   "rw_sem", 0, ret_zero},
 258         {"down_read",           LOCK,   "read_sem", 0, ret_any},
 259         {"down_read_trylock",   LOCK,   "read_sem", 0, ret_one},
 260         {"down_read_killable",  LOCK,   "read_sem", 0, ret_zero},
 261         {"up_read",             UNLOCK, "read_sem", 0, ret_any},
 262 
 263         {"mutex_lock",                      LOCK,   "mutex", 0, ret_any},
 264         {"mutex_lock_io",                   LOCK,   "mutex", 0, ret_any},
 265         {"mutex_unlock",                    UNLOCK, "mutex", 0, ret_any},
 266         {"mutex_lock_nested",               LOCK,   "mutex", 0, ret_any},
 267         {"mutex_lock_io_nested",            LOCK,   "mutex", 0, ret_any},
 268 
 269         {"mutex_lock_interruptible",        LOCK,   "mutex", 0, ret_zero},
 270         {"mutex_lock_interruptible_nested", LOCK,   "mutex", 0, ret_zero},
 271         {"mutex_lock_killable",             LOCK,   "mutex", 0, ret_zero},
 272         {"mutex_lock_killable_nested",      LOCK,   "mutex", 0, ret_zero},
 273 
 274         {"mutex_trylock",                   LOCK,   "mutex", 0, ret_one},
 275 
 276         {"raw_local_irq_disable", LOCK,   "irq", NO_ARG, ret_any},
 277         {"raw_local_irq_enable",  UNLOCK, "irq", NO_ARG, ret_any},
 278         {"spin_lock_irq",         LOCK,   "irq", NO_ARG, ret_any},
 279         {"spin_unlock_irq",       UNLOCK, "irq", NO_ARG, ret_any},
 280         {"_spin_lock_irq",        LOCK,   "irq", NO_ARG, ret_any},
 281         {"_spin_unlock_irq",      UNLOCK, "irq", NO_ARG, ret_any},
 282         {"__spin_lock_irq",       LOCK,   "irq", NO_ARG, ret_any},
 283         {"__spin_unlock_irq",     UNLOCK, "irq", NO_ARG, ret_any},
 284         {"_raw_spin_lock_irq",    LOCK,   "irq", NO_ARG, ret_any},
 285         {"_raw_spin_unlock_irq",  UNLOCK, "irq", NO_ARG, ret_any},
 286         {"__raw_spin_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
 287         {"spin_trylock_irq",      LOCK,   "irq", NO_ARG, ret_one},
 288         {"read_lock_irq",         LOCK,   "irq", NO_ARG, ret_any},
 289         {"read_unlock_irq",       UNLOCK, "irq", NO_ARG, ret_any},
 290         {"_read_lock_irq",        LOCK,   "irq", NO_ARG, ret_any},
 291         {"_read_unlock_irq",      UNLOCK, "irq", NO_ARG, ret_any},
 292         {"__read_lock_irq",       LOCK,   "irq", NO_ARG, ret_any},
 293         {"__read_unlock_irq",     UNLOCK, "irq", NO_ARG, ret_any},
 294         {"write_lock_irq",        LOCK,   "irq", NO_ARG, ret_any},
 295         {"write_unlock_irq",      UNLOCK, "irq", NO_ARG, ret_any},
 296         {"_write_lock_irq",       LOCK,   "irq", NO_ARG, ret_any},
 297         {"_write_unlock_irq",     UNLOCK, "irq", NO_ARG, ret_any},
 298         {"__write_lock_irq",      LOCK,   "irq", NO_ARG, ret_any},
 299         {"__write_unlock_irq",    UNLOCK, "irq", NO_ARG, ret_any},
 300 
 301         {"arch_local_irq_save",        LOCK,   "irqsave", RETURN_VAL, ret_any},
 302         {"arch_local_irq_restore",     UNLOCK, "irqsave", 0, ret_any},
 303         {"__raw_local_irq_save",       LOCK,   "irqsave", RETURN_VAL, ret_any},
 304         {"raw_local_irq_restore",      UNLOCK, "irqsave", 0, ret_any},
 305         {"spin_lock_irqsave_nested",   LOCK,   "irqsave", RETURN_VAL, ret_any},
 306         {"spin_lock_irqsave",          LOCK,   "irqsave", RETURN_VAL, ret_any},
 307         {"spin_lock_irqsave",          LOCK,   "irqsave", 1, ret_any},
 308         {"spin_unlock_irqrestore",     UNLOCK, "irqsave", 1, ret_any},
 309         {"_spin_lock_irqsave_nested",  LOCK,   "irqsave", RETURN_VAL, ret_any},
 310         {"_spin_lock_irqsave",         LOCK,   "irqsave", RETURN_VAL, ret_any},
 311         {"_spin_lock_irqsave",         LOCK,   "irqsave", 1, ret_any},
 312         {"_spin_unlock_irqrestore",    UNLOCK, "irqsave", 1, ret_any},
 313         {"__spin_lock_irqsave_nested", LOCK,   "irqsave", 1, ret_any},
 314         {"__spin_lock_irqsave",        LOCK,   "irqsave", 1, ret_any},
 315         {"__spin_unlock_irqrestore",   UNLOCK, "irqsave", 1, ret_any},
 316         {"_raw_spin_lock_irqsave",     LOCK,   "irqsave", RETURN_VAL, ret_any},
 317         {"_raw_spin_lock_irqsave",     LOCK,   "irqsave", 1, ret_any},
 318         {"_raw_spin_unlock_irqrestore",UNLOCK, "irqsave", 1, ret_any},
 319         {"__raw_spin_lock_irqsave",    LOCK,   "irqsave", RETURN_VAL, ret_any},
 320         {"__raw_spin_unlock_irqrestore",UNLOCK, "irqsave", 1, ret_any},
 321         {"_raw_spin_lock_irqsave_nested", LOCK, "irqsave", RETURN_VAL, ret_any},
 322         {"spin_trylock_irqsave",       LOCK,   "irqsave", 1, ret_one},
 323         {"read_lock_irqsave",          LOCK,   "irqsave", RETURN_VAL, ret_any},
 324         {"read_lock_irqsave",          LOCK,   "irqsave", 1, ret_any},
 325         {"read_unlock_irqrestore",     UNLOCK, "irqsave", 1, ret_any},
 326         {"_read_lock_irqsave",         LOCK,   "irqsave", RETURN_VAL, ret_any},
 327         {"_read_lock_irqsave",         LOCK,   "irqsave", 1, ret_any},
 328         {"_read_unlock_irqrestore",    UNLOCK, "irqsave", 1, ret_any},
 329         {"__read_lock_irqsave",        LOCK,   "irqsave", RETURN_VAL, ret_any},
 330         {"__read_unlock_irqrestore",   UNLOCK, "irqsave", 1, ret_any},
 331         {"write_lock_irqsave",         LOCK,   "irqsave", RETURN_VAL, ret_any},
 332         {"write_lock_irqsave",         LOCK,   "irqsave", 1, ret_any},
 333         {"write_unlock_irqrestore",    UNLOCK, "irqsave", 1, ret_any},
 334         {"_write_lock_irqsave",        LOCK,   "irqsave", RETURN_VAL, ret_any},
 335         {"_write_lock_irqsave",        LOCK,   "irqsave", 1, ret_any},
 336         {"_write_unlock_irqrestore",   UNLOCK, "irqsave", 1, ret_any},
 337         {"__write_lock_irqsave",       LOCK,   "irqsave", RETURN_VAL, ret_any},
 338         {"__write_unlock_irqrestore",  UNLOCK, "irqsave", 1, ret_any},
 339 
 340         {"local_bh_disable",    LOCK,   "bottom_half", NO_ARG, ret_any},
 341         {"_local_bh_disable",   LOCK,   "bottom_half", NO_ARG, ret_any},
 342         {"__local_bh_disable",  LOCK,   "bottom_half", NO_ARG, ret_any},


 346         {"spin_lock_bh",        LOCK,   "bottom_half", NO_ARG, ret_any},
 347         {"spin_unlock_bh",      UNLOCK, "bottom_half", NO_ARG, ret_any},
 348         {"_spin_lock_bh",       LOCK,   "bottom_half", NO_ARG, ret_any},
 349         {"_spin_unlock_bh",     UNLOCK, "bottom_half", NO_ARG, ret_any},
 350         {"__spin_lock_bh",      LOCK,   "bottom_half", NO_ARG, ret_any},
 351         {"__spin_unlock_bh",    UNLOCK, "bottom_half", NO_ARG, ret_any},
 352         {"read_lock_bh",        LOCK,   "bottom_half", NO_ARG, ret_any},
 353         {"read_unlock_bh",      UNLOCK, "bottom_half", NO_ARG, ret_any},
 354         {"_read_lock_bh",       LOCK,   "bottom_half", NO_ARG, ret_any},
 355         {"_read_unlock_bh",     UNLOCK, "bottom_half", NO_ARG, ret_any},
 356         {"__read_lock_bh",      LOCK,   "bottom_half", NO_ARG, ret_any},
 357         {"__read_unlock_bh",    UNLOCK, "bottom_half", NO_ARG, ret_any},
 358         {"_raw_read_lock_bh",   LOCK,   "bottom_half", NO_ARG, ret_any},
 359         {"_raw_read_unlock_bh", UNLOCK, "bottom_half", NO_ARG, ret_any},
 360         {"write_lock_bh",       LOCK,   "bottom_half", NO_ARG, ret_any},
 361         {"write_unlock_bh",     UNLOCK, "bottom_half", NO_ARG, ret_any},
 362         {"_write_lock_bh",      LOCK,   "bottom_half", NO_ARG, ret_any},
 363         {"_write_unlock_bh",    UNLOCK, "bottom_half", NO_ARG, ret_any},
 364         {"__write_lock_bh",     LOCK,   "bottom_half", NO_ARG, ret_any},
 365         {"__write_unlock_bh",   UNLOCK, "bottom_half", NO_ARG, ret_any},
 366         {"spin_trylock_bh",     LOCK,   "bottom_half", NO_ARG, ret_one},
 367         {"_spin_trylock_bh",    LOCK,   "bottom_half", NO_ARG, ret_one},
 368         {"__spin_trylock_bh",   LOCK,   "bottom_half", NO_ARG, ret_one},
 369 
 370         {"ffs_mutex_lock",        LOCK,   "mutex", 0, ret_zero},
 371 };
 372 
 373 static struct lock_info *lock_table;
 374 
 375 static struct tracker_list *starts_locked;
 376 static struct tracker_list *starts_unlocked;
 377 
 378 struct locks_on_return {
 379         int line;
 380         struct tracker_list *locked;
 381         struct tracker_list *unlocked;
 382         struct tracker_list *impossible;
 383         struct range_list *return_values;
 384 };
 385 DECLARE_PTR_LIST(return_list, struct locks_on_return);
 386 static struct return_list *all_returns;
 387 
 388 static char *make_full_name(const char *lock, const char *var)


 445         if (is_locked && is_unlocked)
 446                 return &undefined;
 447         if (is_locked)
 448                 return &locked;
 449         if (is_unlocked)
 450                 return &unlocked;
 451         return &undefined;
 452 }
 453 
 454 static struct smatch_state *unmatched_state(struct sm_state *sm)
 455 {
 456         return &start_state;
 457 }
 458 
 459 static void pre_merge_hook(struct sm_state *sm)
 460 {
 461         if (is_impossible_path())
 462                 set_state(my_id, sm->name, sm->sym, &impossible);
 463 }
 464 
 465 static bool nestable(const char *name)
 466 {
 467         if (strstr(name, "read_sem:"))
 468                 return true;
 469         if (strcmp(name, "bottom_half:") == 0)
 470                 return true;
 471         return false;
 472 }
 473 
 474 static void do_lock(const char *name)
 475 {
 476         struct sm_state *sm;
 477 
 478         if (__inline_fn)
 479                 return;
 480 
 481         sm = get_sm_state(my_id, name, NULL);
 482         if (!sm)
 483                 add_tracker(&starts_unlocked, my_id, name, NULL);
 484         if (sm && slist_has_state(sm->possible, &locked) && !nestable(name))

 485                 sm_error("double lock '%s'", name);
 486         if (sm)
 487                 func_has_transition = TRUE;
 488         set_state(my_id, name, NULL, &locked);
 489 }
 490 
 491 static void do_lock_failed(const char *name)
 492 {
 493         struct sm_state *sm;
 494 
 495         if (__inline_fn)
 496                 return;
 497 
 498         sm = get_sm_state(my_id, name, NULL);
 499         if (!sm)
 500                 add_tracker(&starts_unlocked, my_id, name, NULL);
 501         set_state(my_id, name, NULL, &unlocked);
 502 }
 503 
 504 static void do_unlock(const char *name)


 750                         if (i++)
 751                                 sm_printf("               ");
 752                         sm_printf("line %d\n", tmp->line);
 753                         add_line(&printed, tmp->line);
 754                         continue;
 755                 }
 756                 if (in_tracker_list(tmp->locked, lock->owner, lock->name, lock->sym))
 757                         continue;
 758                 if (start == &unlocked) {
 759                         if (i++)
 760                                 sm_printf("               ");
 761                         sm_printf("line %d\n", tmp->line);
 762                         add_line(&printed, tmp->line);
 763                 }
 764         } END_FOR_EACH_PTR(tmp);
 765 }
 766 
 767 static int matches_return_type(struct range_list *rl, enum return_type type)
 768 {
 769         sval_t zero_sval = ll_to_sval(0);
 770         sval_t one_sval = ll_to_sval(1);
 771 
 772         /* All these double negatives are super ugly!  */
 773 
 774         switch (type) {
 775         case ret_zero:
 776                 return !possibly_true_rl(rl, SPECIAL_NOTEQUAL, alloc_rl(zero_sval, zero_sval));
 777         case ret_one:
 778                 return !possibly_true_rl(rl, SPECIAL_NOTEQUAL, alloc_rl(one_sval, one_sval));
 779         case ret_non_zero:
 780                 return !possibly_true_rl(rl, SPECIAL_EQUAL, alloc_rl(zero_sval, zero_sval));
 781         case ret_negative:
 782                 return !possibly_true_rl(rl, SPECIAL_GTE, alloc_rl(zero_sval, zero_sval));
 783         case ret_positive:
 784                 return !possibly_true_rl(rl, '<', alloc_rl(zero_sval, zero_sval));
 785         case ret_any:
 786         default:
 787                 return 1;
 788         }
 789 }
 790 
 791 static int match_held(struct tracker *lock, struct locks_on_return *this_return, struct smatch_state *start)
 792 {
 793         if (in_tracker_list(this_return->impossible, lock->owner, lock->name, lock->sym))
 794                 return 0;
 795         if (in_tracker_list(this_return->unlocked, lock->owner, lock->name, lock->sym))
 796                 return 0;
 797         if (in_tracker_list(this_return->locked, lock->owner, lock->name, lock->sym))
 798                 return 1;


 915         if (__inline_fn)
 916                 return;
 917 
 918         if (func_has_transition)
 919                 check_consistency(sym);
 920 }
 921 
 922 static void match_after_func(struct symbol *sym)
 923 {
 924         if (__inline_fn)
 925                 return;
 926         clear_lists();
 927 }
 928 
 929 static void register_lock(int index)
 930 {
 931         struct lock_info *lock = &lock_table[index];
 932         void *idx = INT_PTR(index);
 933 
 934         if (lock->return_type == ret_non_zero) {
 935                 return_implies_state(lock->function, 1, INT_MAX, &match_lock_held, idx);
 936                 return_implies_state(lock->function, 0, 0, &match_lock_failed, idx);
 937         } else if (lock->return_type == ret_any && lock->arg == RETURN_VAL) {
 938                 add_function_assign_hook(lock->function, &match_returns_locked, idx);
 939         } else if (lock->return_type == ret_any) {
 940                 add_function_hook(lock->function, &match_lock_unlock, idx);
 941         } else if (lock->return_type == ret_zero) {
 942                 return_implies_state(lock->function, 0, 0, &match_lock_held, idx);
 943                 return_implies_state(lock->function, -4095, -1, &match_lock_failed, idx);
 944         } else if (lock->return_type == ret_one) {
 945                 return_implies_state(lock->function, 1, 1, &match_lock_held, idx);
 946                 return_implies_state(lock->function, 0, 0, &match_lock_failed, idx);
 947         }
 948 }
 949 
 950 static void load_table(struct lock_info *_lock_table, int size)
 951 {
 952         int i;
 953 
 954         lock_table = _lock_table;
 955 
 956         for (i = 0; i < size; i++) {
 957                 if (lock_table[i].action == LOCK)
 958                         register_lock(i);
 959                 else
 960                         add_function_hook(lock_table[i].function, &match_lock_unlock, INT_PTR(i));
 961         }
 962 }
 963 
 964 /* print_held_locks() is used in check_call_tree.c */
 965 void print_held_locks(void)
 966 {