1 /* 2 * Copyright (C) 2014 Oracle. 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 #define _GNU_SOURCE 19 #include <string.h> 20 #include "smatch.h" 21 #include "smatch_slist.h" 22 23 static int my_id; 24 25 STATE(checked); 26 STATE(modified); 27 28 struct stree *to_check; 29 30 static struct statement *get_cur_stmt(void) 31 { 32 return last_ptr_list((struct ptr_list *)big_statement_stack); 33 } 34 35 static void set_modified(struct sm_state *sm, struct expression *mod_expr) 36 { 37 set_state(my_id, sm->name, sm->sym, &modified); 38 } 39 40 static struct expression *strip_condition(struct expression *expr) 41 { 42 expr = strip_expr(expr); 43 44 if (expr->type == EXPR_PREOP && expr->op == '!') 45 return strip_condition(expr->unop); 46 47 if (expr->type == EXPR_COMPARE && 48 (expr->op == SPECIAL_EQUAL || 49 expr->op == SPECIAL_NOTEQUAL)) { 50 if (is_zero(expr->left)) 51 return strip_condition(expr->right); 52 if (is_zero(expr->right)) 53 return strip_condition(expr->left); 54 } 55 56 return expr; 57 } 58 59 static int conditions_match(struct expression *cond, struct expression *prev) 60 { 61 prev = strip_condition(prev); 62 63 if (prev == cond) 64 return 1; 65 66 if (prev->type == EXPR_LOGICAL) { 67 if (conditions_match(cond, prev->left) || 68 conditions_match(cond, prev->right)) 69 return 1; 70 } 71 72 return 0; 73 } 74 75 /* 76 * People like to do "if (foo) { ... } else if (!foo) { ... }". Don't 77 * complain when they do that even though it is nonsense. 78 */ 79 static int is_obvious_else(struct expression *cond) 80 { 81 struct statement *parent; 82 struct expression *prev; 83 84 if (!get_cur_stmt()) 85 return 0; 86 parent = get_cur_stmt()->parent; 87 if (!parent) 88 return 0; 89 90 if (parent->type != STMT_IF) 91 return 0; 92 93 if (!parent->if_false) 94 return 0; 95 if (parent->if_false != get_cur_stmt()) 96 return 0; 97 98 prev = strip_condition(parent->if_conditional); 99 100 return conditions_match(cond, prev); 101 } 102 103 static int name_means_synchronize(const char *name) 104 { 105 if (!name) 106 return 0; 107 108 if (strcasestr(name, "wait")) 109 return 1; 110 if (strcasestr(name, "down")) 111 return 1; 112 if (strcasestr(name, "lock") && !strcasestr(name, "unlock")) 113 return 1; 114 if (strcasestr(name, "delay")) 115 return 1; 116 if (strcasestr(name, "schedule")) 117 return 1; 118 if (strcmp(name, "smp_rmb") == 0) 119 return 1; 120 if (strcmp(name, "mb") == 0) 121 return 1; 122 if (strcmp(name, "barrier") == 0) 123 return 1; 124 return 0; 125 } 126 127 static int previous_statement_was_synchronize(void) 128 { 129 struct statement *stmt; 130 struct position pos; 131 struct position prev_pos; 132 char *ident; 133 134 if (__prev_stmt) { 135 prev_pos = __prev_stmt->pos; 136 prev_pos.line -= 3; 137 } else { 138 prev_pos = __cur_stmt->pos; 139 prev_pos.line -= 5; 140 } 141 142 FOR_EACH_PTR_REVERSE(big_statement_stack, stmt) { 143 if (stmt->pos.line < prev_pos.line) 144 return 0; 145 pos = stmt->pos; 146 ident = get_macro_name(pos); 147 if (name_means_synchronize(ident)) 148 return 1; 149 ident = pos_ident(pos); 150 if (!ident) 151 continue; 152 if (strcmp(ident, "if") == 0) { 153 pos.pos += 4; 154 ident = pos_ident(pos); 155 if (!ident) 156 continue; 157 } 158 if (name_means_synchronize(ident)) 159 return 1; 160 } END_FOR_EACH_PTR_REVERSE(stmt); 161 return 0; 162 } 163 164 static void match_condition(struct expression *expr) 165 { 166 struct smatch_state *state; 167 sval_t dummy; 168 char *name; 169 170 if (inside_loop()) 171 return; 172 173 if (get_value(expr, &dummy)) 174 return; 175 176 if (get_macro_name(expr->pos)) 177 return; 178 179 state = get_stored_condition(expr); 180 if (!state || !state->data) 181 return; 182 if (get_macro_name(((struct expression *)state->data)->pos)) 183 return; 184 185 /* 186 * we allow double checking for NULL because people do this all the time 187 * and trying to stop them is a losers' battle. 188 */ 189 if (is_pointer(expr) && implied_condition_true(expr)) 190 return; 191 192 if (definitely_inside_loop()) { 193 struct symbol *sym; 194 195 if (__inline_fn) 196 return; 197 198 name = expr_to_var_sym(expr, &sym); 199 if (!name) 200 return; 201 set_state_expr(my_id, expr, &checked); 202 set_state_stree(&to_check, my_id, name, sym, &checked); 203 free_string(name); 204 return; 205 } 206 207 if (is_obvious_else(state->data)) 208 return; 209 210 /* 211 * It's common to test something, then take a lock and test if it is 212 * still true. 213 */ 214 if (previous_statement_was_synchronize()) 215 return; 216 217 name = expr_to_str(expr); 218 sm_warning("we tested '%s' before and it was '%s'", name, state->name); 219 free_string(name); 220 } 221 222 int get_check_line(struct sm_state *sm) 223 { 224 struct sm_state *tmp; 225 226 FOR_EACH_PTR(sm->possible, tmp) { 227 if (tmp->state == &checked) 228 return tmp->line; 229 } END_FOR_EACH_PTR(tmp); 230 231 return get_lineno(); 232 } 233 234 static void after_loop(struct statement *stmt) 235 { 236 struct sm_state *check, *sm; 237 238 if (!stmt || stmt->type != STMT_ITERATOR) 239 return; 240 if (definitely_inside_loop()) 241 return; 242 if (__inline_fn) 243 return; 244 245 FOR_EACH_SM(to_check, check) { 246 continue; 247 sm = get_sm_state(my_id, check->name, check->sym); 248 continue; 249 if (!sm) 250 continue; 251 if (slist_has_state(sm->possible, &modified)) 252 continue; 253 254 sm_printf("%s:%d %s() ", get_filename(), get_check_line(sm), get_function()); 255 sm_printf("warn: we tested '%s' already\n", check->name); 256 } END_FOR_EACH_SM(check); 257 258 free_stree(&to_check); 259 } 260 261 static void match_func_end(struct symbol *sym) 262 { 263 if (__inline_fn) 264 return; 265 if (to_check) 266 sm_msg("debug: odd... found an function without an end."); 267 free_stree(&to_check); 268 } 269 270 void check_double_checking(int id) 271 { 272 my_id = id; 273 274 if (!option_spammy) 275 return; 276 277 add_hook(&match_condition, CONDITION_HOOK); 278 add_modification_hook(my_id, &set_modified); 279 add_hook(after_loop, STMT_HOOK_AFTER); 280 add_hook(&match_func_end, AFTER_FUNC_HOOK); 281 } 282