call __split_expr()
[smatch.git] / check_locking.c
blob24968f040f9d417b6522f7970c005106b8d342e2
1 /*
2 * sparse/check_locking.c
4 * Copyright (C) 2009 Dan Carpenter.
6 * Licensed under the Open Software License version 1.1
8 */
11 * This test checks that locks are held the same across all returns.
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.
17 #include "parse.h"
18 #include "smatch.h"
19 #include "smatch_slist.h"
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,
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,
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,
75 /* These functions return 0 on success */
76 static const char *reverse_cond_funcs[] = {
77 "down_trylock",
78 "down_interruptible",
79 NULL,
82 /* todo still need to handle__raw_spin_is_locked */
85 struct locked_call {
86 const char *function;
87 const char *lock;
90 static struct locked_call lock_needed[] = {
91 {"tty_ldisc_ref_wait", "tty_ldisc_lock"},
94 static int my_id;
96 static struct tracker_list *starts_locked;
97 static struct tracker_list *starts_unlocked;
99 struct locks_on_return {
100 int line;
101 struct tracker_list *locked;
102 struct tracker_list *unlocked;
104 DECLARE_PTR_LIST(return_list, struct locks_on_return);
105 static struct return_list *all_returns;
107 STATE(locked);
108 STATE(unlocked);
110 static char *match_func(const char *list[], char *fn_name,
111 struct expression_list *args)
113 struct expression *lock_expr;
114 int i;
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);
122 return NULL;
125 static char kernel[] = "kernel";
126 static char *match_lock_func(char *fn_name, struct expression_list *args)
128 char *arg;
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;
138 static char *match_unlock_func(char *fn_name, struct expression_list *args)
140 char *arg;
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;
150 static void check_locks_needed(const char *fn_name)
152 struct smatch_state *state;
153 int i;
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);
167 static void match_call(struct expression *expr)
169 char *fn_name;
170 char *lock_name;
171 struct sm_state *sm;
173 fn_name = get_variable_from_expr(expr->fn, NULL);
174 if (!fn_name)
175 return;
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;
197 static void match_condition(struct expression *expr)
199 char *fn_name;
200 char *lock_name;
202 if (expr->type != EXPR_CALL)
203 return;
205 fn_name = get_variable_from_expr(expr->fn, NULL);
206 if (!fn_name)
207 return;
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);
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);
219 free_string(fn_name);
220 return;
223 static struct locks_on_return *alloc_return(int line)
225 struct locks_on_return *ret;
227 ret = malloc(sizeof(*ret));
228 ret->line = line;
229 ret->locked = NULL;
230 ret->unlocked = NULL;
231 return ret;
234 static void check_possible(struct sm_state *sm)
236 struct sm_state *tmp;
237 int islocked = 0;
238 int isunlocked = 0;
239 int undef = 0;
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);
253 static void match_return(struct statement *stmt)
255 struct locks_on_return *ret;
256 struct state_list *slist;
257 struct sm_state *tmp;
259 ret = alloc_return(get_lineno());
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);
272 } END_FOR_EACH_PTR(tmp);
273 add_ptr_list(&all_returns, ret);
276 static void check_returns_consistently(struct tracker *lock,
277 struct smatch_state *start)
279 int returns_locked = 0;
280 int returns_unlocked = 0;
281 struct locks_on_return *tmp;
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);
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);
302 static void clear_lists()
304 struct locks_on_return *tmp;
306 __free_ptr_list((struct ptr_list **)&starts_locked);
307 __free_ptr_list((struct ptr_list **)&starts_unlocked);
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);
316 static void check_consistency(struct symbol *sym)
318 struct tracker *tmp;
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);
328 FOR_EACH_PTR(starts_locked, tmp) {
329 check_returns_consistently(tmp, &locked);
330 } END_FOR_EACH_PTR(tmp);
332 FOR_EACH_PTR(starts_unlocked, tmp) {
333 check_returns_consistently(tmp, &unlocked);
334 } END_FOR_EACH_PTR(tmp);
336 clear_lists();
339 void register_locking(int id)
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);