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  * For this test let's look for functions that return a negative value
  12  * with a spinlock held.
  13  *
  14  * One short coming is that it assumes a function isn't supposed
  15  * to return negative with a lock held.  Perhaps the function was
  16  * called with the lock held.  A more complicated script could check that.
  17  *
  18  */
  19
  20 #include "parse.h"
  21 #include "smatch.h"
  22 #include "smatch_slist.h"  // blast this was supposed to be internal only stuff
  23
  24 static int my_id;
  25
  26 STATE(lock);
  27 STATE(unlock);
  28
  29 /*
  30  * merge_func() can go away when we fix the core to just store all the possible
  31  * states.
  32  *
  33  * The parameters are passed in alphabetical order with NULL at the beginning
  34  * of the alphabet.  (s2 is never NULL).
  35  */
  36
  37 static struct smatch_state *merge_func(const char *name, struct symbol *sym,
  38                                        struct smatch_state *s1,
  39                                        struct smatch_state *s2)
  40 {
  41         if (s1 == NULL)
  42                 return s2;
  43         return &undefined;
  44
  45 }
  46
  47 static void match_call(struct expression *expr)
  48 {
  49         char *fn_name;
  50         struct expression *spin_expr;
  51         char *spin_name;
  52
  53         fn_name = get_variable_from_expr(expr->fn, NULL);
  54         if (!fn_name || (strcmp(fn_name, "_spin_lock") && strcmp(fn_name, "_spin_unlock")))
  55                 return;
  56
  57         spin_expr = get_argument_from_call_expr(expr->args, 0);
  58         spin_name = get_variable_from_expr(spin_expr, NULL);
  59         if (!strcmp(fn_name, "_spin_lock")) {
  60                 set_state(spin_name, my_id, NULL, &lock);
  61         } else {
  62                 set_state(spin_name, my_id, NULL, &unlock);
  63         }
  64         free_string(fn_name);
  65 }
  66
  67 static void match_condition(struct expression *expr)
  68 {
  69         /* __raw_spin_is_locked */
  70 }
  71
  72 static int possibly_negative(struct expression *expr)
  73 {
  74         char *name;
  75         struct symbol *sym;
  76         struct state_list *slist;
  77         struct sm_state *tmp;
  78
  79         name = get_variable_from_expr(expr, &sym);
  80         if (!name || !sym)
  81                 return 0;
  82         slist = get_possible_states(name, SMATCH_EXTRA, sym);
  83         FOR_EACH_PTR(slist, tmp) {
  84                 int value = 0;
  85
  86                 if (tmp->state->data)
  87                         value =  *(int *)tmp->state->data;
  88
  89                 if (value < 0) {
  90                         return 1;
  91                 }
  92                 1;
  93         } END_FOR_EACH_PTR(tmp);
  94         return 0;
  95 }
  96
  97 static void match_return(struct statement *stmt)
  98 {
  99         int ret_val;
 100         struct state_list *slist;
 101         struct sm_state *tmp;
 102
 103         ret_val = get_value(stmt->ret_value);
 104         if (ret_val >= 0) {
 105                 return;
 106         }
 107         if (ret_val == UNDEFINED) {
 108                 if (!possibly_negative(stmt->ret_value))
 109                         return;
 110         }
 111
 112         slist = get_all_states(my_id);
 113         FOR_EACH_PTR(slist, tmp) {
 114                 if (tmp->state != &unlock)
 115                         smatch_msg("returned negative with %s spinlock held",
 116                                    tmp->name);
 117         } END_FOR_EACH_PTR(tmp);
 118 }
 119
 120 void register_locking(int id)
 121 {
 122         my_id = id;
 123         add_merge_hook(my_id, &merge_func);
 124         add_hook(&match_call, FUNCTION_CALL_HOOK);
 125         add_hook(&match_return, RETURN_HOOK);
 126 }