check_locking.c

   1 /*
   2  * Copyright (C) 2009 Dan Carpenter.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
  16  */
  17
  18 /*
  19  * This test checks that locks are held the same across all returns.
  20  *
  21  * Of course, some functions are designed to only hold the locks on success.
  22  * Oh well... We can rewrite it later if we want.
  23  *
  24  * The list of wine locking functions came from an earlier script written
  25  * by Michael Stefaniuc.
  26  *
  27  */
  28
  29 #include "parse.h"
  30 #include "smatch.h"
  31 #include "smatch_extra.h"
  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},
  73         {"LeaveCriticalSection", UNLOCK, "CriticalSection", 0, ret_any},
  74         {"RtlEnterCriticalSection", LOCK, "RtlCriticalSection", 0, ret_any},
  75         {"RtlLeaveCriticalSection", UNLOCK, "RtlCriticalSection", 0, ret_any},
  76         {"GDI_GetObjPtr", LOCK, "GDI_Get", 0, ret_non_zero},
  77         {"GDI_ReleaseObj", UNLOCK, "GDI_Get", 0, ret_any},
  78         {"LdrLockLoaderLock", LOCK, "LdrLockLoaderLock", 2, ret_any},
  79         {"LdrUnlockLoaderLock", UNLOCK, "LdrLockLoaderLock", 1, ret_any},
  80         {"_lock", LOCK, "_lock", 0, ret_any},
  81         {"_unlock", UNLOCK, "_lock", 0, ret_any},
  82         {"msiobj_lock", LOCK, "msiobj_lock", 0, ret_any},
  83         {"msiobj_unlock", UNLOCK, "msiobj_lock", 0, ret_any},
  84         {"RtlAcquirePebLock", LOCK, "PebLock", NO_ARG, ret_any},
  85         {"RtlReleasePebLock", UNLOCK, "PebLock", NO_ARG, ret_any},
  86         {"server_enter_uninterrupted_section", LOCK, "server_uninterrupted_section", 0, ret_any},
  87         {"server_leave_uninterrupted_section", UNLOCK, "server_uninterrupted_section", 0, ret_any},
  88         {"RtlLockHeap", LOCK, "RtlLockHeap", 0, ret_any},
  89         {"RtlUnlockHeap", UNLOCK, "RtlLockHeap", 0, ret_any},
  90         {"_EnterSysLevel", LOCK, "SysLevel", 0, ret_any},
  91         {"_LeaveSysLevel", UNLOCK, "SysLevel", 0, ret_any},
  92         {"USER_Lock", LOCK, "USER_Lock", NO_ARG, ret_any},
  93         {"USER_Unlock", UNLOCK, "USER_Lock", NO_ARG, ret_any},
  94         {"wine_tsx11_lock", LOCK, "wine_tsx11_lock", NO_ARG, ret_any},
  95         {"wine_tsx11_unlock", UNLOCK, "wine_tsx11_lock", NO_ARG, ret_any},
  96         {"wine_tsx11_lock_ptr", LOCK, "wine_tsx11_lock_ptr", NO_ARG, ret_any},
  97         {"wine_tsx11_unlock_ptr", UNLOCK, "wine_tsx11_lock_ptr", NO_ARG, ret_any},
  98         {"wined3d_mutex_lock", LOCK, "wined3d_mutex_lock", NO_ARG, ret_any},
  99         {"wined3d_mutex_unlock", UNLOCK, "wined3d_mutex_lock", NO_ARG, ret_any},
 100         {"X11DRV_DIB_Lock", LOCK, "X11DRV_DIB_Lock", 0, ret_any},
 101         {"X11DRV_DIB_Unlock", UNLOCK, "X11DRV_DIB_Lock", 0, ret_any},
 102 };
 103
 104 static struct lock_info kernel_lock_table[] = {
 105         {"lock_kernel",   LOCK,   "BKL", NO_ARG, ret_any},
 106         {"unlock_kernel", UNLOCK, "BKL", NO_ARG, ret_any},
 107
 108         {"spin_lock",                  LOCK,   "spin_lock", 0, ret_any},
 109         {"spin_unlock",                UNLOCK, "spin_lock", 0, ret_any},
 110         {"spin_lock_nested",           LOCK,   "spin_lock", 0, ret_any},
 111         {"_spin_lock",                 LOCK,   "spin_lock", 0, ret_any},
 112         {"_spin_unlock",               UNLOCK, "spin_lock", 0, ret_any},
 113         {"_spin_lock_nested",          LOCK,   "spin_lock", 0, ret_any},
 114         {"__spin_lock",                LOCK,   "spin_lock", 0, ret_any},
 115         {"__spin_unlock",              UNLOCK, "spin_lock", 0, ret_any},
 116         {"__spin_lock_nested",         LOCK,   "spin_lock", 0, ret_any},
 117         {"raw_spin_lock",              LOCK,   "spin_lock", 0, ret_any},
 118         {"raw_spin_unlock",            UNLOCK, "spin_lock", 0, ret_any},
 119         {"_raw_spin_lock",             LOCK,   "spin_lock", 0, ret_any},
 120         {"_raw_spin_lock_nested",      LOCK,   "spin_lock", 0, ret_any},
 121         {"_raw_spin_unlock",           UNLOCK, "spin_lock", 0, ret_any},
 122         {"__raw_spin_lock",            LOCK,   "spin_lock", 0, ret_any},
 123         {"__raw_spin_unlock",          UNLOCK, "spin_lock", 0, ret_any},
 124
 125         {"spin_lock_irq",              LOCK,   "spin_lock", 0, ret_any},
 126         {"spin_unlock_irq",            UNLOCK, "spin_lock", 0, ret_any},
 127         {"_spin_lock_irq",             LOCK,   "spin_lock", 0, ret_any},
 128         {"_spin_unlock_irq",           UNLOCK, "spin_lock", 0, ret_any},
 129         {"__spin_lock_irq",            LOCK,   "spin_lock", 0, ret_any},
 130         {"__spin_unlock_irq",          UNLOCK, "spin_lock", 0, ret_any},
 131         {"_raw_spin_lock_irq",         LOCK,   "spin_lock", 0, ret_any},
 132         {"_raw_spin_unlock_irq",       UNLOCK, "spin_lock", 0, ret_any},
 133         {"__raw_spin_unlock_irq",      UNLOCK, "spin_lock", 0, ret_any},
 134         {"spin_lock_irqsave",          LOCK,   "spin_lock", 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         {"mutex_lock",                      LOCK,   "mutex", 0, ret_any},
 252         {"mutex_unlock",                    UNLOCK, "mutex", 0, ret_any},
 253         {"mutex_lock_nested",               LOCK,   "mutex", 0, ret_any},
 254
 255         {"mutex_lock_interruptible",        LOCK,   "mutex", 0, ret_zero},
 256         {"mutex_lock_interruptible_nested", LOCK,   "mutex", 0, ret_zero},
 257         {"mutex_lock_killable",             LOCK,   "mutex", 0, ret_zero},
 258         {"mutex_lock_killable_nested",      LOCK,   "mutex", 0, ret_zero},
 259
 260         {"mutex_trylock",                   LOCK,   "mutex", 0, ret_one},
 261
 262         {"raw_local_irq_disable", LOCK,   "irq", NO_ARG, ret_any},
 263         {"raw_local_irq_enable",  UNLOCK, "irq", NO_ARG, ret_any},
 264         {"spin_lock_irq",         LOCK,   "irq", NO_ARG, ret_any},
 265         {"spin_unlock_irq",       UNLOCK, "irq", NO_ARG, ret_any},
 266         {"_spin_lock_irq",        LOCK,   "irq", NO_ARG, ret_any},
 267         {"_spin_unlock_irq",      UNLOCK, "irq", NO_ARG, ret_any},
 268         {"__spin_lock_irq",       LOCK,   "irq", NO_ARG, ret_any},
 269         {"__spin_unlock_irq",     UNLOCK, "irq", NO_ARG, ret_any},
 270         {"_raw_spin_lock_irq",    LOCK,   "irq", NO_ARG, ret_any},
 271         {"_raw_spin_unlock_irq",  UNLOCK, "irq", NO_ARG, ret_any},
 272         {"__raw_spin_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
 273         {"spin_trylock_irq",      LOCK,   "irq", NO_ARG, ret_one},
 274         {"read_lock_irq",         LOCK,   "irq", NO_ARG, ret_any},
 275         {"read_unlock_irq",       UNLOCK, "irq", NO_ARG, ret_any},
 276         {"_read_lock_irq",        LOCK,   "irq", NO_ARG, ret_any},
 277         {"_read_unlock_irq",      UNLOCK, "irq", NO_ARG, ret_any},
 278         {"__read_lock_irq",       LOCK,   "irq", NO_ARG, ret_any},
 279         {"__read_unlock_irq",     UNLOCK, "irq", NO_ARG, ret_any},
 280         {"write_lock_irq",        LOCK,   "irq", NO_ARG, ret_any},
 281         {"write_unlock_irq",      UNLOCK, "irq", NO_ARG, ret_any},
 282         {"_write_lock_irq",       LOCK,   "irq", NO_ARG, ret_any},
 283         {"_write_unlock_irq",     UNLOCK, "irq", NO_ARG, ret_any},
 284         {"__write_lock_irq",      LOCK,   "irq", NO_ARG, ret_any},
 285         {"__write_unlock_irq",    UNLOCK, "irq", NO_ARG, ret_any},
 286
 287         {"arch_local_irq_save",        LOCK,   "irqsave", RETURN_VAL, ret_any},
 288         {"arch_local_irq_restore",     UNLOCK, "irqsave", 0, ret_any},
 289         {"__raw_local_irq_save",       LOCK,   "irqsave", RETURN_VAL, ret_any},
 290         {"raw_local_irq_restore",      UNLOCK, "irqsave", 0, ret_any},
 291         {"spin_lock_irqsave_nested",   LOCK,   "irqsave", RETURN_VAL, ret_any},
 292         {"spin_lock_irqsave",          LOCK,   "irqsave", RETURN_VAL, ret_any},
 293         {"spin_lock_irqsave",          LOCK,   "irqsave", 1, ret_any},
 294         {"spin_unlock_irqrestore",     UNLOCK, "irqsave", 1, ret_any},
 295         {"_spin_lock_irqsave_nested",  LOCK,   "irqsave", RETURN_VAL, ret_any},
 296         {"_spin_lock_irqsave",         LOCK,   "irqsave", RETURN_VAL, ret_any},
 297         {"_spin_lock_irqsave",         LOCK,   "irqsave", 1, ret_any},
 298         {"_spin_unlock_irqrestore",    UNLOCK, "irqsave", 1, ret_any},
 299         {"__spin_lock_irqsave_nested", LOCK,   "irqsave", 1, ret_any},
 300         {"__spin_lock_irqsave",        LOCK,   "irqsave", 1, ret_any},
 301         {"__spin_unlock_irqrestore",   UNLOCK, "irqsave", 1, ret_any},
 302         {"_raw_spin_lock_irqsave",     LOCK,   "irqsave", RETURN_VAL, ret_any},
 303         {"_raw_spin_lock_irqsave",     LOCK,   "irqsave", 1, ret_any},
 304         {"_raw_spin_unlock_irqrestore",UNLOCK, "irqsave", 1, ret_any},
 305         {"__raw_spin_lock_irqsave",    LOCK,   "irqsave", RETURN_VAL, ret_any},
 306         {"__raw_spin_unlock_irqrestore",UNLOCK, "irqsave", 1, ret_any},
 307         {"_raw_spin_lock_irqsave_nested", LOCK, "irqsave", RETURN_VAL, ret_any},
 308         {"spin_trylock_irqsave",       LOCK,   "irqsave", 1, ret_one},
 309         {"read_lock_irqsave",          LOCK,   "irqsave", RETURN_VAL, ret_any},
 310         {"read_lock_irqsave",          LOCK,   "irqsave", 1, ret_any},
 311         {"read_unlock_irqrestore",     UNLOCK, "irqsave", 1, ret_any},
 312         {"_read_lock_irqsave",         LOCK,   "irqsave", RETURN_VAL, ret_any},
 313         {"_read_lock_irqsave",         LOCK,   "irqsave", 1, ret_any},
 314         {"_read_unlock_irqrestore",    UNLOCK, "irqsave", 1, ret_any},
 315         {"__read_lock_irqsave",        LOCK,   "irqsave", RETURN_VAL, ret_any},
 316         {"__read_unlock_irqrestore",   UNLOCK, "irqsave", 1, ret_any},
 317         {"write_lock_irqsave",         LOCK,   "irqsave", RETURN_VAL, ret_any},
 318         {"write_lock_irqsave",         LOCK,   "irqsave", 1, ret_any},
 319         {"write_unlock_irqrestore",    UNLOCK, "irqsave", 1, ret_any},
 320         {"_write_lock_irqsave",        LOCK,   "irqsave", RETURN_VAL, ret_any},
 321         {"_write_lock_irqsave",        LOCK,   "irqsave", 1, ret_any},
 322         {"_write_unlock_irqrestore",   UNLOCK, "irqsave", 1, ret_any},
 323         {"__write_lock_irqsave",       LOCK,   "irqsave", RETURN_VAL, ret_any},
 324         {"__write_unlock_irqrestore",  UNLOCK, "irqsave", 1, ret_any},
 325
 326         {"local_bh_disable",    LOCK,   "bottom_half", NO_ARG, ret_any},
 327         {"_local_bh_disable",   LOCK,   "bottom_half", NO_ARG, ret_any},
 328         {"__local_bh_disable",  LOCK,   "bottom_half", NO_ARG, ret_any},
 329         {"local_bh_enable",     UNLOCK, "bottom_half", NO_ARG, ret_any},
 330         {"_local_bh_enable",    UNLOCK, "bottom_half", NO_ARG, ret_any},
 331         {"__local_bh_enable",   UNLOCK, "bottom_half", NO_ARG, ret_any},
 332         {"spin_lock_bh",        LOCK,   "bottom_half", NO_ARG, ret_any},
 333         {"spin_unlock_bh",      UNLOCK, "bottom_half", NO_ARG, ret_any},
 334         {"_spin_lock_bh",       LOCK,   "bottom_half", NO_ARG, ret_any},
 335         {"_spin_unlock_bh",     UNLOCK, "bottom_half", NO_ARG, ret_any},
 336         {"__spin_lock_bh",      LOCK,   "bottom_half", NO_ARG, ret_any},
 337         {"__spin_unlock_bh",    UNLOCK, "bottom_half", NO_ARG, ret_any},
 338         {"read_lock_bh",        LOCK,   "bottom_half", NO_ARG, ret_any},
 339         {"read_unlock_bh",      UNLOCK, "bottom_half", NO_ARG, ret_any},
 340         {"_read_lock_bh",       LOCK,   "bottom_half", NO_ARG, ret_any},
 341         {"_read_unlock_bh",     UNLOCK, "bottom_half", NO_ARG, ret_any},
 342         {"__read_lock_bh",      LOCK,   "bottom_half", NO_ARG, ret_any},
 343         {"__read_unlock_bh",    UNLOCK, "bottom_half", NO_ARG, ret_any},
 344         {"_raw_read_lock_bh",   LOCK,   "bottom_half", NO_ARG, ret_any},
 345         {"_raw_read_unlock_bh", UNLOCK, "bottom_half", NO_ARG, ret_any},
 346         {"write_lock_bh",       LOCK,   "bottom_half", NO_ARG, ret_any},
 347         {"write_unlock_bh",     UNLOCK, "bottom_half", NO_ARG, ret_any},
 348         {"_write_lock_bh",      LOCK,   "bottom_half", NO_ARG, ret_any},
 349         {"_write_unlock_bh",    UNLOCK, "bottom_half", NO_ARG, ret_any},
 350         {"__write_lock_bh",     LOCK,   "bottom_half", NO_ARG, ret_any},
 351         {"__write_unlock_bh",   UNLOCK, "bottom_half", NO_ARG, ret_any},
 352         {"spin_trylock_bh",     LOCK,   "bottom_half", NO_ARG, ret_one},
 353         {"_spin_trylock_bh",    LOCK,   "bottom_half", NO_ARG, ret_one},
 354         {"__spin_trylock_bh",   LOCK,   "bottom_half", NO_ARG, ret_one},
 355
 356         {"ffs_mutex_lock",        LOCK,   "mutex", 0, ret_zero},
 357 };
 358
 359 static struct lock_info *lock_table;
 360
 361 static struct tracker_list *starts_locked;
 362 static struct tracker_list *starts_unlocked;
 363
 364 struct locks_on_return {
 365         int line;
 366         struct tracker_list *locked;
 367         struct tracker_list *unlocked;
 368         struct tracker_list *impossible;
 369         struct range_list *return_values;
 370 };
 371 DECLARE_PTR_LIST(return_list, struct locks_on_return);
 372 static struct return_list *all_returns;
 373
 374 static char *make_full_name(const char *lock, const char *var)
 375 {
 376         static char tmp_buf[512];
 377
 378         snprintf(tmp_buf, sizeof(tmp_buf), "%s:%s", lock, var);
 379         remove_parens(tmp_buf);
 380         return alloc_string(tmp_buf);
 381 }
 382
 383 static struct expression *remove_spinlock_check(struct expression *expr)
 384 {
 385         if (expr->type != EXPR_CALL)
 386                 return expr;
 387         if (expr->fn->type != EXPR_SYMBOL)
 388                 return expr;
 389         if (strcmp(expr->fn->symbol_name->name, "spinlock_check"))
 390                 return expr;
 391         expr = get_argument_from_call_expr(expr->args, 0);
 392         return expr;
 393 }
 394
 395 static char *get_full_name(struct expression *expr, int index)
 396 {
 397         struct expression *arg;
 398         char *name = NULL;
 399         char *full_name = NULL;
 400         struct lock_info *lock = &lock_table[index];
 401
 402         if (lock->arg == RETURN_VAL) {
 403                 name = expr_to_var(expr->left);
 404                 full_name = make_full_name(lock->name, name);
 405         } else if (lock->arg == NO_ARG) {
 406                 full_name = make_full_name(lock->name, "");
 407         } else {
 408                 arg = get_argument_from_call_expr(expr->args, lock->arg);
 409                 if (!arg)
 410                         goto free;
 411                 arg = remove_spinlock_check(arg);
 412                 name = expr_to_str(arg);
 413                 if (!name)
 414                         goto free;
 415                 full_name = make_full_name(lock->name, name);
 416         }
 417 free:
 418         free_string(name);
 419         return full_name;
 420 }
 421
 422 static struct smatch_state *get_start_state(struct sm_state *sm)
 423 {
 424         int is_locked = 0;
 425         int is_unlocked = 0;
 426
 427         if (in_tracker_list(starts_locked, my_id, sm->name, sm->sym))
 428                 is_locked = 1;
 429         if (in_tracker_list(starts_unlocked, my_id, sm->name, sm->sym))
 430                 is_unlocked = 1;
 431         if (is_locked && is_unlocked)
 432                 return &undefined;
 433         if (is_locked)
 434                 return &locked;
 435         if (is_unlocked)
 436                 return &unlocked;
 437         return &undefined;
 438 }
 439
 440 static struct smatch_state *unmatched_state(struct sm_state *sm)
 441 {
 442         return &start_state;
 443 }
 444
 445 static void pre_merge_hook(struct sm_state *sm)
 446 {
 447         if (is_impossible_path())
 448                 set_state(my_id, sm->name, sm->sym, &impossible);
 449 }
 450
 451 static void do_lock(const char *name)
 452 {
 453         struct sm_state *sm;
 454
 455         if (__inline_fn)
 456                 return;
 457
 458         sm = get_sm_state(my_id, name, NULL);
 459         if (!sm)
 460                 add_tracker(&starts_unlocked, my_id, name, NULL);
 461         if (sm && slist_has_state(sm->possible, &locked) &&
 462                         strcmp(name, "bottom_half:") != 0)
 463                 sm_error("double lock '%s'", name);
 464         if (sm)
 465                 func_has_transition = TRUE;
 466         set_state(my_id, name, NULL, &locked);
 467 }
 468
 469 static void do_lock_failed(const char *name)
 470 {
 471         struct sm_state *sm;
 472
 473         if (__inline_fn)
 474                 return;
 475
 476         sm = get_sm_state(my_id, name, NULL);
 477         if (!sm)
 478                 add_tracker(&starts_unlocked, my_id, name, NULL);
 479         set_state(my_id, name, NULL, &unlocked);
 480 }
 481
 482 static void do_unlock(const char *name)
 483 {
 484         struct sm_state *sm;
 485
 486         if (__inline_fn)
 487                 return;
 488         if (__path_is_null())
 489                 return;
 490         sm = get_sm_state(my_id, name, NULL);
 491         if (!sm)
 492                 add_tracker(&starts_locked, my_id, name, NULL);
 493         if (sm && slist_has_state(sm->possible, &unlocked) &&
 494                         strcmp(name, "bottom_half:") != 0)
 495                 sm_error("double unlock '%s'", name);
 496         if (sm)
 497                 func_has_transition = TRUE;
 498         set_state(my_id, name, NULL, &unlocked);
 499 }
 500
 501 static void match_lock_held(const char *fn, struct expression *call_expr,
 502                         struct expression *assign_expr, void *_index)
 503 {
 504         int index = PTR_INT(_index);
 505         char *lock_name;
 506         struct lock_info *lock = &lock_table[index];
 507
 508         if (lock->arg == NO_ARG) {
 509                 lock_name = get_full_name(NULL, index);
 510         } else if (lock->arg == RETURN_VAL) {
 511                 if (!assign_expr)
 512                         return;
 513                 lock_name = get_full_name(assign_expr, index);
 514         } else {
 515                 lock_name = get_full_name(call_expr, index);
 516         }
 517         if (!lock_name)
 518                 return;
 519         do_lock(lock_name);
 520         free_string(lock_name);
 521 }
 522
 523 static void match_lock_failed(const char *fn, struct expression *call_expr,
 524                         struct expression *assign_expr, void *_index)
 525 {
 526         int index = PTR_INT(_index);
 527         char *lock_name;
 528         struct lock_info *lock = &lock_table[index];
 529
 530         if (lock->arg == NO_ARG) {
 531                 lock_name = get_full_name(NULL, index);
 532         } else if (lock->arg == RETURN_VAL) {
 533                 if (!assign_expr)
 534                         return;
 535                 lock_name = get_full_name(assign_expr, index);
 536         } else {
 537                 lock_name = get_full_name(call_expr, index);
 538         }
 539         if (!lock_name)
 540                 return;
 541         do_lock_failed(lock_name);
 542         free_string(lock_name);
 543 }
 544
 545 static void match_returns_locked(const char *fn, struct expression *expr,
 546                                       void *_index)
 547 {
 548         char *full_name = NULL;
 549         int index = PTR_INT(_index);
 550         struct lock_info *lock = &lock_table[index];
 551
 552         if (lock->arg != RETURN_VAL)
 553                 return;
 554         full_name = get_full_name(expr, index);
 555         do_lock(full_name);
 556 }
 557
 558 static void match_lock_unlock(const char *fn, struct expression *expr, void *_index)
 559 {
 560         char *full_name = NULL;
 561         int index = PTR_INT(_index);
 562         struct lock_info *lock = &lock_table[index];
 563
 564         if (__inline_fn)
 565                 return;
 566
 567         full_name = get_full_name(expr, index);
 568         if (!full_name)
 569                 return;
 570         if (lock->action == LOCK)
 571                 do_lock(full_name);
 572         else
 573                 do_unlock(full_name);
 574         free_string(full_name);
 575 }
 576
 577 static struct locks_on_return *alloc_return(struct expression *expr)
 578 {
 579         struct locks_on_return *ret;
 580
 581         ret = malloc(sizeof(*ret));
 582         if (!get_implied_rl(expr, &ret->return_values))
 583                 ret->return_values = NULL;
 584         ret->line = get_lineno();
 585         ret->locked = NULL;
 586         ret->unlocked = NULL;
 587         ret->impossible = NULL;
 588         return ret;
 589 }
 590
 591 static int check_possible(struct sm_state *sm)
 592 {
 593         struct sm_state *tmp;
 594         int islocked = 0;
 595         int isunlocked = 0;
 596         int undef = 0;
 597
 598         if (!option_spammy)
 599                 return 0;
 600
 601         FOR_EACH_PTR(sm->possible, tmp) {
 602                 if (tmp->state == &locked)
 603                         islocked = 1;
 604                 if (tmp->state == &unlocked)
 605                         isunlocked = 1;
 606                 if (tmp->state == &start_state) {
 607                         struct smatch_state *s;
 608
 609                         s = get_start_state(tmp);
 610                         if (s == &locked)
 611                                 islocked = 1;
 612                         else if (s == &unlocked)
 613                                 isunlocked = 1;
 614                         else
 615                                 undef = 1;
 616                 }
 617                 if (tmp->state == &undefined)
 618                         undef = 1;  // i don't think this is possible any more.
 619         } END_FOR_EACH_PTR(tmp);
 620         if ((islocked && isunlocked) || undef) {
 621                 sm_warning("'%s' is sometimes locked here and sometimes unlocked.", sm->name);
 622                 return 1;
 623         }
 624         return 0;
 625 }
 626
 627 static struct position warned_pos;
 628
 629 static void match_return(int return_id, char *return_ranges, struct expression *expr)
 630 {
 631         struct locks_on_return *ret;
 632         struct stree *stree;
 633         struct sm_state *tmp;
 634
 635         if (!final_pass)
 636                 return;
 637         if (__inline_fn)
 638                 return;
 639
 640         if (expr && cmp_pos(expr->pos, warned_pos) == 0)
 641                 return;
 642
 643         ret = alloc_return(expr);
 644
 645         stree = __get_cur_stree();
 646         FOR_EACH_MY_SM(my_id, stree, tmp) {
 647                 if (tmp->state == &locked) {
 648                         add_tracker(&ret->locked, tmp->owner, tmp->name,
 649                                 tmp->sym);
 650                 } else if (tmp->state == &unlocked) {
 651                         add_tracker(&ret->unlocked, tmp->owner, tmp->name,
 652                                 tmp->sym);
 653                 } else if (tmp->state == &start_state) {
 654                         struct smatch_state *s;
 655
 656                         s = get_start_state(tmp);
 657                         if (s == &locked)
 658                                 add_tracker(&ret->locked, tmp->owner, tmp->name,
 659                                             tmp->sym);
 660                         if (s == &unlocked)
 661                                 add_tracker(&ret->unlocked, tmp->owner,tmp->name,
 662                                              tmp->sym);
 663                 } else if (tmp->state == &impossible) {
 664                         add_tracker(&ret->impossible, tmp->owner, tmp->name,
 665                                     tmp->sym);
 666                 } else {
 667                         if (check_possible(tmp)) {
 668                                 if (expr)
 669                                         warned_pos = expr->pos;
 670                         }
 671                 }
 672         } END_FOR_EACH_SM(tmp);
 673         add_ptr_list(&all_returns, ret);
 674 }
 675
 676 static void add_line(struct range_list **rl, int line)
 677 {
 678         sval_t sval = sval_type_val(&int_ctype, line);
 679
 680         add_range(rl, sval, sval);
 681 }
 682
 683 static int line_printed(struct range_list *rl, int line)
 684 {
 685         sval_t sval = sval_type_val(&int_ctype, line);
 686
 687         return rl_has_sval(rl, sval);
 688 }
 689
 690 static void print_inconsistent_returns(struct tracker *lock,
 691                                 struct smatch_state *start)
 692 {
 693         struct locks_on_return *tmp;
 694         struct range_list *printed = NULL;
 695         int i;
 696
 697         sm_warning("inconsistent returns '%s'.", lock->name);
 698         sm_printf("  Locked on:   ");
 699
 700         i = 0;
 701         FOR_EACH_PTR(all_returns, tmp) {
 702                 if (line_printed(printed, tmp->line))
 703                         continue;
 704                 if (in_tracker_list(tmp->unlocked, lock->owner, lock->name, lock->sym))
 705                         continue;
 706                 if (in_tracker_list(tmp->locked, lock->owner, lock->name, lock->sym)) {
 707                         if (i++)
 708                                 sm_printf("               ");
 709                         sm_printf("line %d\n", tmp->line);
 710                         add_line(&printed, tmp->line);
 711                         continue;
 712                 }
 713                 if (start == &locked) {
 714                         if (i++)
 715                                 sm_printf("               ");
 716                         sm_printf("line %d\n", tmp->line);
 717                         add_line(&printed, tmp->line);
 718                 }
 719         } END_FOR_EACH_PTR(tmp);
 720
 721         sm_printf("  Unlocked on: ");
 722         printed = NULL;
 723         i = 0;
 724         FOR_EACH_PTR(all_returns, tmp) {
 725                 if (line_printed(printed, tmp->line))
 726                         continue;
 727                 if (in_tracker_list(tmp->unlocked, lock->owner, lock->name, lock->sym)) {
 728                         if (i++)
 729                                 sm_printf("               ");
 730                         sm_printf("line %d\n", tmp->line);
 731                         add_line(&printed, tmp->line);
 732                         continue;
 733                 }
 734                 if (in_tracker_list(tmp->locked, lock->owner, lock->name, lock->sym))
 735                         continue;
 736                 if (start == &unlocked) {
 737                         if (i++)
 738                                 sm_printf("               ");
 739                         sm_printf("line %d\n", tmp->line);
 740                         add_line(&printed, tmp->line);
 741                 }
 742         } END_FOR_EACH_PTR(tmp);
 743 }
 744
 745 static int matches_return_type(struct range_list *rl, enum return_type type)
 746 {
 747         sval_t zero_sval = ll_to_sval(0);
 748         sval_t one_sval = ll_to_sval(1);
 749
 750         /* All these double negatives are super ugly!  */
 751
 752         switch (type) {
 753         case ret_zero:
 754                 return !possibly_true_rl(rl, SPECIAL_NOTEQUAL, alloc_rl(zero_sval, zero_sval));
 755         case ret_one:
 756                 return !possibly_true_rl(rl, SPECIAL_NOTEQUAL, alloc_rl(one_sval, one_sval));
 757         case ret_non_zero:
 758                 return !possibly_true_rl(rl, SPECIAL_EQUAL, alloc_rl(zero_sval, zero_sval));
 759         case ret_negative:
 760                 return !possibly_true_rl(rl, SPECIAL_GTE, alloc_rl(zero_sval, zero_sval));
 761         case ret_positive:
 762                 return !possibly_true_rl(rl, '<', alloc_rl(zero_sval, zero_sval));
 763         case ret_any:
 764         default:
 765                 return 1;
 766         }
 767 }
 768
 769 static int match_held(struct tracker *lock, struct locks_on_return *this_return, struct smatch_state *start)
 770 {
 771         if (in_tracker_list(this_return->impossible, lock->owner, lock->name, lock->sym))
 772                 return 0;
 773         if (in_tracker_list(this_return->unlocked, lock->owner, lock->name, lock->sym))
 774                 return 0;
 775         if (in_tracker_list(this_return->locked, lock->owner, lock->name, lock->sym))
 776                 return 1;
 777         if (start == &unlocked)
 778                 return 0;
 779         return 1;
 780 }
 781
 782 static int match_released(struct tracker *lock, struct locks_on_return *this_return, struct smatch_state *start)
 783 {
 784         if (in_tracker_list(this_return->impossible, lock->owner, lock->name, lock->sym))
 785                 return 0;
 786         if (in_tracker_list(this_return->unlocked, lock->owner, lock->name, lock->sym))
 787                 return 1;
 788         if (in_tracker_list(this_return->locked, lock->owner, lock->name, lock->sym))
 789                 return 0;
 790         if (start == &unlocked)
 791                 return 1;
 792         return 0;
 793 }
 794
 795 static int held_on_return(struct tracker *lock, struct smatch_state *start, enum return_type type)
 796 {
 797         struct locks_on_return *tmp;
 798
 799         FOR_EACH_PTR(all_returns, tmp) {
 800                 if (!matches_return_type(tmp->return_values, type))
 801                         continue;
 802                 if (match_held(lock, tmp, start))
 803                         return 1;
 804         } END_FOR_EACH_PTR(tmp);
 805         return 0;
 806 }
 807
 808 static int released_on_return(struct tracker *lock, struct smatch_state *start, enum return_type type)
 809 {
 810         struct locks_on_return *tmp;
 811
 812         FOR_EACH_PTR(all_returns, tmp) {
 813                 if (!matches_return_type(tmp->return_values, type))
 814                         continue;
 815                 if (match_released(lock, tmp, start))
 816                         return 1;
 817         } END_FOR_EACH_PTR(tmp);
 818         return 0;
 819 }
 820
 821 static void check_returns_consistently(struct tracker *lock,
 822                                 struct smatch_state *start)
 823 {
 824         struct symbol *type;
 825
 826         if (!held_on_return(lock, start, ret_any) ||
 827             !released_on_return(lock, start, ret_any))
 828                 return;
 829
 830         if (held_on_return(lock, start, ret_zero) &&
 831             !held_on_return(lock, start, ret_non_zero))
 832                 return;
 833
 834         if (held_on_return(lock, start, ret_positive) &&
 835             !held_on_return(lock, start, ret_zero))
 836                 return;
 837
 838         if (held_on_return(lock, start, ret_positive) &&
 839             !held_on_return(lock, start, ret_negative))
 840                 return;
 841
 842         type = cur_func_return_type();
 843         if (type && type->type == SYM_PTR) {
 844                 if (held_on_return(lock, start, ret_non_zero) &&
 845                     !held_on_return(lock, start, ret_zero))
 846                         return;
 847         }
 848
 849         print_inconsistent_returns(lock, start);
 850 }
 851
 852 static void check_consistency(struct symbol *sym)
 853 {
 854         struct tracker *tmp;
 855
 856         FOR_EACH_PTR(starts_locked, tmp) {
 857                 if (in_tracker_list(starts_unlocked, tmp->owner, tmp->name,
 858                                         tmp->sym))
 859                         sm_error("locking inconsistency.  We assume "
 860                                    "'%s' is both locked and unlocked at the "
 861                                    "start.",
 862                                 tmp->name);
 863         } END_FOR_EACH_PTR(tmp);
 864
 865         FOR_EACH_PTR(starts_locked, tmp) {
 866                 check_returns_consistently(tmp, &locked);
 867         } END_FOR_EACH_PTR(tmp);
 868
 869         FOR_EACH_PTR(starts_unlocked, tmp) {
 870                 check_returns_consistently(tmp, &unlocked);
 871         } END_FOR_EACH_PTR(tmp);
 872 }
 873
 874 static void clear_lists(void)
 875 {
 876         struct locks_on_return *tmp;
 877
 878         func_has_transition = FALSE;
 879
 880         free_trackers_and_list(&starts_locked);
 881         free_trackers_and_list(&starts_unlocked);
 882
 883         FOR_EACH_PTR(all_returns, tmp) {
 884                 free_trackers_and_list(&tmp->locked);
 885                 free_trackers_and_list(&tmp->unlocked);
 886                 free(tmp);
 887         } END_FOR_EACH_PTR(tmp);
 888         __free_ptr_list((struct ptr_list **)&all_returns);
 889 }
 890
 891 static void match_func_end(struct symbol *sym)
 892 {
 893         if (__inline_fn)
 894                 return;
 895
 896         if (func_has_transition)
 897                 check_consistency(sym);
 898 }
 899
 900 static void match_after_func(struct symbol *sym)
 901 {
 902         if (__inline_fn)
 903                 return;
 904         clear_lists();
 905 }
 906
 907 static void register_lock(int index)
 908 {
 909         struct lock_info *lock = &lock_table[index];
 910         void *idx = INT_PTR(index);
 911
 912         if (lock->return_type == ret_non_zero) {
 913                 return_implies_state(lock->function, valid_ptr_min, valid_ptr_max, &match_lock_held, idx);
 914                 return_implies_state(lock->function, 0, 0, &match_lock_failed, idx);
 915         } else if (lock->return_type == ret_any && lock->arg == RETURN_VAL) {
 916                 add_function_assign_hook(lock->function, &match_returns_locked, idx);
 917         } else if (lock->return_type == ret_any) {
 918                 add_function_hook(lock->function, &match_lock_unlock, idx);
 919         } else if (lock->return_type == ret_zero) {
 920                 return_implies_state(lock->function, 0, 0, &match_lock_held, idx);
 921                 return_implies_state(lock->function, -4095, -1, &match_lock_failed, idx);
 922         } else if (lock->return_type == ret_one) {
 923                 return_implies_state(lock->function, 1, 1, &match_lock_held, idx);
 924                 return_implies_state(lock->function, 0, 0, &match_lock_failed, idx);
 925         }
 926 }
 927
 928 static void load_table(struct lock_info *_lock_table, int size)
 929 {
 930         int i;
 931
 932         lock_table = _lock_table;
 933
 934         for (i = 0; i < size; i++) {
 935                 if (lock_table[i].action == LOCK)
 936                         register_lock(i);
 937                 else
 938                         add_function_hook(lock_table[i].function, &match_lock_unlock, INT_PTR(i));
 939         }
 940 }
 941
 942 /* print_held_locks() is used in check_call_tree.c */
 943 void print_held_locks(void)
 944 {
 945         struct stree *stree;
 946         struct sm_state *sm;
 947         int i = 0;
 948
 949         stree = __get_cur_stree();
 950         FOR_EACH_MY_SM(my_id, stree, sm) {
 951                 if (sm->state != &locked)
 952                         continue;
 953                 if (i++)
 954                         sm_printf(" ");
 955                 sm_printf("'%s'", sm->name);
 956         } END_FOR_EACH_SM(sm);
 957 }
 958
 959 void check_locking(int id)
 960 {
 961         my_id = id;
 962
 963         if (option_project == PROJ_WINE)
 964                 load_table(wine_lock_table, ARRAY_SIZE(wine_lock_table));
 965         else if (option_project == PROJ_KERNEL)
 966                 load_table(kernel_lock_table, ARRAY_SIZE(kernel_lock_table));
 967         else
 968                 return;
 969
 970         add_unmatched_state_hook(my_id, &unmatched_state);
 971         add_pre_merge_hook(my_id, &pre_merge_hook);
 972         add_split_return_callback(match_return);
 973         add_hook(&match_func_end, END_FUNC_HOOK);
 974         add_hook(&match_after_func, AFTER_FUNC_HOOK);
 975
 976 }