?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
locking: _atomic_dec_and_lock() is a spinlock()
[smatch.git] / check_locking.c
blobce0544df8b789115699ef929bf55195311f95599
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 * The list of wine locking functions came from an earlier script written
17 * by Michael Stefaniuc.
18 *
19 */
20
21 #include "parse.h"
22 #include "smatch.h"
23 #include "smatch_slist.h"
24
25 static int my_id;
26
27 STATE(locked);
28 STATE(start_state);
29 STATE(unlocked);
30
31 enum action {
32 LOCK,
33 UNLOCK,
34 };
35
36 enum return_type {
37 ret_any,
38 ret_non_zero,
39 ret_zero,
40 };
41
42 #define RETURN_VAL -1
43 #define NO_ARG -2
44
45 struct lock_info {
46 const char *function;
47 enum action action;
48 const char *name;
49 int arg;
50 enum return_type return_type;
51 };
52
53 static struct lock_info wine_lock_table[] = {
54 {"create_window_handle", LOCK, "create_window_handle", RETURN_VAL, ret_non_zero},
55 {"WIN_GetPtr", LOCK, "create_window_handle", RETURN_VAL, ret_non_zero},
56 {"WIN_ReleasePtr", UNLOCK, "create_window_handle", 0, ret_any},
57 {"EnterCriticalSection", LOCK, "CriticalSection", 0, ret_any},
58 {"LeaveCriticalSection", UNLOCK, "CriticalSection", 0, ret_any},
59 {"RtlEnterCriticalSection", LOCK, "RtlCriticalSection", 0, ret_any},
60 {"RtlLeaveCriticalSection", UNLOCK, "RtlCriticalSection", 0, ret_any},
61 {"GDI_GetObjPtr", LOCK, "GDI_Get", 0, ret_non_zero},
62 {"GDI_ReleaseObj", UNLOCK, "GDI_Get", 0, ret_any},
63 {"LdrLockLoaderLock", LOCK, "LdrLockLoaderLock", 2, ret_any},
64 {"LdrUnlockLoaderLock", UNLOCK, "LdrLockLoaderLock", 1, ret_any},
65 {"_lock", LOCK, "_lock", 0, ret_any},
66 {"_unlock", UNLOCK, "_lock", 0, ret_any},
67 {"msiobj_lock", LOCK, "msiobj_lock", 0, ret_any},
68 {"msiobj_unlock", UNLOCK, "msiobj_lock", 0, ret_any},
69 {"RtlAcquirePebLock", LOCK, "PebLock", NO_ARG, ret_any},
70 {"RtlReleasePebLock", UNLOCK, "PebLock", NO_ARG, ret_any},
71 {"server_enter_uninterrupted_section", LOCK, "server_uninterrupted_section", 0, ret_any},
72 {"server_leave_uninterrupted_section", UNLOCK, "server_uninterrupted_section", 0, ret_any},
73 {"RtlLockHeap", LOCK, "RtlLockHeap", 0, ret_any},
74 {"RtlUnlockHeap", UNLOCK, "RtlLockHeap", 0, ret_any},
75 {"_EnterSysLevel", LOCK, "SysLevel", 0, ret_any},
76 {"_LeaveSysLevel", UNLOCK, "SysLevel", 0, ret_any},
77 {"USER_Lock", LOCK, "USER_Lock", NO_ARG, ret_any},
78 {"USER_Unlock", UNLOCK, "USER_Lock", NO_ARG, ret_any},
79 {"wine_tsx11_lock", LOCK, "wine_tsx11_lock", NO_ARG, ret_any},
80 {"wine_tsx11_unlock", UNLOCK, "wine_tsx11_lock", NO_ARG, ret_any},
81 {"wine_tsx11_lock_ptr", LOCK, "wine_tsx11_lock_ptr", NO_ARG, ret_any},
82 {"wine_tsx11_unlock_ptr", UNLOCK, "wine_tsx11_lock_ptr", NO_ARG, ret_any},
83 {"wined3d_mutex_lock", LOCK, "wined3d_mutex_lock", NO_ARG, ret_any},
84 {"wined3d_mutex_unlock", UNLOCK, "wined3d_mutex_lock", NO_ARG, ret_any},
85 {"X11DRV_DIB_Lock", LOCK, "X11DRV_DIB_Lock", 0, ret_any},
86 {"X11DRV_DIB_Unlock", UNLOCK, "X11DRV_DIB_Lock", 0, ret_any},
87 };
88
89 static struct lock_info kernel_lock_table[] = {
90 {"lock_kernel", LOCK, "BKL", NO_ARG, ret_any},
91 {"unlock_kernel", UNLOCK, "BKL", NO_ARG, ret_any},
92
93 {"spin_lock", LOCK, "spin_lock", 0, ret_any},
94 {"spin_unlock", UNLOCK, "spin_lock", 0, ret_any},
95 {"spin_lock_nested", LOCK, "spin_lock", 0, ret_any},
96 {"_spin_lock", LOCK, "spin_lock", 0, ret_any},
97 {"_spin_unlock", UNLOCK, "spin_lock", 0, ret_any},
98 {"_spin_lock_nested", LOCK, "spin_lock", 0, ret_any},
99 {"__spin_lock", LOCK, "spin_lock", 0, ret_any},
100 {"__spin_unlock", UNLOCK, "spin_lock", 0, ret_any},
101 {"__spin_lock_nested", LOCK, "spin_lock", 0, ret_any},
102 {"raw_spin_lock", LOCK, "spin_lock", 0, ret_any},
103 {"raw_spin_unlock", UNLOCK, "spin_lock", 0, ret_any},
104 {"_raw_spin_lock", LOCK, "spin_lock", 0, ret_any},
105 {"_raw_spin_unlock", UNLOCK, "spin_lock", 0, ret_any},
106 {"__raw_spin_lock", LOCK, "spin_lock", 0, ret_any},
107 {"__raw_spin_unlock", UNLOCK, "spin_lock", 0, ret_any},
108
109 {"spin_lock_irq", LOCK, "spin_lock", 0, ret_any},
110 {"spin_unlock_irq", UNLOCK, "spin_lock", 0, ret_any},
111 {"_spin_lock_irq", LOCK, "spin_lock", 0, ret_any},
112 {"_spin_unlock_irq", UNLOCK, "spin_lock", 0, ret_any},
113 {"__spin_lock_irq", LOCK, "spin_lock", 0, ret_any},
114 {"__spin_unlock_irq", UNLOCK, "spin_lock", 0, ret_any},
115 {"_raw_spin_lock_irq", LOCK, "spin_lock", 0, ret_any},
116 {"_raw_spin_unlock_irq", UNLOCK, "spin_lock", 0, ret_any},
117 {"__raw_spin_unlock_irq", UNLOCK, "spin_lock", 0, ret_any},
118 {"spin_lock_irqsave", LOCK, "spin_lock", 0, ret_any},
119 {"spin_unlock_irqrestore", UNLOCK, "spin_lock", 0, ret_any},
120 {"_spin_lock_irqsave", LOCK, "spin_lock", 0, ret_any},
121 {"_spin_unlock_irqrestore", UNLOCK, "spin_lock", 0, ret_any},
122 {"__spin_lock_irqsave", LOCK, "spin_lock", 0, ret_any},
123 {"__spin_unlock_irqrestore", UNLOCK, "spin_lock", 0, ret_any},
124 {"_raw_spin_lock_irqsave", LOCK, "spin_lock", 0, ret_any},
125 {"_raw_spin_unlock_irqrestore", UNLOCK, "spin_lock", 0, ret_any},
126 {"__raw_spin_lock_irqsave", LOCK, "spin_lock", 0, ret_any},
127 {"__raw_spin_unlock_irqrestore", UNLOCK, "spin_lock", 0, ret_any},
128 {"spin_lock_irqsave_nested", LOCK, "spin_lock", 0, ret_any},
129 {"_spin_lock_irqsave_nested", LOCK, "spin_lock", 0, ret_any},
130 {"__spin_lock_irqsave_nested", LOCK, "spin_lock", 0, ret_any},
131 {"_raw_spin_lock_irqsave_nested", LOCK, "spin_lock", 0, ret_any},
132 {"spin_lock_bh", LOCK, "spin_lock", 0, ret_any},
133 {"spin_unlock_bh", UNLOCK, "spin_lock", 0, ret_any},
134 {"_spin_lock_bh", LOCK, "spin_lock", 0, ret_any},
135 {"_spin_unlock_bh", UNLOCK, "spin_lock", 0, ret_any},
136 {"__spin_lock_bh", LOCK, "spin_lock", 0, ret_any},
137 {"__spin_unlock_bh", UNLOCK, "spin_lock", 0, ret_any},
138
139 {"spin_trylock", LOCK, "spin_lock", 0, ret_non_zero},
140 {"_spin_trylock", LOCK, "spin_lock", 0, ret_non_zero},
141 {"__spin_trylock", LOCK, "spin_lock", 0, ret_non_zero},
142 {"raw_spin_trylock", LOCK, "spin_lock", 0, ret_non_zero},
143 {"_raw_spin_trylock", LOCK, "spin_lock", 0, ret_non_zero},
144 {"spin_trylock_irq", LOCK, "spin_lock", 0, ret_non_zero},
145 {"spin_trylock_irqsave", LOCK, "spin_lock", 0, ret_non_zero},
146 {"spin_trylock_bh", LOCK, "spin_lock", 0, ret_non_zero},
147 {"_spin_trylock_bh", LOCK, "spin_lock", 0, ret_non_zero},
148 {"__spin_trylock_bh", LOCK, "spin_lock", 0, ret_non_zero},
149 {"__raw_spin_trylock", LOCK, "spin_lock", 0, ret_non_zero},
150 {"_atomic_dec_and_lock", LOCK, "spin_lock", 1, ret_non_zero},
151
152 {"read_lock", LOCK, "read_lock", 0, ret_any},
153 {"read_unlock", UNLOCK, "read_lock", 0, ret_any},
154 {"_read_lock", LOCK, "read_lock", 0, ret_any},
155 {"_read_unlock", UNLOCK, "read_lock", 0, ret_any},
156 {"__read_lock", LOCK, "read_lock", 0, ret_any},
157 {"__read_unlock", UNLOCK, "read_lock", 0, ret_any},
158 {"read_lock_irq", LOCK, "read_lock", 0, ret_any},
159 {"read_unlock_irq" , UNLOCK, "read_lock", 0, ret_any},
160 {"_read_lock_irq", LOCK, "read_lock", 0, ret_any},
161 {"_read_unlock_irq", UNLOCK, "read_lock", 0, ret_any},
162 {"__read_lock_irq", LOCK, "read_lock", 0, ret_any},
163 {"__read_unlock_irq", UNLOCK, "read_lock", 0, ret_any},
164 {"read_lock_irqsave", LOCK, "read_lock", 0, ret_any},
165 {"read_unlock_irqrestore", UNLOCK, "read_lock", 0, ret_any},
166 {"_read_lock_irqsave", LOCK, "read_lock", 0, ret_any},
167 {"_read_unlock_irqrestore", UNLOCK, "read_lock", 0, ret_any},
168 {"__read_lock_irqsave", LOCK, "read_lock", 0, ret_any},
169 {"__read_unlock_irqrestore", UNLOCK, "read_lock", 0, ret_any},
170 {"read_lock_bh", LOCK, "read_lock", 0, ret_any},
171 {"read_unlock_bh", UNLOCK, "read_lock", 0, ret_any},
172 {"_read_lock_bh", LOCK, "read_lock", 0, ret_any},
173 {"_read_unlock_bh", UNLOCK, "read_lock", 0, ret_any},
174 {"__read_lock_bh", LOCK, "read_lock", 0, ret_any},
175 {"__read_unlock_bh", UNLOCK, "read_lock", 0, ret_any},
176
177 {"generic__raw_read_trylock", LOCK, "read_lock", 0, ret_non_zero},
178 {"read_trylock", LOCK, "read_lock", 0, ret_non_zero},
179 {"_read_trylock", LOCK, "read_lock", 0, ret_non_zero},
180 {"raw_read_trylock", LOCK, "read_lock", 0, ret_non_zero},
181 {"_raw_read_trylock", LOCK, "read_lock", 0, ret_non_zero},
182 {"__raw_read_trylock", LOCK, "read_lock", 0, ret_non_zero},
183 {"__read_trylock", LOCK, "read_lock", 0, ret_non_zero},
184
185 {"write_lock", LOCK, "write_lock", 0, ret_any},
186 {"write_unlock", UNLOCK, "write_lock", 0, ret_any},
187 {"_write_lock", LOCK, "write_lock", 0, ret_any},
188 {"_write_unlock", UNLOCK, "write_lock", 0, ret_any},
189 {"__write_lock", LOCK, "write_lock", 0, ret_any},
190 {"__write_unlock", UNLOCK, "write_lock", 0, ret_any},
191 {"write_lock_irq", LOCK, "write_lock", 0, ret_any},
192 {"write_unlock_irq", UNLOCK, "write_lock", 0, ret_any},
193 {"_write_lock_irq", LOCK, "write_lock", 0, ret_any},
194 {"_write_unlock_irq", UNLOCK, "write_lock", 0, ret_any},
195 {"__write_lock_irq", LOCK, "write_lock", 0, ret_any},
196 {"__write_unlock_irq", UNLOCK, "write_lock", 0, ret_any},
197 {"write_lock_irqsave", LOCK, "write_lock", 0, ret_any},
198 {"write_unlock_irqrestore", UNLOCK, "write_lock", 0, ret_any},
199 {"_write_lock_irqsave", LOCK, "write_lock", 0, ret_any},
200 {"_write_unlock_irqrestore", UNLOCK, "write_lock", 0, ret_any},
201 {"__write_lock_irqsave", LOCK, "write_lock", 0, ret_any},
202 {"__write_unlock_irqrestore", UNLOCK, "write_lock", 0, ret_any},
203 {"write_lock_bh", LOCK, "write_lock", 0, ret_any},
204 {"write_unlock_bh", UNLOCK, "write_lock", 0, ret_any},
205 {"_write_lock_bh", LOCK, "write_lock", 0, ret_any},
206 {"_write_unlock_bh", UNLOCK, "write_lock", 0, ret_any},
207 {"__write_lock_bh", LOCK, "write_lock", 0, ret_any},
208 {"__write_unlock_bh", UNLOCK, "write_lock", 0, ret_any},
209
210 {"write_trylock", LOCK, "write_lock", 0, ret_non_zero},
211 {"_write_trylock", LOCK, "write_lock", 0, ret_non_zero},
212 {"raw_write_trylock", LOCK, "write_lock", 0, ret_non_zero},
213 {"_raw_write_trylock", LOCK, "write_lock", 0, ret_non_zero},
214 {"__write_trylock", LOCK, "write_lock", 0, ret_non_zero},
215 {"__raw_write_trylock", LOCK, "write_lock", 0, ret_non_zero},
216
217 {"down", LOCK, "sem", 0, ret_any},
218 {"up", UNLOCK, "sem", 0, ret_any},
219 {"down_trylock", LOCK, "sem", 0, ret_zero},
220 {"down_interruptible", LOCK, "sem", 0, ret_zero},
221
222 {"mutex_lock", LOCK, "mutex", 0, ret_any},
223 {"mutex_unlock", UNLOCK, "mutex", 0, ret_any},
224 {"mutex_lock_nested", LOCK, "mutex", 0, ret_any},
225
226 {"mutex_lock_interruptible", LOCK, "mutex", 0, ret_zero},
227 {"mutex_lock_interruptible_nested", LOCK, "mutex", 0, ret_zero},
228 {"mutex_lock_killable", LOCK, "mutex", 0, ret_zero},
229 {"mutex_lock_killable_nested", LOCK, "mutex", 0, ret_zero},
230
231 {"mutex_trylock", LOCK, "mutex", 0, ret_non_zero},
232
233 {"raw_local_irq_disable", LOCK, "irq", NO_ARG, ret_any},
234 {"raw_local_irq_enable", UNLOCK, "irq", NO_ARG, ret_any},
235 {"spin_lock_irq", LOCK, "irq", NO_ARG, ret_any},
236 {"spin_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
237 {"_spin_lock_irq", LOCK, "irq", NO_ARG, ret_any},
238 {"_spin_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
239 {"__spin_lock_irq", LOCK, "irq", NO_ARG, ret_any},
240 {"__spin_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
241 {"_raw_spin_lock_irq", LOCK, "irq", NO_ARG, ret_any},
242 {"_raw_spin_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
243 {"__raw_spin_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
244 {"spin_trylock_irq", LOCK, "irq", NO_ARG, ret_non_zero},
245 {"read_lock_irq", LOCK, "irq", NO_ARG, ret_any},
246 {"read_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
247 {"_read_lock_irq", LOCK, "irq", NO_ARG, ret_any},
248 {"_read_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
249 {"__read_lock_irq", LOCK, "irq", NO_ARG, ret_any},
250 {"__read_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
251 {"write_lock_irq", LOCK, "irq", NO_ARG, ret_any},
252 {"write_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
253 {"_write_lock_irq", LOCK, "irq", NO_ARG, ret_any},
254 {"_write_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
255 {"__write_lock_irq", LOCK, "irq", NO_ARG, ret_any},
256 {"__write_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
257
258 {"arch_local_irq_save", LOCK, "irqsave", RETURN_VAL, ret_any},
259 {"arch_local_irq_restore", UNLOCK, "irqsave", 0, ret_any},
260 {"__raw_local_irq_save", LOCK, "irqsave", RETURN_VAL, ret_any},
261 {"raw_local_irq_restore", UNLOCK, "irqsave", 0, ret_any},
262 {"spin_lock_irqsave_nested", LOCK, "irqsave", RETURN_VAL, ret_any},
263 {"spin_lock_irqsave", LOCK, "irqsave", RETURN_VAL, ret_any},
264 {"spin_lock_irqsave", LOCK, "irqsave", 1, ret_any},
265 {"spin_unlock_irqrestore", UNLOCK, "irqsave", 1, ret_any},
266 {"_spin_lock_irqsave_nested", LOCK, "irqsave", RETURN_VAL, ret_any},
267 {"_spin_lock_irqsave", LOCK, "irqsave", RETURN_VAL, ret_any},
268 {"_spin_lock_irqsave", LOCK, "irqsave", 1, ret_any},
269 {"_spin_unlock_irqrestore", UNLOCK, "irqsave", 1, ret_any},
270 {"__spin_lock_irqsave_nested", LOCK, "irqsave", 1, ret_any},
271 {"__spin_lock_irqsave", LOCK, "irqsave", 1, ret_any},
272 {"__spin_unlock_irqrestore", UNLOCK, "irqsave", 1, ret_any},
273 {"_raw_spin_lock_irqsave", LOCK, "irqsave", RETURN_VAL, ret_any},
274 {"_raw_spin_lock_irqsave", LOCK, "irqsave", 1, ret_any},
275 {"_raw_spin_unlock_irqrestore",UNLOCK, "irqsave", 1, ret_any},
276 {"__raw_spin_lock_irqsave", LOCK, "irqsave", RETURN_VAL, ret_any},
277 {"__raw_spin_unlock_irqrestore",UNLOCK, "irqsave", 1, ret_any},
278 {"_raw_spin_lock_irqsave_nested", LOCK, "irqsave", RETURN_VAL, ret_any},
279 {"spin_trylock_irqsave", LOCK, "irqsave", 1, ret_non_zero},
280 {"read_lock_irqsave", LOCK, "irqsave", RETURN_VAL, ret_any},
281 {"read_lock_irqsave", LOCK, "irqsave", 1, ret_any},
282 {"read_unlock_irqrestore", UNLOCK, "irqsave", 1, ret_any},
283 {"_read_lock_irqsave", LOCK, "irqsave", RETURN_VAL, ret_any},
284 {"_read_lock_irqsave", LOCK, "irqsave", 1, ret_any},
285 {"_read_unlock_irqrestore", UNLOCK, "irqsave", 1, ret_any},
286 {"__read_lock_irqsave", LOCK, "irqsave", RETURN_VAL, ret_any},
287 {"__read_unlock_irqrestore", UNLOCK, "irqsave", 1, ret_any},
288 {"write_lock_irqsave", LOCK, "irqsave", RETURN_VAL, ret_any},
289 {"write_lock_irqsave", LOCK, "irqsave", 1, ret_any},
290 {"write_unlock_irqrestore", UNLOCK, "irqsave", 1, ret_any},
291 {"_write_lock_irqsave", LOCK, "irqsave", RETURN_VAL, ret_any},
292 {"_write_lock_irqsave", LOCK, "irqsave", 1, ret_any},
293 {"_write_unlock_irqrestore", UNLOCK, "irqsave", 1, ret_any},
294 {"__write_lock_irqsave", LOCK, "irqsave", RETURN_VAL, ret_any},
295 {"__write_unlock_irqrestore", UNLOCK, "irqsave", 1, ret_any},
296
297 {"spin_lock_bh", LOCK, "bottom_half", NO_ARG, ret_any},
298 {"spin_unlock_bh", UNLOCK, "bottom_half", NO_ARG, ret_any},
299 {"_spin_lock_bh", LOCK, "bottom_half", NO_ARG, ret_any},
300 {"_spin_unlock_bh", UNLOCK, "bottom_half", NO_ARG, ret_any},
301 {"__spin_lock_bh", LOCK, "bottom_half", NO_ARG, ret_any},
302 {"__spin_unlock_bh", UNLOCK, "bottom_half", NO_ARG, ret_any},
303 {"read_lock_bh", LOCK, "bottom_half", NO_ARG, ret_any},
304 {"read_unlock_bh", UNLOCK, "bottom_half", NO_ARG, ret_any},
305 {"_read_lock_bh", LOCK, "bottom_half", NO_ARG, ret_any},
306 {"_read_unlock_bh", UNLOCK, "bottom_half", NO_ARG, ret_any},
307 {"__read_lock_bh", LOCK, "bottom_half", NO_ARG, ret_any},
308 {"__read_unlock_bh", UNLOCK, "bottom_half", NO_ARG, ret_any},
309 {"write_lock_bh", LOCK, "bottom_half", NO_ARG, ret_any},
310 {"write_unlock_bh", UNLOCK, "bottom_half", NO_ARG, ret_any},
311 {"_write_lock_bh", LOCK, "bottom_half", NO_ARG, ret_any},
312 {"_write_unlock_bh", UNLOCK, "bottom_half", NO_ARG, ret_any},
313 {"__write_lock_bh", LOCK, "bottom_half", NO_ARG, ret_any},
314 {"__write_unlock_bh", UNLOCK, "bottom_half", NO_ARG, ret_any},
315 {"spin_trylock_bh", LOCK, "bottom_half", NO_ARG, ret_non_zero},
316 {"_spin_trylock_bh", LOCK, "bottom_half", NO_ARG, ret_non_zero},
317 {"__spin_trylock_bh", LOCK, "bottom_half", NO_ARG, ret_non_zero},
318 };
319
320 static struct lock_info *lock_table;
321
322 static struct tracker_list *starts_locked;
323 static struct tracker_list *starts_unlocked;
324
325 struct locks_on_return {
326 int line;
327 struct tracker_list *locked;
328 struct tracker_list *unlocked;
329 };
330 DECLARE_PTR_LIST(return_list, struct locks_on_return);
331 static struct return_list *all_returns;
332
333 static char *make_full_name(const char *lock, const char *var)
334 {
335 static char tmp_buf[512];
336
337 snprintf(tmp_buf, 512, "%s:%s", lock, var);
338 tmp_buf[511] = '\0';
339 return alloc_string(tmp_buf);
340 }
341
342 static struct expression *remove_spinlock_check(struct expression *expr)
343 {
344 if (expr->type != EXPR_CALL)
345 return expr;
346 if (expr->fn->type != EXPR_SYMBOL)
347 return expr;
348 if (strcmp(expr->fn->symbol_name->name, "spinlock_check"))
349 return expr;
350 expr = get_argument_from_call_expr(expr->args, 0);
351 return expr;
352 }
353
354 static char *get_full_name(struct expression *expr, int index)
355 {
356 struct expression *arg;
357 char *name = NULL;
358 char *full_name = NULL;
359 struct lock_info *lock = &lock_table[index];
360
361 if (lock->arg == RETURN_VAL) {
362 name = get_variable_from_expr(expr->left, NULL);
363 full_name = make_full_name(lock->name, name);
364 } else if (lock->arg == NO_ARG) {
365 full_name = make_full_name(lock->name, "");
366 } else {
367 arg = get_argument_from_call_expr(expr->args, lock->arg);
368 if (!arg)
369 goto free;
370 arg = remove_spinlock_check(arg);
371 name = get_variable_from_expr(arg, NULL);
372 if (!name)
373 goto free;
374 full_name = make_full_name(lock->name, name);
375 }
376 free:
377 free_string(name);
378 return full_name;
379 }
380
381 static struct smatch_state *get_start_state(struct sm_state *sm)
382 {
383 int is_locked = 0;
384 int is_unlocked = 0;
385
386 if (in_tracker_list(starts_locked, my_id, sm->name, sm->sym))
387 is_locked = 1;
388 if (in_tracker_list(starts_unlocked, my_id, sm->name, sm->sym))
389 is_unlocked = 1;
390 if (is_locked && is_unlocked)
391 return &undefined;
392 if (is_locked)
393 return &locked;
394 if (is_unlocked)
395 return &unlocked;
396 return &undefined;
397 }
398
399 static struct smatch_state *unmatched_state(struct sm_state *sm)
400 {
401 return &start_state;
402 }
403
404 static void do_lock(const char *name)
405 {
406 struct sm_state *sm;
407
408 sm = get_sm_state(my_id, name, NULL);
409 if (!sm)
410 add_tracker(&starts_unlocked, my_id, name, NULL);
411 if (sm && slist_has_state(sm->possible, &locked))
412 sm_msg("error: double lock '%s'", name);
413 set_state(my_id, name, NULL, &locked);
414 }
415
416 static void do_lock_failed(const char *name)
417 {
418 struct sm_state *sm;
419
420 sm = get_sm_state(my_id, name, NULL);
421 if (!sm)
422 add_tracker(&starts_unlocked, my_id, name, NULL);
423 set_state(my_id, name, NULL, &unlocked);
424 }
425
426 static void do_unlock(const char *name)
427 {
428 struct sm_state *sm;
429
430 sm = get_sm_state(my_id, name, NULL);
431 if (!sm)
432 add_tracker(&starts_locked, my_id, name, NULL);
433 if (sm && slist_has_state(sm->possible, &unlocked))
434 sm_msg("error: double unlock '%s'", name);
435 set_state(my_id, name, NULL, &unlocked);
436
437 }
438
439 static void match_lock_held(const char *fn, struct expression *call_expr,
440 struct expression *assign_expr, void *_index)
441 {
442 int index = (int)_index;
443 char *lock_name;
444 struct lock_info *lock = &lock_table[index];
445
446 if (lock->arg == NO_ARG) {
447 lock_name = get_full_name(NULL, index);
448 } else if (lock->arg == RETURN_VAL) {
449 if (!assign_expr)
450 return;
451 lock_name = get_full_name(assign_expr, index);
452 } else {
453 lock_name = get_full_name(call_expr, index);
454 }
455 if (!lock_name)
456 return;
457 do_lock(lock_name);
458 free_string(lock_name);
459 }
460
461 static void match_lock_failed(const char *fn, struct expression *call_expr,
462 struct expression *assign_expr, void *_index)
463 {
464 int index = (int)_index;
465 char *lock_name;
466 struct lock_info *lock = &lock_table[index];
467
468 if (lock->arg == NO_ARG) {
469 lock_name = get_full_name(NULL, index);
470 } else if (lock->arg == RETURN_VAL) {
471 if (!assign_expr)
472 return;
473 lock_name = get_full_name(assign_expr, index);
474 } else {
475 lock_name = get_full_name(call_expr, index);
476 }
477 if (!lock_name)
478 return;
479 do_lock_failed(lock_name);
480 free_string(lock_name);
481 }
482
483 static void match_returns_locked(const char *fn, struct expression *expr,
484 void *_index)
485 {
486 char *full_name = NULL;
487 int index = (int)_index;
488 struct lock_info *lock = &lock_table[index];
489
490 if (lock->arg != RETURN_VAL)
491 return;
492 full_name = get_full_name(expr, index);
493 do_lock(full_name);
494 }
495
496 static void match_lock_unlock(const char *fn, struct expression *expr, void *_index)
497 {
498 char *full_name = NULL;
499 int index = (int)_index;
500 struct lock_info *lock = &lock_table[index];
501
502 full_name = get_full_name(expr, index);
503 if (!full_name)
504 return;
505 if (lock->action == LOCK)
506 do_lock(full_name);
507 else
508 do_unlock(full_name);
509 free_string(full_name);
510 }
511
512 static struct locks_on_return *alloc_return(int line)
513 {
514 struct locks_on_return *ret;
515
516 ret = malloc(sizeof(*ret));
517 ret->line = line;
518 ret->locked = NULL;
519 ret->unlocked = NULL;
520 return ret;
521 }
522
523 static void check_possible(struct sm_state *sm)
524 {
525 struct sm_state *tmp;
526 int islocked = 0;
527 int isunlocked = 0;
528 int undef = 0;
529
530 if (!option_spammy)
531 return;
532
533 FOR_EACH_PTR(sm->possible, tmp) {
534 if (tmp->state == &locked)
535 islocked = 1;
536 if (tmp->state == &unlocked)
537 isunlocked = 1;
538 if (tmp->state == &start_state) {
539 struct smatch_state *s;
540
541 s = get_start_state(tmp);
542 if (s == &locked)
543 islocked = 1;
544 else if (s == &unlocked)
545 isunlocked = 1;
546 else
547 undef = 1;
548 }
549 if (tmp->state == &undefined)
550 undef = 1; // i don't think this is possible any more.
551 } END_FOR_EACH_PTR(tmp);
552 if ((islocked && isunlocked) || undef)
553 sm_msg("warn: '%s' is sometimes locked here and sometimes unlocked.", sm->name);
554 }
555
556 static void match_return(struct expression *ret_value)
557 {
558 struct locks_on_return *ret;
559 struct state_list *slist;
560 struct sm_state *tmp;
561
562 if (!final_pass)
563 return;
564
565 ret = alloc_return(get_lineno());
566
567 slist = get_all_states(my_id);
568 FOR_EACH_PTR(slist, tmp) {
569 if (tmp->state == &locked) {
570 add_tracker(&ret->locked, tmp->owner, tmp->name,
571 tmp->sym);
572 } else if (tmp->state == &unlocked) {
573 add_tracker(&ret->unlocked, tmp->owner, tmp->name,
574 tmp->sym);
575 } else if (tmp->state == &start_state) {
576 struct smatch_state *s;
577
578 s = get_start_state(tmp);
579 if (s == &locked)
580 add_tracker(&ret->locked, tmp->owner, tmp->name,
581 tmp->sym);
582 if (s == &unlocked)
583 add_tracker(&ret->unlocked, tmp->owner,tmp->name,
584 tmp->sym);
585 }else {
586 check_possible(tmp);
587 }
588 } END_FOR_EACH_PTR(tmp);
589 free_slist(&slist);
590 add_ptr_list(&all_returns, ret);
591 }
592
593 static void print_inconsistent_returns(struct tracker *lock,
594 struct smatch_state *start)
595 {
596 struct locks_on_return *tmp;
597 int i;
598
599 sm_printf("%s +%d %s(%d) ", get_filename(), get_lineno(), get_function(), get_func_pos());
600 sm_printf("warn: inconsistent returns %s:", lock->name);
601 sm_printf(" locked (");
602 i = 0;
603 FOR_EACH_PTR(all_returns, tmp) {
604 if (in_tracker_list(tmp->unlocked, lock->owner, lock->name, lock->sym))
605 continue;
606 if (in_tracker_list(tmp->locked, lock->owner, lock->name, lock->sym)) {
607 if (i++)
608 sm_printf(",");
609 sm_printf("%d", tmp->line);
610 continue;
611 }
612 if (start == &locked) {
613 if (i++)
614 sm_printf(",");
615 sm_printf("%d", tmp->line);
616 }
617 } END_FOR_EACH_PTR(tmp);
618
619 sm_printf(") unlocked (");
620 i = 0;
621 FOR_EACH_PTR(all_returns, tmp) {
622 if (in_tracker_list(tmp->unlocked, lock->owner, lock->name, lock->sym)) {
623 if (i++)
624 sm_printf(",");
625 sm_printf("%d", tmp->line);
626 continue;
627 }
628 if (in_tracker_list(tmp->locked, lock->owner, lock->name, lock->sym)) {
629 continue;
630 }
631 if (start == &unlocked) {
632 if (i++)
633 sm_printf(",");
634 sm_printf("%d", tmp->line);
635 }
636 } END_FOR_EACH_PTR(tmp);
637 sm_printf(")\n");
638 }
639
640 static void check_returns_consistently(struct tracker *lock,
641 struct smatch_state *start)
642 {
643 int returns_locked = 0;
644 int returns_unlocked = 0;
645 struct locks_on_return *tmp;
646
647 FOR_EACH_PTR(all_returns, tmp) {
648 if (in_tracker_list(tmp->unlocked, lock->owner, lock->name,
649 lock->sym))
650 returns_unlocked = tmp->line;
651 else if (in_tracker_list(tmp->locked, lock->owner, lock->name,
652 lock->sym))
653 returns_locked = tmp->line;
654 else if (start == &locked)
655 returns_locked = tmp->line;
656 else if (start == &unlocked)
657 returns_unlocked = tmp->line;
658 } END_FOR_EACH_PTR(tmp);
659
660 if (returns_locked && returns_unlocked)
661 print_inconsistent_returns(lock, start);
662 }
663
664 static void check_consistency(struct symbol *sym)
665 {
666 struct tracker *tmp;
667
668 if (is_reachable())
669 match_return(NULL);
670
671 FOR_EACH_PTR(starts_locked, tmp) {
672 if (in_tracker_list(starts_unlocked, tmp->owner, tmp->name,
673 tmp->sym))
674 sm_msg("error: locking inconsistency. We assume "
675 "'%s' is both locked and unlocked at the "
676 "start.",
677 tmp->name);
678 } END_FOR_EACH_PTR(tmp);
679
680 FOR_EACH_PTR(starts_locked, tmp) {
681 check_returns_consistently(tmp, &locked);
682 } END_FOR_EACH_PTR(tmp);
683
684 FOR_EACH_PTR(starts_unlocked, tmp) {
685 check_returns_consistently(tmp, &unlocked);
686 } END_FOR_EACH_PTR(tmp);
687
688 }
689
690 static void clear_lists(void)
691 {
692 struct locks_on_return *tmp;
693
694 free_trackers_and_list(&starts_locked);
695 free_trackers_and_list(&starts_unlocked);
696
697 FOR_EACH_PTR(all_returns, tmp) {
698 free_trackers_and_list(&tmp->locked);
699 free_trackers_and_list(&tmp->unlocked);
700 free(tmp);
701 } END_FOR_EACH_PTR(tmp);
702 __free_ptr_list((struct ptr_list **)&all_returns);
703 }
704
705 static void match_func_end(struct symbol *sym)
706 {
707 check_consistency(sym);
708 clear_lists();
709 }
710
711 static void register_lock(int index)
712 {
713 struct lock_info *lock = &lock_table[index];
714 void *idx = (void *)index;
715
716 if (lock->return_type == ret_non_zero) {
717 return_implies_state(lock->function, 1, POINTER_MAX, &match_lock_held, idx);
718 return_implies_state(lock->function, 0, 0, &match_lock_failed, idx);
719 } else if (lock->return_type == ret_any && lock->arg == RETURN_VAL) {
720 add_function_assign_hook(lock->function, &match_returns_locked, idx);
721 } else if (lock->return_type == ret_any) {
722 add_function_hook(lock->function, &match_lock_unlock, idx);
723 } else if (lock->return_type == ret_zero) {
724 return_implies_state(lock->function, 0, 0, &match_lock_held, idx);
725 return_implies_state(lock->function, whole_range.min, -1, &match_lock_failed, idx);
726 }
727 }
728
729 static void load_table(struct lock_info *_lock_table, int size)
730 {
731 int i;
732
733 lock_table = _lock_table;
734
735 for (i = 0; i < size; i++) {
736 if (lock_table[i].action == LOCK)
737 register_lock(i);
738 else
739 add_function_hook(lock_table[i].function, &match_lock_unlock, (void *)i);
740 }
741 }
742
743 /* print_held_locks() is used in check_call_tree.c */
744 void print_held_locks()
745 {
746 struct state_list *slist;
747 struct sm_state *sm;
748 int i = 0;
749
750 slist = get_all_states(my_id);
751 FOR_EACH_PTR(slist, sm) {
752 if (sm->state != &locked)
753 continue;
754 if (i++)
755 sm_printf(" ");
756 sm_printf("'%s'", sm->name);
757 } END_FOR_EACH_PTR(sm);
758 free_slist(&slist);
759 }
760
761 void check_locking(int id)
762 {
763 my_id = id;
764
765 if (option_project == PROJ_WINE)
766 load_table(wine_lock_table, ARRAY_SIZE(wine_lock_table));
767 else if (option_project == PROJ_KERNEL)
768 load_table(kernel_lock_table, ARRAY_SIZE(kernel_lock_table));
769 else
770 return;
771
772 add_unmatched_state_hook(my_id, &unmatched_state);
773 add_hook(&match_return, RETURN_HOOK);
774 add_hook(&match_func_end, END_FUNC_HOOK);
775 }
Static analysis for C