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
  17 #include "parse.h"
  18 #include "smatch.h"
  19 #include "smatch_slist.h"
  20
  21 static const char *lock_funcs[] = {
  22         "_spin_lock",
  23         "_spin_lock_irqsave",
  24         "_spin_lock_irq",
  25         "_spin_lock_bh",
  26         "_spin_lock_nested",
  27         "_spin_lock_irqsave_nested",
  28         "_raw_spin_lock",
  29         "_read_lock",
  30         "_read_lock_irqsave",
  31         "_read_lock_irq",
  32         "_read_lock_bh",
  33         "_write_lock",
  34         "_write_lock_irqsave",
  35         "_write_lock_irq",
  36         "_write_lock_bh",
  37         "down",
  38         NULL,
  39 };
  40
  41 static const char *unlock_funcs[] = {
  42         "_spin_unlock",
  43         "_spin_unlock_irqrestore",
  44         "_spin_unlock_irq",
  45         "_spin_unlock_bh",
  46         "_raw_spin_unlock",
  47         "_read_unlock",
  48         "_read_unlock_irqrestore",
  49         "_read_unlock_irq",
  50         "_read_unlock_bh",
  51         "_write_unlock",
  52         "_write_unlock_irqrestore",
  53         "_write_unlock_irq",
  54         "_write_unlock_bh",
  55         "up",
  56         NULL,
  57 };
  58
  59 static const char *conditional_funcs[] = {
  60         "_spin_trylock",
  61         "_spin_trylock_bh",
  62         "_read_trylock",
  63         "_write_trylock",
  64         "generic__raw_read_trylock",
  65         "_raw_spin_trylock",
  66         "_raw_read_trylock",
  67         "_raw_write_trylock",
  68         "__raw_spin_trylock",
  69         "__raw_read_trylock",
  70         "__raw_write_trylock",
  71         "__raw_write_trylock",
  72         NULL,
  73 };
  74
  75 /* These functions return 0 on success */
  76 static const char *reverse_cond_funcs[] = {
  77         "down_trylock",
  78         "down_interruptible",
  79         NULL,
  80 };
  81
  82 /* todo still need to handle__raw_spin_is_locked */
  83
  84
  85 struct locked_call {
  86         const char *function;
  87         const char *lock;
  88 };
  89
  90 static struct locked_call lock_needed[] = {
  91         {"tty_ldisc_ref_wait", "tty_ldisc_lock"},
  92 };
  93
  94 static int my_id;
  95
  96 static struct tracker_list *starts_locked;
  97 static struct tracker_list *starts_unlocked;
  98
  99 struct locks_on_return {
 100         int line;
 101         struct tracker_list *locked;
 102         struct tracker_list *unlocked;
 103 };
 104 DECLARE_PTR_LIST(return_list, struct locks_on_return);
 105 static struct return_list *all_returns;
 106
 107 STATE(locked);
 108 STATE(unlocked);
 109
 110 static char *match_func(const char *list[], char *fn_name,
 111                         struct expression_list *args)
 112 {
 113         struct expression *lock_expr;
 114         int i;
 115
 116         for (i = 0; list[i]; i++) {
 117                 if (!strcmp(fn_name, list[i])) {
 118                         lock_expr = get_argument_from_call_expr(args, 0);
 119                         return get_variable_from_expr(lock_expr, NULL);
 120                 }
 121         }
 122         return NULL;
 123 }
 124
 125 static char kernel[] = "kernel";
 126 static char *match_lock_func(char *fn_name, struct expression_list *args)
 127 {
 128         char *arg;
 129
 130         arg = match_func(lock_funcs, fn_name, args);
 131         if (arg)
 132                 return arg;
 133         if (!strcmp(fn_name, "lock_kernel"))
 134                 return kernel;
 135         return NULL;
 136 }
 137
 138 static char *match_unlock_func(char *fn_name, struct expression_list *args)
 139 {
 140         char *arg;
 141
 142         arg = match_func(unlock_funcs, fn_name, args);
 143         if (arg)
 144                 return arg;
 145         if (!strcmp(fn_name, "unlock_kernel"))
 146                 return kernel;
 147         return NULL;
 148 }
 149
 150 static void check_locks_needed(const char *fn_name)
 151 {
 152         struct smatch_state *state;
 153         int i;
 154
 155         for (i = 0; i < sizeof(lock_needed)/sizeof(struct locked_call); i++) {
 156                 if (!strcmp(fn_name, lock_needed[i].function)) {
 157                         state = get_state(lock_needed[i].lock, my_id, NULL);
 158                         if (state != &locked) {
 159                                 smatch_msg("%s called without holding '%s' lock",
 160                                         lock_needed[i].function,
 161                                         lock_needed[i].lock);
 162                         }
 163                 }
 164         }
 165 }
 166
 167 static void match_call(struct expression *expr)
 168 {
 169         char *fn_name;
 170         char *lock_name;
 171         struct sm_state *sm;
 172
 173         fn_name = get_variable_from_expr(expr->fn, NULL);
 174         if (!fn_name)
 175                 return;
 176
 177         if ((lock_name = match_lock_func(fn_name, expr->args))) {
 178                 sm = get_sm_state(lock_name, my_id, NULL);
 179                 if (!sm)
 180                         add_tracker(&starts_unlocked, lock_name, my_id, NULL);
 181                 if (sm && slist_has_state(sm->possible, &locked))
 182                         smatch_msg("double lock '%s'", lock_name);
 183                 set_state(lock_name, my_id, NULL, &locked);
 184         } else if ((lock_name = match_unlock_func(fn_name, expr->args))) {
 185                 sm = get_sm_state(lock_name, my_id, NULL);
 186                 if (!sm)
 187                         add_tracker(&starts_locked, lock_name, my_id, NULL);
 188                 if (sm && slist_has_state(sm->possible, &unlocked))
 189                         smatch_msg("double unlock '%s'", lock_name);
 190                 set_state(lock_name, my_id, NULL, &unlocked);
 191         } else
 192                 check_locks_needed(fn_name);
 193         free_string(fn_name);
 194         return;
 195 }
 196
 197 static void match_condition(struct expression *expr)
 198 {
 199         char *fn_name;
 200         char *lock_name;
 201
 202         if (expr->type != EXPR_CALL)
 203                 return;
 204
 205         fn_name = get_variable_from_expr(expr->fn, NULL);
 206         if (!fn_name)
 207                 return;
 208
 209         if ((lock_name = match_func(conditional_funcs, fn_name, expr->args))) {
 210                 if (!get_state(lock_name, my_id, NULL))
 211                         add_tracker(&starts_unlocked, lock_name, my_id, NULL);
 212                 set_true_false_states(lock_name, my_id, NULL, &locked, &unlocked);
 213         }
 214         if ((lock_name = match_func(reverse_cond_funcs, fn_name, expr->args))) {
 215                 if (!get_state(lock_name, my_id, NULL))
 216                         add_tracker(&starts_unlocked, lock_name, my_id, NULL);
 217                 set_true_false_states(lock_name, my_id, NULL, &unlocked, &locked);
 218         }
 219         free_string(fn_name);
 220         return;
 221 }
 222
 223 static struct locks_on_return *alloc_return(int line)
 224 {
 225         struct locks_on_return *ret;
 226
 227         ret = malloc(sizeof(*ret));
 228         ret->line = line;
 229         ret->locked = NULL;
 230         ret->unlocked = NULL;
 231         return ret;
 232 }
 233
 234 static void check_possible(struct sm_state *sm)
 235 {
 236         struct sm_state *tmp;
 237         int islocked = 0;
 238         int isunlocked = 0;
 239         int undef = 0;
 240
 241         FOR_EACH_PTR(sm->possible, tmp) {
 242                 if (tmp->state == &locked)
 243                         islocked = 1;
 244                 else if (tmp->state == &unlocked)
 245                         isunlocked = 1;
 246                 else if (tmp->state == &undefined)
 247                         undef = 1;
 248         } END_FOR_EACH_PTR(tmp);
 249         if (islocked && (isunlocked || undef))
 250                 smatch_msg("Unclear if '%s' is locked or unlocked.", tmp->name);
 251 }
 252
 253 static void match_return(struct statement *stmt)
 254 {
 255         struct locks_on_return *ret;
 256         struct state_list *slist;
 257         struct sm_state *tmp;
 258
 259         ret = alloc_return(get_lineno());
 260
 261         slist = get_all_states(my_id);
 262         FOR_EACH_PTR(slist, tmp) {
 263                 if (tmp->state == &locked) {
 264                         add_tracker(&ret->locked, tmp->name, tmp->owner,
 265                                 tmp->sym);
 266                 } else if (tmp->state == &unlocked) {
 267                         add_tracker(&ret->unlocked, tmp->name, tmp->owner,
 268                                 tmp->sym);
 269                 } else {
 270                         check_possible(tmp);
 271                 }
 272         } END_FOR_EACH_PTR(tmp);
 273         add_ptr_list(&all_returns, ret);
 274 }
 275
 276 static void check_returns_consistently(struct tracker *lock,
 277                                 struct smatch_state *start)
 278 {
 279         int returns_locked = 0;
 280         int returns_unlocked = 0;
 281         struct locks_on_return *tmp;
 282
 283         FOR_EACH_PTR(all_returns, tmp) {
 284                 if (in_tracker_list(tmp->unlocked, lock->name, lock->owner,
 285                                         lock->sym))
 286                         returns_unlocked = tmp->line;
 287                 else if (in_tracker_list(tmp->locked, lock->name, lock->owner,
 288                                                 lock->sym))
 289                         returns_locked = tmp->line;
 290                 else if (start == &locked)
 291                         returns_locked = tmp->line;
 292                 else if (start == &unlocked)
 293                         returns_unlocked = tmp->line;
 294         } END_FOR_EACH_PTR(tmp);
 295
 296         if (returns_locked && returns_unlocked)
 297                 smatch_msg("Lock '%s' held on line %d but not on %d.",
 298                         lock->name, returns_locked, returns_unlocked);
 299
 300 }
 301
 302 static void clear_lists()
 303 {
 304         struct locks_on_return *tmp;
 305
 306         __free_ptr_list((struct ptr_list **)&starts_locked);
 307         __free_ptr_list((struct ptr_list **)&starts_unlocked);
 308
 309         FOR_EACH_PTR(all_returns, tmp) {
 310                 __free_ptr_list((struct ptr_list **)&tmp->locked);
 311                 __free_ptr_list((struct ptr_list **)&tmp->unlocked);
 312         } END_FOR_EACH_PTR(tmp);
 313         __free_ptr_list((struct ptr_list **)&all_returns);
 314 }
 315
 316 static void check_consistency(struct symbol *sym)
 317 {
 318         struct tracker *tmp;
 319
 320         FOR_EACH_PTR(starts_locked, tmp) {
 321                 if (in_tracker_list(starts_unlocked, tmp->name, tmp->owner,
 322                                         tmp->sym))
 323                         smatch_msg("Locking inconsistency.  We assume '%s' is "
 324                                 "both locked and unlocked at the start.",
 325                                 tmp->name);
 326         } END_FOR_EACH_PTR(tmp);
 327
 328         FOR_EACH_PTR(starts_locked, tmp) {
 329                 check_returns_consistently(tmp, &locked);
 330         } END_FOR_EACH_PTR(tmp);
 331
 332         FOR_EACH_PTR(starts_unlocked, tmp) {
 333                 check_returns_consistently(tmp, &unlocked);
 334         } END_FOR_EACH_PTR(tmp);
 335
 336         clear_lists();
 337 }
 338
 339 void register_locking(int id)
 340 {
 341         my_id = id;
 342         add_hook(&match_condition, CONDITION_HOOK);
 343         add_hook(&match_call, FUNCTION_CALL_HOOK);
 344         add_hook(&match_return, RETURN_HOOK);
 345         add_hook(&check_consistency, END_FUNC_HOOK);
 346 }