check_locking.c

   1 /*
   2  * sparse/check_locking.c
   3  *
   4  * Copyright (C) 2009 Dan Carpenter.
   5  *
   6  *  Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 /*
  11  * This test checks that locks are held the same across all returns.
  12  *
  13  * Of course, some functions are designed to only hold the locks on success.
  14  * Oh well... We can rewrite it later if we want.
  15  *
  16  * The list of wine locking functions came from an earlier script written
  17  * by Michael Stefaniuc.
  18  *
  19  */
  20
  21 #include "parse.h"
  22 #include "smatch.h"
  23 #include "smatch_slist.h"
  24
  25 static int my_id;
  26
  27 STATE(locked);
  28 STATE(start_state);
  29 STATE(unlocked);
  30
  31 enum action {
  32         LOCK,
  33         UNLOCK,
  34 };
  35
  36 enum return_type {
  37         ret_any,
  38         ret_non_zero,
  39         ret_zero,
  40 };
  41
  42 #define RETURN_VAL -1
  43 #define NO_ARG -2
  44
  45 struct lock_info {
  46         const char *function;
  47         enum action action;
  48         const char *name;
  49         int arg;
  50         enum return_type return_type;
  51 };
  52
  53 static struct lock_info wine_lock_table[] = {
  54         {"create_window_handle", LOCK, "create_window_handle", RETURN_VAL, ret_non_zero},
  55         {"WIN_GetPtr", LOCK, "create_window_handle", RETURN_VAL, ret_non_zero},
  56         {"WIN_ReleasePtr", UNLOCK, "create_window_handle", 0, ret_any},
  57         {"EnterCriticalSection", LOCK, "CriticalSection", 0, ret_any},
  58         {"LeaveCriticalSection", UNLOCK, "CriticalSection", 0, ret_any},
  59         {"RtlEnterCriticalSection", LOCK, "RtlCriticalSection", 0, ret_any},
  60         {"RtlLeaveCriticalSection", UNLOCK, "RtlCriticalSection", 0, ret_any},
  61         {"GDI_GetObjPtr", LOCK, "GDI_Get", 0, ret_non_zero},
  62         {"GDI_ReleaseObj", UNLOCK, "GDI_Get", 0, ret_any},
  63         {"LdrLockLoaderLock", LOCK, "LdrLockLoaderLock", 2, ret_any},
  64         {"LdrUnlockLoaderLock", UNLOCK, "LdrLockLoaderLock", 1, ret_any},
  65         {"_lock", LOCK, "_lock", 0, ret_any},
  66         {"_unlock", UNLOCK, "_lock", 0, ret_any},
  67         {"msiobj_lock", LOCK, "msiobj_lock", 0, ret_any},
  68         {"msiobj_unlock", UNLOCK, "msiobj_lock", 0, ret_any},
  69         {"RtlAcquirePebLock", LOCK, "PebLock", NO_ARG, ret_any},
  70         {"RtlReleasePebLock", UNLOCK, "PebLock", NO_ARG, ret_any},
  71         {"server_enter_uninterrupted_section", LOCK, "server_uninterrupted_section", 0, ret_any},
  72         {"server_leave_uninterrupted_section", UNLOCK, "server_uninterrupted_section", 0, ret_any},
  73         {"RtlLockHeap", LOCK, "RtlLockHeap", 0, ret_any},
  74         {"RtlUnlockHeap", UNLOCK, "RtlLockHeap", 0, ret_any},
  75         {"_EnterSysLevel", LOCK, "SysLevel", 0, ret_any},
  76         {"_LeaveSysLevel", UNLOCK, "SysLevel", 0, ret_any},
  77         {"USER_Lock", LOCK, "USER_Lock", NO_ARG, ret_any},
  78         {"USER_Unlock", UNLOCK, "USER_Lock", NO_ARG, ret_any},
  79         {"wine_tsx11_lock", LOCK, "wine_tsx11_lock", NO_ARG, ret_any},
  80         {"wine_tsx11_unlock", UNLOCK, "wine_tsx11_lock", NO_ARG, ret_any},
  81         {"wine_tsx11_lock_ptr", LOCK, "wine_tsx11_lock_ptr", NO_ARG, ret_any},
  82         {"wine_tsx11_unlock_ptr", UNLOCK, "wine_tsx11_lock_ptr", NO_ARG, ret_any},
  83         {"wined3d_mutex_lock", LOCK, "wined3d_mutex_lock", NO_ARG, ret_any},
  84         {"wined3d_mutex_unlock", UNLOCK, "wined3d_mutex_lock", NO_ARG, ret_any},
  85         {"X11DRV_DIB_Lock", LOCK, "X11DRV_DIB_Lock", 0, ret_any},
  86         {"X11DRV_DIB_Unlock", UNLOCK, "X11DRV_DIB_Lock", 0, ret_any},
  87 };
  88
  89 static struct lock_info kernel_lock_table[] = {
  90         {"lock_kernel",   LOCK,   "BKL", NO_ARG, ret_any},
  91         {"unlock_kernel", UNLOCK, "BKL", NO_ARG, ret_any},
  92
  93         {"spin_lock",                  LOCK,   "spin_lock", 0, ret_any},
  94         {"spin_unlock",                UNLOCK, "spin_lock", 0, ret_any},
  95         {"spin_lock_nested",           LOCK,   "spin_lock", 0, ret_any},
  96         {"_spin_lock",                 LOCK,   "spin_lock", 0, ret_any},
  97         {"_spin_unlock",               UNLOCK, "spin_lock", 0, ret_any},
  98         {"_spin_lock_nested",          LOCK,   "spin_lock", 0, ret_any},
  99         {"__spin_lock",                LOCK,   "spin_lock", 0, ret_any},
 100         {"__spin_unlock",              UNLOCK, "spin_lock", 0, ret_any},
 101         {"__spin_lock_nested",         LOCK,   "spin_lock", 0, ret_any},
 102         {"raw_spin_lock",              LOCK,   "spin_lock", 0, ret_any},
 103         {"raw_spin_unlock",            UNLOCK, "spin_lock", 0, ret_any},
 104         {"_raw_spin_lock",             LOCK,   "spin_lock", 0, ret_any},
 105         {"_raw_spin_lock_nested",      LOCK,   "spin_lock", 0, ret_any},
 106         {"_raw_spin_unlock",           UNLOCK, "spin_lock", 0, ret_any},
 107         {"__raw_spin_lock",            LOCK,   "spin_lock", 0, ret_any},
 108         {"__raw_spin_unlock",          UNLOCK, "spin_lock", 0, ret_any},
 109
 110         {"spin_lock_irq",              LOCK,   "spin_lock", 0, ret_any},
 111         {"spin_unlock_irq",            UNLOCK, "spin_lock", 0, ret_any},
 112         {"_spin_lock_irq",             LOCK,   "spin_lock", 0, ret_any},
 113         {"_spin_unlock_irq",           UNLOCK, "spin_lock", 0, ret_any},
 114         {"__spin_lock_irq",            LOCK,   "spin_lock", 0, ret_any},
 115         {"__spin_unlock_irq",          UNLOCK, "spin_lock", 0, ret_any},
 116         {"_raw_spin_lock_irq",         LOCK,   "spin_lock", 0, ret_any},
 117         {"_raw_spin_unlock_irq",       UNLOCK, "spin_lock", 0, ret_any},
 118         {"__raw_spin_unlock_irq",      UNLOCK, "spin_lock", 0, ret_any},
 119         {"spin_lock_irqsave",          LOCK,   "spin_lock", 0, ret_any},
 120         {"spin_unlock_irqrestore",     UNLOCK, "spin_lock", 0, ret_any},
 121         {"_spin_lock_irqsave",         LOCK,   "spin_lock", 0, ret_any},
 122         {"_spin_unlock_irqrestore",    UNLOCK, "spin_lock", 0, ret_any},
 123         {"__spin_lock_irqsave",        LOCK,   "spin_lock", 0, ret_any},
 124         {"__spin_unlock_irqrestore",   UNLOCK, "spin_lock", 0, ret_any},
 125         {"_raw_spin_lock_irqsave",     LOCK,   "spin_lock", 0, ret_any},
 126         {"_raw_spin_unlock_irqrestore", UNLOCK, "spin_lock", 0, ret_any},
 127         {"__raw_spin_lock_irqsave",    LOCK,   "spin_lock", 0, ret_any},
 128         {"__raw_spin_unlock_irqrestore", UNLOCK, "spin_lock", 0, ret_any},
 129         {"spin_lock_irqsave_nested",   LOCK,   "spin_lock", 0, ret_any},
 130         {"_spin_lock_irqsave_nested",  LOCK,   "spin_lock", 0, ret_any},
 131         {"__spin_lock_irqsave_nested", LOCK,   "spin_lock", 0, ret_any},
 132         {"_raw_spin_lock_irqsave_nested", LOCK, "spin_lock", 0, ret_any},
 133         {"spin_lock_bh",               LOCK,   "spin_lock", 0, ret_any},
 134         {"spin_unlock_bh",             UNLOCK, "spin_lock", 0, ret_any},
 135         {"_spin_lock_bh",              LOCK,   "spin_lock", 0, ret_any},
 136         {"_spin_unlock_bh",            UNLOCK, "spin_lock", 0, ret_any},
 137         {"__spin_lock_bh",             LOCK,   "spin_lock", 0, ret_any},
 138         {"__spin_unlock_bh",           UNLOCK, "spin_lock", 0, ret_any},
 139
 140         {"spin_trylock",               LOCK,   "spin_lock", 0, ret_non_zero},
 141         {"_spin_trylock",              LOCK,   "spin_lock", 0, ret_non_zero},
 142         {"__spin_trylock",             LOCK,   "spin_lock", 0, ret_non_zero},
 143         {"raw_spin_trylock",           LOCK,   "spin_lock", 0, ret_non_zero},
 144         {"_raw_spin_trylock",          LOCK,   "spin_lock", 0, ret_non_zero},
 145         {"spin_trylock_irq",           LOCK,   "spin_lock", 0, ret_non_zero},
 146         {"spin_trylock_irqsave",       LOCK,   "spin_lock", 0, ret_non_zero},
 147         {"spin_trylock_bh",            LOCK,   "spin_lock", 0, ret_non_zero},
 148         {"_spin_trylock_bh",           LOCK,   "spin_lock", 0, ret_non_zero},
 149         {"__spin_trylock_bh",          LOCK,   "spin_lock", 0, ret_non_zero},
 150         {"__raw_spin_trylock",         LOCK,   "spin_lock", 0, ret_non_zero},
 151         {"_atomic_dec_and_lock",       LOCK,   "spin_lock", 1, ret_non_zero},
 152
 153         {"read_lock",                 LOCK,   "read_lock", 0, ret_any},
 154         {"read_unlock",               UNLOCK, "read_lock", 0, ret_any},
 155         {"_read_lock",                LOCK,   "read_lock", 0, ret_any},
 156         {"_read_unlock",              UNLOCK, "read_lock", 0, ret_any},
 157         {"__read_lock",               LOCK,   "read_lock", 0, ret_any},
 158         {"__read_unlock",             UNLOCK, "read_lock", 0, ret_any},
 159         {"read_lock_irq",             LOCK,   "read_lock", 0, ret_any},
 160         {"read_unlock_irq" ,          UNLOCK, "read_lock", 0, ret_any},
 161         {"_read_lock_irq",            LOCK,   "read_lock", 0, ret_any},
 162         {"_read_unlock_irq",          UNLOCK, "read_lock", 0, ret_any},
 163         {"__read_lock_irq",           LOCK,   "read_lock", 0, ret_any},
 164         {"__read_unlock_irq",         UNLOCK, "read_lock", 0, ret_any},
 165         {"read_lock_irqsave",         LOCK,   "read_lock", 0, ret_any},
 166         {"read_unlock_irqrestore",    UNLOCK, "read_lock", 0, ret_any},
 167         {"_read_lock_irqsave",        LOCK,   "read_lock", 0, ret_any},
 168         {"_read_unlock_irqrestore",   UNLOCK, "read_lock", 0, ret_any},
 169         {"__read_lock_irqsave",       LOCK,   "read_lock", 0, ret_any},
 170         {"__read_unlock_irqrestore",  UNLOCK, "read_lock", 0, ret_any},
 171         {"read_lock_bh",              LOCK,   "read_lock", 0, ret_any},
 172         {"read_unlock_bh",            UNLOCK, "read_lock", 0, ret_any},
 173         {"_read_lock_bh",             LOCK,   "read_lock", 0, ret_any},
 174         {"_read_unlock_bh",           UNLOCK, "read_lock", 0, ret_any},
 175         {"__read_lock_bh",            LOCK,   "read_lock", 0, ret_any},
 176         {"__read_unlock_bh",          UNLOCK, "read_lock", 0, ret_any},
 177
 178         {"generic__raw_read_trylock", LOCK,   "read_lock", 0, ret_non_zero},
 179         {"read_trylock",              LOCK,   "read_lock", 0, ret_non_zero},
 180         {"_read_trylock",             LOCK,   "read_lock", 0, ret_non_zero},
 181         {"raw_read_trylock",          LOCK,   "read_lock", 0, ret_non_zero},
 182         {"_raw_read_trylock",         LOCK,   "read_lock", 0, ret_non_zero},
 183         {"__raw_read_trylock",        LOCK,   "read_lock", 0, ret_non_zero},
 184         {"__read_trylock",            LOCK,   "read_lock", 0, ret_non_zero},
 185
 186         {"write_lock",                LOCK,   "write_lock", 0, ret_any},
 187         {"write_unlock",              UNLOCK, "write_lock", 0, ret_any},
 188         {"_write_lock",               LOCK,   "write_lock", 0, ret_any},
 189         {"_write_unlock",             UNLOCK, "write_lock", 0, ret_any},
 190         {"__write_lock",              LOCK,   "write_lock", 0, ret_any},
 191         {"__write_unlock",            UNLOCK, "write_lock", 0, ret_any},
 192         {"write_lock_irq",            LOCK,   "write_lock", 0, ret_any},
 193         {"write_unlock_irq",          UNLOCK, "write_lock", 0, ret_any},
 194         {"_write_lock_irq",           LOCK,   "write_lock", 0, ret_any},
 195         {"_write_unlock_irq",         UNLOCK, "write_lock", 0, ret_any},
 196         {"__write_lock_irq",          LOCK,   "write_lock", 0, ret_any},
 197         {"__write_unlock_irq",        UNLOCK, "write_lock", 0, ret_any},
 198         {"write_lock_irqsave",        LOCK,   "write_lock", 0, ret_any},
 199         {"write_unlock_irqrestore",   UNLOCK, "write_lock", 0, ret_any},
 200         {"_write_lock_irqsave",       LOCK,   "write_lock", 0, ret_any},
 201         {"_write_unlock_irqrestore",  UNLOCK, "write_lock", 0, ret_any},
 202         {"__write_lock_irqsave",      LOCK,   "write_lock", 0, ret_any},
 203         {"__write_unlock_irqrestore", UNLOCK, "write_lock", 0, ret_any},
 204         {"write_lock_bh",             LOCK,   "write_lock", 0, ret_any},
 205         {"write_unlock_bh",           UNLOCK, "write_lock", 0, ret_any},
 206         {"_write_lock_bh",            LOCK,   "write_lock", 0, ret_any},
 207         {"_write_unlock_bh",          UNLOCK, "write_lock", 0, ret_any},
 208         {"__write_lock_bh",           LOCK,   "write_lock", 0, ret_any},
 209         {"__write_unlock_bh",         UNLOCK, "write_lock", 0, ret_any},
 210
 211         {"write_trylock",             LOCK,   "write_lock", 0, ret_non_zero},
 212         {"_write_trylock",            LOCK,   "write_lock", 0, ret_non_zero},
 213         {"raw_write_trylock",         LOCK,   "write_lock", 0, ret_non_zero},
 214         {"_raw_write_trylock",        LOCK,   "write_lock", 0, ret_non_zero},
 215         {"__write_trylock",           LOCK,   "write_lock", 0, ret_non_zero},
 216         {"__raw_write_trylock",       LOCK,   "write_lock", 0, ret_non_zero},
 217
 218         {"down",               LOCK,   "sem", 0, ret_any},
 219         {"up",                 UNLOCK, "sem", 0, ret_any},
 220         {"down_trylock",       LOCK,   "sem", 0, ret_zero},
 221         {"down_interruptible", LOCK,   "sem", 0, ret_zero},
 222
 223         {"mutex_lock",                      LOCK,   "mutex", 0, ret_any},
 224         {"mutex_unlock",                    UNLOCK, "mutex", 0, ret_any},
 225         {"mutex_lock_nested",               LOCK,   "mutex", 0, ret_any},
 226
 227         {"mutex_lock_interruptible",        LOCK,   "mutex", 0, ret_zero},
 228         {"mutex_lock_interruptible_nested", LOCK,   "mutex", 0, ret_zero},
 229         {"mutex_lock_killable",             LOCK,   "mutex", 0, ret_zero},
 230         {"mutex_lock_killable_nested",      LOCK,   "mutex", 0, ret_zero},
 231
 232         {"mutex_trylock",                   LOCK,   "mutex", 0, ret_non_zero},
 233
 234         {"raw_local_irq_disable", LOCK,   "irq", NO_ARG, ret_any},
 235         {"raw_local_irq_enable",  UNLOCK, "irq", NO_ARG, ret_any},
 236         {"spin_lock_irq",         LOCK,   "irq", NO_ARG, ret_any},
 237         {"spin_unlock_irq",       UNLOCK, "irq", NO_ARG, ret_any},
 238         {"_spin_lock_irq",        LOCK,   "irq", NO_ARG, ret_any},
 239         {"_spin_unlock_irq",      UNLOCK, "irq", NO_ARG, ret_any},
 240         {"__spin_lock_irq",       LOCK,   "irq", NO_ARG, ret_any},
 241         {"__spin_unlock_irq",     UNLOCK, "irq", NO_ARG, ret_any},
 242         {"_raw_spin_lock_irq",    LOCK,   "irq", NO_ARG, ret_any},
 243         {"_raw_spin_unlock_irq",  UNLOCK, "irq", NO_ARG, ret_any},
 244         {"__raw_spin_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
 245         {"spin_trylock_irq",      LOCK,   "irq", NO_ARG, ret_non_zero},
 246         {"read_lock_irq",         LOCK,   "irq", NO_ARG, ret_any},
 247         {"read_unlock_irq",       UNLOCK, "irq", NO_ARG, ret_any},
 248         {"_read_lock_irq",        LOCK,   "irq", NO_ARG, ret_any},
 249         {"_read_unlock_irq",      UNLOCK, "irq", NO_ARG, ret_any},
 250         {"__read_lock_irq",       LOCK,   "irq", NO_ARG, ret_any},
 251         {"__read_unlock_irq",     UNLOCK, "irq", NO_ARG, ret_any},
 252         {"write_lock_irq",        LOCK,   "irq", NO_ARG, ret_any},
 253         {"write_unlock_irq",      UNLOCK, "irq", NO_ARG, ret_any},
 254         {"_write_lock_irq",       LOCK,   "irq", NO_ARG, ret_any},
 255         {"_write_unlock_irq",     UNLOCK, "irq", NO_ARG, ret_any},
 256         {"__write_lock_irq",      LOCK,   "irq", NO_ARG, ret_any},
 257         {"__write_unlock_irq",    UNLOCK, "irq", NO_ARG, ret_any},
 258
 259         {"arch_local_irq_save",        LOCK,   "irqsave", RETURN_VAL, ret_any},
 260         {"arch_local_irq_restore",     UNLOCK, "irqsave", 0, ret_any},
 261         {"__raw_local_irq_save",       LOCK,   "irqsave", RETURN_VAL, ret_any},
 262         {"raw_local_irq_restore",      UNLOCK, "irqsave", 0, ret_any},
 263         {"spin_lock_irqsave_nested",   LOCK,   "irqsave", RETURN_VAL, ret_any},
 264         {"spin_lock_irqsave",          LOCK,   "irqsave", RETURN_VAL, ret_any},
 265         {"spin_lock_irqsave",          LOCK,   "irqsave", 1, ret_any},
 266         {"spin_unlock_irqrestore",     UNLOCK, "irqsave", 1, ret_any},
 267         {"_spin_lock_irqsave_nested",  LOCK,   "irqsave", RETURN_VAL, ret_any},
 268         {"_spin_lock_irqsave",         LOCK,   "irqsave", RETURN_VAL, ret_any},
 269         {"_spin_lock_irqsave",         LOCK,   "irqsave", 1, ret_any},
 270         {"_spin_unlock_irqrestore",    UNLOCK, "irqsave", 1, ret_any},
 271         {"__spin_lock_irqsave_nested", LOCK,   "irqsave", 1, ret_any},
 272         {"__spin_lock_irqsave",        LOCK,   "irqsave", 1, ret_any},
 273         {"__spin_unlock_irqrestore",   UNLOCK, "irqsave", 1, ret_any},
 274         {"_raw_spin_lock_irqsave",     LOCK,   "irqsave", RETURN_VAL, ret_any},
 275         {"_raw_spin_lock_irqsave",     LOCK,   "irqsave", 1, ret_any},
 276         {"_raw_spin_unlock_irqrestore",UNLOCK, "irqsave", 1, ret_any},
 277         {"__raw_spin_lock_irqsave",    LOCK,   "irqsave", RETURN_VAL, ret_any},
 278         {"__raw_spin_unlock_irqrestore",UNLOCK, "irqsave", 1, ret_any},
 279         {"_raw_spin_lock_irqsave_nested", LOCK, "irqsave", RETURN_VAL, ret_any},
 280         {"spin_trylock_irqsave",       LOCK,   "irqsave", 1, ret_non_zero},
 281         {"read_lock_irqsave",          LOCK,   "irqsave", RETURN_VAL, ret_any},
 282         {"read_lock_irqsave",          LOCK,   "irqsave", 1, ret_any},
 283         {"read_unlock_irqrestore",     UNLOCK, "irqsave", 1, ret_any},
 284         {"_read_lock_irqsave",         LOCK,   "irqsave", RETURN_VAL, ret_any},
 285         {"_read_lock_irqsave",         LOCK,   "irqsave", 1, ret_any},
 286         {"_read_unlock_irqrestore",    UNLOCK, "irqsave", 1, ret_any},
 287         {"__read_lock_irqsave",        LOCK,   "irqsave", RETURN_VAL, ret_any},
 288         {"__read_unlock_irqrestore",   UNLOCK, "irqsave", 1, ret_any},
 289         {"write_lock_irqsave",         LOCK,   "irqsave", RETURN_VAL, ret_any},
 290         {"write_lock_irqsave",         LOCK,   "irqsave", 1, ret_any},
 291         {"write_unlock_irqrestore",    UNLOCK, "irqsave", 1, ret_any},
 292         {"_write_lock_irqsave",        LOCK,   "irqsave", RETURN_VAL, ret_any},
 293         {"_write_lock_irqsave",        LOCK,   "irqsave", 1, ret_any},
 294         {"_write_unlock_irqrestore",   UNLOCK, "irqsave", 1, ret_any},
 295         {"__write_lock_irqsave",       LOCK,   "irqsave", RETURN_VAL, ret_any},
 296         {"__write_unlock_irqrestore",  UNLOCK, "irqsave", 1, ret_any},
 297
 298         {"spin_lock_bh",      LOCK,   "bottom_half", NO_ARG, ret_any},
 299         {"spin_unlock_bh",    UNLOCK, "bottom_half", NO_ARG, ret_any},
 300         {"_spin_lock_bh",     LOCK,   "bottom_half", NO_ARG, ret_any},
 301         {"_spin_unlock_bh",   UNLOCK, "bottom_half", NO_ARG, ret_any},
 302         {"__spin_lock_bh",    LOCK,   "bottom_half", NO_ARG, ret_any},
 303         {"__spin_unlock_bh",  UNLOCK, "bottom_half", NO_ARG, ret_any},
 304         {"read_lock_bh",      LOCK,   "bottom_half", NO_ARG, ret_any},
 305         {"read_unlock_bh",    UNLOCK, "bottom_half", NO_ARG, ret_any},
 306         {"_read_lock_bh",     LOCK,   "bottom_half", NO_ARG, ret_any},
 307         {"_read_unlock_bh",   UNLOCK, "bottom_half", NO_ARG, ret_any},
 308         {"__read_lock_bh",    LOCK,   "bottom_half", NO_ARG, ret_any},
 309         {"__read_unlock_bh",  UNLOCK, "bottom_half", NO_ARG, ret_any},
 310         {"write_lock_bh",     LOCK,   "bottom_half", NO_ARG, ret_any},
 311         {"write_unlock_bh",   UNLOCK, "bottom_half", NO_ARG, ret_any},
 312         {"_write_lock_bh",    LOCK,   "bottom_half", NO_ARG, ret_any},
 313         {"_write_unlock_bh",  UNLOCK, "bottom_half", NO_ARG, ret_any},
 314         {"__write_lock_bh",   LOCK,   "bottom_half", NO_ARG, ret_any},
 315         {"__write_unlock_bh", UNLOCK, "bottom_half", NO_ARG, ret_any},
 316         {"spin_trylock_bh",   LOCK,   "bottom_half", NO_ARG, ret_non_zero},
 317         {"_spin_trylock_bh",  LOCK,   "bottom_half", NO_ARG, ret_non_zero},
 318         {"__spin_trylock_bh", LOCK,   "bottom_half", NO_ARG, ret_non_zero},
 319 };
 320
 321 static struct lock_info *lock_table;
 322
 323 static struct tracker_list *starts_locked;
 324 static struct tracker_list *starts_unlocked;
 325
 326 struct locks_on_return {
 327         int line;
 328         struct tracker_list *locked;
 329         struct tracker_list *unlocked;
 330 };
 331 DECLARE_PTR_LIST(return_list, struct locks_on_return);
 332 static struct return_list *all_returns;
 333
 334 static char *make_full_name(const char *lock, const char *var)
 335 {
 336         static char tmp_buf[512];
 337
 338         snprintf(tmp_buf, 512, "%s:%s", lock, var);
 339         tmp_buf[511] = '\0';
 340         return alloc_string(tmp_buf);
 341 }
 342
 343 static struct expression *remove_spinlock_check(struct expression *expr)
 344 {
 345         if (expr->type != EXPR_CALL)
 346                 return expr;
 347         if (expr->fn->type != EXPR_SYMBOL)
 348                 return expr;
 349         if (strcmp(expr->fn->symbol_name->name, "spinlock_check"))
 350                 return expr;
 351         expr = get_argument_from_call_expr(expr->args, 0);
 352         return expr;
 353 }
 354
 355 static char *get_full_name(struct expression *expr, int index)
 356 {
 357         struct expression *arg;
 358         char *name = NULL;
 359         char *full_name = NULL;
 360         struct lock_info *lock = &lock_table[index];
 361
 362         if (lock->arg == RETURN_VAL) {
 363                 name = get_variable_from_expr(expr->left, NULL);
 364                 full_name = make_full_name(lock->name, name);
 365         } else if (lock->arg == NO_ARG) {
 366                 full_name = make_full_name(lock->name, "");
 367         } else {
 368                 arg = get_argument_from_call_expr(expr->args, lock->arg);
 369                 if (!arg)
 370                         goto free;
 371                 arg = remove_spinlock_check(arg);
 372                 name = get_variable_from_expr(arg, NULL);
 373                 if (!name)
 374                         goto free;
 375                 full_name = make_full_name(lock->name, name);
 376         }
 377 free:
 378         free_string(name);
 379         return full_name;
 380 }
 381
 382 static struct smatch_state *get_start_state(struct sm_state *sm)
 383 {
 384        int is_locked = 0;
 385        int is_unlocked = 0;
 386
 387        if (in_tracker_list(starts_locked, my_id, sm->name, sm->sym))
 388                is_locked = 1;
 389        if (in_tracker_list(starts_unlocked, my_id, sm->name, sm->sym))
 390                is_unlocked = 1;
 391        if (is_locked && is_unlocked)
 392                return &undefined;
 393        if (is_locked)
 394                return &locked;
 395        if (is_unlocked)
 396                return &unlocked;
 397         return &undefined;
 398 }
 399
 400 static struct smatch_state *unmatched_state(struct sm_state *sm)
 401 {
 402         return &start_state;
 403 }
 404
 405 static void do_lock(const char *name)
 406 {
 407         struct sm_state *sm;
 408
 409         sm = get_sm_state(my_id, name, NULL);
 410         if (!sm)
 411                 add_tracker(&starts_unlocked, my_id, name, NULL);
 412         if (sm && slist_has_state(sm->possible, &locked))
 413                 sm_msg("error: double lock '%s'", name);
 414         set_state(my_id, name, NULL, &locked);
 415 }
 416
 417 static void do_lock_failed(const char *name)
 418 {
 419         struct sm_state *sm;
 420
 421         sm = get_sm_state(my_id, name, NULL);
 422         if (!sm)
 423                 add_tracker(&starts_unlocked, my_id, name, NULL);
 424         set_state(my_id, name, NULL, &unlocked);
 425 }
 426
 427 static void do_unlock(const char *name)
 428 {
 429         struct sm_state *sm;
 430
 431         sm = get_sm_state(my_id, name, NULL);
 432         if (!sm)
 433                 add_tracker(&starts_locked, my_id, name, NULL);
 434         if (sm && slist_has_state(sm->possible, &unlocked))
 435                 sm_msg("error: double unlock '%s'", name);
 436         set_state(my_id, name, NULL, &unlocked);
 437
 438 }
 439
 440 static void match_lock_held(const char *fn, struct expression *call_expr,
 441                         struct expression *assign_expr, void *_index)
 442 {
 443         int index = PTR_INT(_index);
 444         char *lock_name;
 445         struct lock_info *lock = &lock_table[index];
 446
 447         if (lock->arg == NO_ARG) {
 448                 lock_name = get_full_name(NULL, index);
 449         } else if (lock->arg == RETURN_VAL) {
 450                 if (!assign_expr)
 451                         return;
 452                 lock_name = get_full_name(assign_expr, index);
 453         } else {
 454                 lock_name = get_full_name(call_expr, index);
 455         }
 456         if (!lock_name)
 457                 return;
 458         do_lock(lock_name);
 459         free_string(lock_name);
 460 }
 461
 462 static void match_lock_failed(const char *fn, struct expression *call_expr,
 463                         struct expression *assign_expr, void *_index)
 464 {
 465         int index = PTR_INT(_index);
 466         char *lock_name;
 467         struct lock_info *lock = &lock_table[index];
 468
 469         if (lock->arg == NO_ARG) {
 470                 lock_name = get_full_name(NULL, index);
 471         } else if (lock->arg == RETURN_VAL) {
 472                 if (!assign_expr)
 473                         return;
 474                 lock_name = get_full_name(assign_expr, index);
 475         } else {
 476                 lock_name = get_full_name(call_expr, index);
 477         }
 478         if (!lock_name)
 479                 return;
 480         do_lock_failed(lock_name);
 481         free_string(lock_name);
 482 }
 483
 484 static void match_returns_locked(const char *fn, struct expression *expr,
 485                                       void *_index)
 486 {
 487         char *full_name = NULL;
 488         int index = PTR_INT(_index);
 489         struct lock_info *lock = &lock_table[index];
 490
 491         if (lock->arg != RETURN_VAL)
 492                 return;
 493         full_name = get_full_name(expr, index);
 494         do_lock(full_name);
 495 }
 496
 497 static void match_lock_unlock(const char *fn, struct expression *expr, void *_index)
 498 {
 499         char *full_name = NULL;
 500         int index = PTR_INT(_index);
 501         struct lock_info *lock = &lock_table[index];
 502
 503         full_name = get_full_name(expr, index);
 504         if (!full_name)
 505                 return;
 506         if (lock->action == LOCK)
 507                 do_lock(full_name);
 508         else
 509                 do_unlock(full_name);
 510         free_string(full_name);
 511 }
 512
 513 static struct locks_on_return *alloc_return(int line)
 514 {
 515         struct locks_on_return *ret;
 516
 517         ret = malloc(sizeof(*ret));
 518         ret->line = line;
 519         ret->locked = NULL;
 520         ret->unlocked = NULL;
 521         return ret;
 522 }
 523
 524 static void check_possible(struct sm_state *sm)
 525 {
 526         struct sm_state *tmp;
 527         int islocked = 0;
 528         int isunlocked = 0;
 529         int undef = 0;
 530
 531         if (!option_spammy)
 532                 return;
 533
 534         FOR_EACH_PTR(sm->possible, tmp) {
 535                 if (tmp->state == &locked)
 536                         islocked = 1;
 537                 if (tmp->state == &unlocked)
 538                         isunlocked = 1;
 539                 if (tmp->state == &start_state) {
 540                         struct smatch_state *s;
 541
 542                         s = get_start_state(tmp);
 543                         if (s == &locked)
 544                                 islocked = 1;
 545                         else if (s == &unlocked)
 546                                 isunlocked = 1;
 547                         else
 548                                 undef = 1;
 549                 }
 550                 if (tmp->state == &undefined)
 551                         undef = 1;  // i don't think this is possible any more.
 552         } END_FOR_EACH_PTR(tmp);
 553         if ((islocked && isunlocked) || undef)
 554                 sm_msg("warn: '%s' is sometimes locked here and sometimes unlocked.", sm->name);
 555 }
 556
 557 static void match_return(struct expression *ret_value)
 558 {
 559         struct locks_on_return *ret;
 560         struct state_list *slist;
 561         struct sm_state *tmp;
 562
 563         if (!final_pass)
 564                 return;
 565
 566         ret = alloc_return(get_lineno());
 567
 568         slist = get_all_states(my_id);
 569         FOR_EACH_PTR(slist, tmp) {
 570                 if (tmp->state == &locked) {
 571                         add_tracker(&ret->locked, tmp->owner, tmp->name,
 572                                 tmp->sym);
 573                 } else if (tmp->state == &unlocked) {
 574                         add_tracker(&ret->unlocked, tmp->owner, tmp->name,
 575                                 tmp->sym);
 576                 } else if (tmp->state == &start_state) {
 577                         struct smatch_state *s;
 578
 579                         s = get_start_state(tmp);
 580                         if (s == &locked)
 581                                 add_tracker(&ret->locked, tmp->owner, tmp->name,
 582                                             tmp->sym);
 583                         if (s == &unlocked)
 584                                 add_tracker(&ret->unlocked, tmp->owner,tmp->name,
 585                                              tmp->sym);
 586                 }else {
 587                         check_possible(tmp);
 588                 }
 589         } END_FOR_EACH_PTR(tmp);
 590         free_slist(&slist);
 591         add_ptr_list(&all_returns, ret);
 592 }
 593
 594 static void print_inconsistent_returns(struct tracker *lock,
 595                                 struct smatch_state *start)
 596 {
 597         struct locks_on_return *tmp;
 598         int i;
 599
 600         sm_printf("%s +%d %s(%d) ", get_filename(), get_lineno(), get_function(), get_func_pos());
 601         sm_printf("warn: inconsistent returns %s:", lock->name);
 602         sm_printf(" locked (");
 603         i = 0;
 604         FOR_EACH_PTR(all_returns, tmp) {
 605                 if (in_tracker_list(tmp->unlocked, lock->owner, lock->name, lock->sym))
 606                         continue;
 607                 if (in_tracker_list(tmp->locked, lock->owner, lock->name, lock->sym)) {
 608                         if (i++)
 609                                 sm_printf(",");
 610                         sm_printf("%d", tmp->line);
 611                         continue;
 612                 }
 613                 if (start == &locked) {
 614                         if (i++)
 615                                 sm_printf(",");
 616                         sm_printf("%d", tmp->line);
 617                 }
 618         } END_FOR_EACH_PTR(tmp);
 619
 620         sm_printf(") unlocked (");
 621         i = 0;
 622         FOR_EACH_PTR(all_returns, tmp) {
 623                 if (in_tracker_list(tmp->unlocked, lock->owner, lock->name, lock->sym)) {
 624                         if (i++)
 625                                 sm_printf(",");
 626                         sm_printf("%d", tmp->line);
 627                         continue;
 628                 }
 629                 if (in_tracker_list(tmp->locked, lock->owner, lock->name, lock->sym)) {
 630                         continue;
 631                 }
 632                 if (start == &unlocked) {
 633                         if (i++)
 634                                 sm_printf(",");
 635                         sm_printf("%d", tmp->line);
 636                 }
 637         } END_FOR_EACH_PTR(tmp);
 638         sm_printf(")\n");
 639 }
 640
 641 static void check_returns_consistently(struct tracker *lock,
 642                                 struct smatch_state *start)
 643 {
 644         int returns_locked = 0;
 645         int returns_unlocked = 0;
 646         struct locks_on_return *tmp;
 647
 648         FOR_EACH_PTR(all_returns, tmp) {
 649                 if (in_tracker_list(tmp->unlocked, lock->owner, lock->name,
 650                                         lock->sym))
 651                         returns_unlocked = tmp->line;
 652                 else if (in_tracker_list(tmp->locked, lock->owner, lock->name,
 653                                                 lock->sym))
 654                         returns_locked = tmp->line;
 655                 else if (start == &locked)
 656                         returns_locked = tmp->line;
 657                 else if (start == &unlocked)
 658                         returns_unlocked = tmp->line;
 659         } END_FOR_EACH_PTR(tmp);
 660
 661         if (returns_locked && returns_unlocked)
 662                 print_inconsistent_returns(lock, start);
 663 }
 664
 665 static void check_consistency(struct symbol *sym)
 666 {
 667         struct tracker *tmp;
 668
 669         if (is_reachable())
 670                 match_return(NULL);
 671
 672         FOR_EACH_PTR(starts_locked, tmp) {
 673                 if (in_tracker_list(starts_unlocked, tmp->owner, tmp->name,
 674                                         tmp->sym))
 675                         sm_msg("error:  locking inconsistency.  We assume "
 676                                    "'%s' is both locked and unlocked at the "
 677                                    "start.",
 678                                 tmp->name);
 679         } END_FOR_EACH_PTR(tmp);
 680
 681         FOR_EACH_PTR(starts_locked, tmp) {
 682                 check_returns_consistently(tmp, &locked);
 683         } END_FOR_EACH_PTR(tmp);
 684
 685         FOR_EACH_PTR(starts_unlocked, tmp) {
 686                 check_returns_consistently(tmp, &unlocked);
 687         } END_FOR_EACH_PTR(tmp);
 688
 689 }
 690
 691 static void clear_lists(void)
 692 {
 693         struct locks_on_return *tmp;
 694
 695         free_trackers_and_list(&starts_locked);
 696         free_trackers_and_list(&starts_unlocked);
 697
 698         FOR_EACH_PTR(all_returns, tmp) {
 699                 free_trackers_and_list(&tmp->locked);
 700                 free_trackers_and_list(&tmp->unlocked);
 701                 free(tmp);
 702         } END_FOR_EACH_PTR(tmp);
 703         __free_ptr_list((struct ptr_list **)&all_returns);
 704 }
 705
 706 static void match_func_end(struct symbol *sym)
 707 {
 708         check_consistency(sym);
 709         clear_lists();
 710 }
 711
 712 static void register_lock(int index)
 713 {
 714         struct lock_info *lock = &lock_table[index];
 715         void *idx = INT_PTR(index);
 716
 717         if (lock->return_type == ret_non_zero) {
 718                 return_implies_state(lock->function, 1, POINTER_MAX, &match_lock_held, idx);
 719                 return_implies_state(lock->function, 0, 0, &match_lock_failed, idx);
 720         } else if (lock->return_type == ret_any && lock->arg == RETURN_VAL) {
 721                 add_function_assign_hook(lock->function, &match_returns_locked, idx);
 722         } else if (lock->return_type == ret_any) {
 723                 add_function_hook(lock->function, &match_lock_unlock, idx);
 724         } else if (lock->return_type == ret_zero) {
 725                 return_implies_state(lock->function, 0, 0, &match_lock_held, idx);
 726                 return_implies_state(lock->function, whole_range.min, -1, &match_lock_failed, idx);
 727         }
 728 }
 729
 730 static void load_table(struct lock_info *_lock_table, int size)
 731 {
 732         int i;
 733
 734         lock_table = _lock_table;
 735
 736         for (i = 0; i < size; i++) {
 737                 if (lock_table[i].action == LOCK)
 738                         register_lock(i);
 739                 else
 740                         add_function_hook(lock_table[i].function, &match_lock_unlock, INT_PTR(i));
 741         }
 742 }
 743
 744 /* print_held_locks() is used in check_call_tree.c */
 745 void print_held_locks()
 746 {
 747         struct state_list *slist;
 748         struct sm_state *sm;
 749         int i = 0;
 750
 751         slist = get_all_states(my_id);
 752         FOR_EACH_PTR(slist, sm) {
 753                 if (sm->state != &locked)
 754                         continue;
 755                 if (i++)
 756                         sm_printf(" ");
 757                 sm_printf("'%s'", sm->name);
 758         } END_FOR_EACH_PTR(sm);
 759         free_slist(&slist);
 760 }
 761
 762 void check_locking(int id)
 763 {
 764         my_id = id;
 765
 766         if (option_project == PROJ_WINE)
 767                 load_table(wine_lock_table, ARRAY_SIZE(wine_lock_table));
 768         else if (option_project == PROJ_KERNEL)
 769                 load_table(kernel_lock_table, ARRAY_SIZE(kernel_lock_table));
 770         else
 771                 return;
 772
 773         add_unmatched_state_hook(my_id, &unmatched_state);
 774         add_hook(&match_return, RETURN_HOOK);
 775         add_hook(&match_func_end, END_FUNC_HOOK);
 776 }