smatch_locking_type.c

   1 /*
   2  * Copyright 2024 Linaro Ltd.
   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 #include "smatch.h"
  19 #include "smatch_extra.h"
  20 #include "smatch_slist.h"
  21
  22 static int my_id;
  23
  24 STATE(lock);
  25 STATE(unlock);
  26
  27 static struct smatch_state *get_opposite(struct smatch_state *state)
  28 {
  29         if (state == &lock)
  30                 return &unlock;
  31         if (state == &unlock)
  32                 return &lock;
  33         return NULL;
  34 }
  35
  36 static struct stree *start_states;
  37
  38 static void set_start_state(const char *name, struct smatch_state *start)
  39 {
  40         struct smatch_state *orig;
  41
  42         if (!name || !start)
  43                 return;
  44
  45         if (get_state(my_id, name, NULL))
  46                 return;
  47
  48         orig = get_state_stree(start_states, my_id, name, NULL);
  49         if (!orig)
  50                 set_state_stree(&start_states, my_id, name, NULL, start);
  51         else if (orig != start)
  52                 set_state_stree(&start_states, my_id, name, NULL, &undefined);
  53 }
  54
  55 static struct smatch_state *get_start_state(struct sm_state *sm)
  56 {
  57         struct smatch_state *orig;
  58
  59         if (!sm)
  60                 return NULL;
  61
  62         orig = get_state_stree(start_states, my_id, sm->name, sm->sym);
  63         if (orig)
  64                 return orig;
  65         return NULL;
  66 }
  67
  68 static void update_state(const char *member, struct smatch_state *state)
  69 {
  70         set_start_state(member, get_opposite(state));
  71         set_state(my_id, member, NULL, state);
  72 }
  73
  74 static void update_expr(struct expression *expr, struct smatch_state *state)
  75 {
  76         char *member;
  77
  78         if (!expr)
  79                 return;
  80         if (expr->type == EXPR_PREOP && expr->op == '&')
  81                 expr = strip_expr(expr->unop);
  82
  83         member = get_member_name(expr);
  84         if (!member)
  85                 return;
  86
  87         update_state(member, state);
  88 }
  89
  90 static void lock_hook(struct lock_info *info, struct expression *expr, const char *name, struct symbol *sym)
  91 {
  92         update_expr(expr, &lock);
  93 }
  94
  95 static void unlock_hook(struct lock_info *info, struct expression *expr, const char *name, struct symbol *sym)
  96 {
  97         update_expr(expr, &unlock);
  98 }
  99
 100 bool locking_type_is_start_state(void)
 101 {
 102         struct sm_state *sm;
 103         int cnt;
 104
 105         cnt = 0;
 106         FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
 107                 if (++cnt > 1)
 108                         return false;
 109                 if (sm->state != get_start_state(sm))
 110                         return false;
 111         } END_FOR_EACH_SM(sm);
 112
 113         return cnt == 1;
 114 }
 115
 116 static int get_db_type(struct sm_state *sm)
 117 {
 118         if (sm->state == &lock)
 119                 return TYPE_LOCK2;
 120         if (sm->state == &unlock)
 121                 return TYPE_UNLOCK2;
 122
 123         return -1;
 124 }
 125
 126 static bool is_clean_transition(struct sm_state *sm)
 127 {
 128         struct smatch_state *start;
 129
 130         start = get_start_state(sm);
 131         if (!start)
 132                 return false;
 133         if (start == get_opposite(sm->state))
 134                 return true;
 135         return false;
 136 }
 137
 138 static void match_return_info(int return_id, char *return_ranges, struct expression *expr)
 139 {
 140         struct sm_state *sm;
 141         int type;
 142
 143         FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
 144                 type = get_db_type(sm);
 145                 if (local_debug)
 146                         sm_msg("%s: type=%d sm='%s' clean=%d", __func__,
 147                                type, show_sm(sm), is_clean_transition(sm));
 148                 if (type == -1)
 149                         continue;
 150
 151                 if (!is_clean_transition(sm))
 152                         continue;
 153
 154                 sql_insert_return_states(return_id, return_ranges, type,
 155                                          -2, sm->name, "");
 156         } END_FOR_EACH_SM(sm);
 157 }
 158
 159 static void db_param_locked(struct expression *expr, int param, char *key, char *value)
 160 {
 161         while (expr && expr->type == EXPR_ASSIGNMENT)
 162                 expr = strip_expr(expr->right);
 163         if (expr && expr->type == EXPR_CALL && is_locking_primitive_expr(expr->fn))
 164                 return;
 165
 166         update_state(key, &lock);
 167 }
 168
 169 static void db_param_unlocked(struct expression *expr, int param, char *key, char *value)
 170 {
 171         while (expr && expr->type == EXPR_ASSIGNMENT)
 172                 expr = strip_expr(expr->right);
 173         if (expr && expr->type == EXPR_CALL && is_locking_primitive_expr(expr->fn))
 174                 return;
 175
 176         update_state(key, &unlock);
 177 }
 178
 179 void register_locking_type(int id)
 180 {
 181         my_id = id;
 182
 183         add_function_data((unsigned long *)&start_states);
 184
 185         add_lock_hook(&lock_hook);
 186         add_unlock_hook(&unlock_hook);
 187         add_restore_hook(&unlock_hook);
 188
 189         select_return_states_hook(TYPE_LOCK2, &db_param_locked);
 190         select_return_states_hook(TYPE_UNLOCK2, &db_param_unlocked);
 191
 192         add_split_return_callback(match_return_info);
 193 }