2 * sparse/check_locking.c
4 * Copyright (C) 2009 Dan Carpenter.
6 * Licensed under the Open Software License version 1.1
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.
16 * The list of wine locking functions came from an earlier script written
17 * by Michael Stefaniuc.
23 #include "smatch_extra.h"
24 #include "smatch_slist.h"
28 static int func_has_transition
;
55 enum return_type return_type
;
58 static struct lock_info wine_lock_table
[] = {
59 {"create_window_handle", LOCK
, "create_window_handle", RETURN_VAL
, ret_non_zero
},
60 {"WIN_GetPtr", LOCK
, "create_window_handle", RETURN_VAL
, ret_non_zero
},
61 {"WIN_ReleasePtr", UNLOCK
, "create_window_handle", 0, ret_any
},
62 {"EnterCriticalSection", LOCK
, "CriticalSection", 0, ret_any
},
63 {"LeaveCriticalSection", UNLOCK
, "CriticalSection", 0, ret_any
},
64 {"RtlEnterCriticalSection", LOCK
, "RtlCriticalSection", 0, ret_any
},
65 {"RtlLeaveCriticalSection", UNLOCK
, "RtlCriticalSection", 0, ret_any
},
66 {"GDI_GetObjPtr", LOCK
, "GDI_Get", 0, ret_non_zero
},
67 {"GDI_ReleaseObj", UNLOCK
, "GDI_Get", 0, ret_any
},
68 {"LdrLockLoaderLock", LOCK
, "LdrLockLoaderLock", 2, ret_any
},
69 {"LdrUnlockLoaderLock", UNLOCK
, "LdrLockLoaderLock", 1, ret_any
},
70 {"_lock", LOCK
, "_lock", 0, ret_any
},
71 {"_unlock", UNLOCK
, "_lock", 0, ret_any
},
72 {"msiobj_lock", LOCK
, "msiobj_lock", 0, ret_any
},
73 {"msiobj_unlock", UNLOCK
, "msiobj_lock", 0, ret_any
},
74 {"RtlAcquirePebLock", LOCK
, "PebLock", NO_ARG
, ret_any
},
75 {"RtlReleasePebLock", UNLOCK
, "PebLock", NO_ARG
, ret_any
},
76 {"server_enter_uninterrupted_section", LOCK
, "server_uninterrupted_section", 0, ret_any
},
77 {"server_leave_uninterrupted_section", UNLOCK
, "server_uninterrupted_section", 0, ret_any
},
78 {"RtlLockHeap", LOCK
, "RtlLockHeap", 0, ret_any
},
79 {"RtlUnlockHeap", UNLOCK
, "RtlLockHeap", 0, ret_any
},
80 {"_EnterSysLevel", LOCK
, "SysLevel", 0, ret_any
},
81 {"_LeaveSysLevel", UNLOCK
, "SysLevel", 0, ret_any
},
82 {"USER_Lock", LOCK
, "USER_Lock", NO_ARG
, ret_any
},
83 {"USER_Unlock", UNLOCK
, "USER_Lock", NO_ARG
, ret_any
},
84 {"wine_tsx11_lock", LOCK
, "wine_tsx11_lock", NO_ARG
, ret_any
},
85 {"wine_tsx11_unlock", UNLOCK
, "wine_tsx11_lock", NO_ARG
, ret_any
},
86 {"wine_tsx11_lock_ptr", LOCK
, "wine_tsx11_lock_ptr", NO_ARG
, ret_any
},
87 {"wine_tsx11_unlock_ptr", UNLOCK
, "wine_tsx11_lock_ptr", NO_ARG
, ret_any
},
88 {"wined3d_mutex_lock", LOCK
, "wined3d_mutex_lock", NO_ARG
, ret_any
},
89 {"wined3d_mutex_unlock", UNLOCK
, "wined3d_mutex_lock", NO_ARG
, ret_any
},
90 {"X11DRV_DIB_Lock", LOCK
, "X11DRV_DIB_Lock", 0, ret_any
},
91 {"X11DRV_DIB_Unlock", UNLOCK
, "X11DRV_DIB_Lock", 0, ret_any
},
94 static struct lock_info kernel_lock_table
[] = {
95 {"lock_kernel", LOCK
, "BKL", NO_ARG
, ret_any
},
96 {"unlock_kernel", UNLOCK
, "BKL", NO_ARG
, ret_any
},
98 {"spin_lock", LOCK
, "spin_lock", 0, ret_any
},
99 {"spin_unlock", UNLOCK
, "spin_lock", 0, ret_any
},
100 {"spin_lock_nested", LOCK
, "spin_lock", 0, ret_any
},
101 {"_spin_lock", LOCK
, "spin_lock", 0, ret_any
},
102 {"_spin_unlock", UNLOCK
, "spin_lock", 0, ret_any
},
103 {"_spin_lock_nested", LOCK
, "spin_lock", 0, ret_any
},
104 {"__spin_lock", LOCK
, "spin_lock", 0, ret_any
},
105 {"__spin_unlock", UNLOCK
, "spin_lock", 0, ret_any
},
106 {"__spin_lock_nested", LOCK
, "spin_lock", 0, ret_any
},
107 {"raw_spin_lock", LOCK
, "spin_lock", 0, ret_any
},
108 {"raw_spin_unlock", UNLOCK
, "spin_lock", 0, ret_any
},
109 {"_raw_spin_lock", LOCK
, "spin_lock", 0, ret_any
},
110 {"_raw_spin_lock_nested", LOCK
, "spin_lock", 0, ret_any
},
111 {"_raw_spin_unlock", UNLOCK
, "spin_lock", 0, ret_any
},
112 {"__raw_spin_lock", LOCK
, "spin_lock", 0, ret_any
},
113 {"__raw_spin_unlock", UNLOCK
, "spin_lock", 0, ret_any
},
115 {"spin_lock_irq", LOCK
, "spin_lock", 0, ret_any
},
116 {"spin_unlock_irq", UNLOCK
, "spin_lock", 0, ret_any
},
117 {"_spin_lock_irq", LOCK
, "spin_lock", 0, ret_any
},
118 {"_spin_unlock_irq", UNLOCK
, "spin_lock", 0, ret_any
},
119 {"__spin_lock_irq", LOCK
, "spin_lock", 0, ret_any
},
120 {"__spin_unlock_irq", UNLOCK
, "spin_lock", 0, ret_any
},
121 {"_raw_spin_lock_irq", LOCK
, "spin_lock", 0, ret_any
},
122 {"_raw_spin_unlock_irq", UNLOCK
, "spin_lock", 0, ret_any
},
123 {"__raw_spin_unlock_irq", UNLOCK
, "spin_lock", 0, ret_any
},
124 {"spin_lock_irqsave", LOCK
, "spin_lock", 0, ret_any
},
125 {"spin_unlock_irqrestore", UNLOCK
, "spin_lock", 0, ret_any
},
126 {"_spin_lock_irqsave", LOCK
, "spin_lock", 0, ret_any
},
127 {"_spin_unlock_irqrestore", UNLOCK
, "spin_lock", 0, ret_any
},
128 {"__spin_lock_irqsave", LOCK
, "spin_lock", 0, ret_any
},
129 {"__spin_unlock_irqrestore", UNLOCK
, "spin_lock", 0, ret_any
},
130 {"_raw_spin_lock_irqsave", LOCK
, "spin_lock", 0, ret_any
},
131 {"_raw_spin_unlock_irqrestore", UNLOCK
, "spin_lock", 0, ret_any
},
132 {"__raw_spin_lock_irqsave", LOCK
, "spin_lock", 0, ret_any
},
133 {"__raw_spin_unlock_irqrestore", UNLOCK
, "spin_lock", 0, ret_any
},
134 {"spin_lock_irqsave_nested", LOCK
, "spin_lock", 0, ret_any
},
135 {"_spin_lock_irqsave_nested", LOCK
, "spin_lock", 0, ret_any
},
136 {"__spin_lock_irqsave_nested", LOCK
, "spin_lock", 0, ret_any
},
137 {"_raw_spin_lock_irqsave_nested", LOCK
, "spin_lock", 0, ret_any
},
138 {"spin_lock_bh", LOCK
, "spin_lock", 0, ret_any
},
139 {"spin_unlock_bh", UNLOCK
, "spin_lock", 0, ret_any
},
140 {"_spin_lock_bh", LOCK
, "spin_lock", 0, ret_any
},
141 {"_spin_unlock_bh", UNLOCK
, "spin_lock", 0, ret_any
},
142 {"__spin_lock_bh", LOCK
, "spin_lock", 0, ret_any
},
143 {"__spin_unlock_bh", UNLOCK
, "spin_lock", 0, ret_any
},
145 {"spin_trylock", LOCK
, "spin_lock", 0, ret_non_zero
},
146 {"_spin_trylock", LOCK
, "spin_lock", 0, ret_non_zero
},
147 {"__spin_trylock", LOCK
, "spin_lock", 0, ret_non_zero
},
148 {"raw_spin_trylock", LOCK
, "spin_lock", 0, ret_non_zero
},
149 {"_raw_spin_trylock", LOCK
, "spin_lock", 0, ret_non_zero
},
150 {"spin_trylock_irq", LOCK
, "spin_lock", 0, ret_non_zero
},
151 {"spin_trylock_irqsave", LOCK
, "spin_lock", 0, ret_non_zero
},
152 {"spin_trylock_bh", LOCK
, "spin_lock", 0, ret_non_zero
},
153 {"_spin_trylock_bh", LOCK
, "spin_lock", 0, ret_non_zero
},
154 {"__spin_trylock_bh", LOCK
, "spin_lock", 0, ret_non_zero
},
155 {"__raw_spin_trylock", LOCK
, "spin_lock", 0, ret_non_zero
},
156 {"_atomic_dec_and_lock", LOCK
, "spin_lock", 1, ret_non_zero
},
158 {"read_lock", LOCK
, "read_lock", 0, ret_any
},
159 {"read_unlock", UNLOCK
, "read_lock", 0, ret_any
},
160 {"_read_lock", LOCK
, "read_lock", 0, ret_any
},
161 {"_read_unlock", UNLOCK
, "read_lock", 0, ret_any
},
162 {"__read_lock", LOCK
, "read_lock", 0, ret_any
},
163 {"__read_unlock", UNLOCK
, "read_lock", 0, ret_any
},
164 {"_raw_read_lock", LOCK
, "read_lock", 0, ret_any
},
165 {"_raw_read_unlock", UNLOCK
, "read_lock", 0, ret_any
},
166 {"read_lock_irq", LOCK
, "read_lock", 0, ret_any
},
167 {"read_unlock_irq" , UNLOCK
, "read_lock", 0, ret_any
},
168 {"_read_lock_irq", LOCK
, "read_lock", 0, ret_any
},
169 {"_read_unlock_irq", UNLOCK
, "read_lock", 0, ret_any
},
170 {"__read_lock_irq", LOCK
, "read_lock", 0, ret_any
},
171 {"__read_unlock_irq", UNLOCK
, "read_lock", 0, ret_any
},
172 {"read_lock_irqsave", LOCK
, "read_lock", 0, ret_any
},
173 {"read_unlock_irqrestore", UNLOCK
, "read_lock", 0, ret_any
},
174 {"_read_lock_irqsave", LOCK
, "read_lock", 0, ret_any
},
175 {"_read_unlock_irqrestore", UNLOCK
, "read_lock", 0, ret_any
},
176 {"__read_lock_irqsave", LOCK
, "read_lock", 0, ret_any
},
177 {"__read_unlock_irqrestore", UNLOCK
, "read_lock", 0, ret_any
},
178 {"read_lock_bh", LOCK
, "read_lock", 0, ret_any
},
179 {"read_unlock_bh", UNLOCK
, "read_lock", 0, ret_any
},
180 {"_read_lock_bh", LOCK
, "read_lock", 0, ret_any
},
181 {"_read_unlock_bh", UNLOCK
, "read_lock", 0, ret_any
},
182 {"__read_lock_bh", LOCK
, "read_lock", 0, ret_any
},
183 {"__read_unlock_bh", UNLOCK
, "read_lock", 0, ret_any
},
184 {"_raw_read_lock_bh", LOCK
, "read_lock", 0, ret_any
},
185 {"_raw_read_unlock_bh", UNLOCK
, "read_lock", 0, ret_any
},
187 {"generic__raw_read_trylock", LOCK
, "read_lock", 0, ret_non_zero
},
188 {"read_trylock", LOCK
, "read_lock", 0, ret_non_zero
},
189 {"_read_trylock", LOCK
, "read_lock", 0, ret_non_zero
},
190 {"raw_read_trylock", LOCK
, "read_lock", 0, ret_non_zero
},
191 {"_raw_read_trylock", LOCK
, "read_lock", 0, ret_non_zero
},
192 {"__raw_read_trylock", LOCK
, "read_lock", 0, ret_non_zero
},
193 {"__read_trylock", LOCK
, "read_lock", 0, ret_non_zero
},
195 {"write_lock", LOCK
, "write_lock", 0, ret_any
},
196 {"write_unlock", UNLOCK
, "write_lock", 0, ret_any
},
197 {"_write_lock", LOCK
, "write_lock", 0, ret_any
},
198 {"_write_unlock", UNLOCK
, "write_lock", 0, ret_any
},
199 {"__write_lock", LOCK
, "write_lock", 0, ret_any
},
200 {"__write_unlock", UNLOCK
, "write_lock", 0, ret_any
},
201 {"write_lock_irq", LOCK
, "write_lock", 0, ret_any
},
202 {"write_unlock_irq", UNLOCK
, "write_lock", 0, ret_any
},
203 {"_write_lock_irq", LOCK
, "write_lock", 0, ret_any
},
204 {"_write_unlock_irq", UNLOCK
, "write_lock", 0, ret_any
},
205 {"__write_lock_irq", LOCK
, "write_lock", 0, ret_any
},
206 {"__write_unlock_irq", UNLOCK
, "write_lock", 0, ret_any
},
207 {"write_lock_irqsave", LOCK
, "write_lock", 0, ret_any
},
208 {"write_unlock_irqrestore", UNLOCK
, "write_lock", 0, ret_any
},
209 {"_write_lock_irqsave", LOCK
, "write_lock", 0, ret_any
},
210 {"_write_unlock_irqrestore", UNLOCK
, "write_lock", 0, ret_any
},
211 {"__write_lock_irqsave", LOCK
, "write_lock", 0, ret_any
},
212 {"__write_unlock_irqrestore", UNLOCK
, "write_lock", 0, ret_any
},
213 {"write_lock_bh", LOCK
, "write_lock", 0, ret_any
},
214 {"write_unlock_bh", UNLOCK
, "write_lock", 0, ret_any
},
215 {"_write_lock_bh", LOCK
, "write_lock", 0, ret_any
},
216 {"_write_unlock_bh", UNLOCK
, "write_lock", 0, ret_any
},
217 {"__write_lock_bh", LOCK
, "write_lock", 0, ret_any
},
218 {"__write_unlock_bh", UNLOCK
, "write_lock", 0, ret_any
},
220 {"write_trylock", LOCK
, "write_lock", 0, ret_non_zero
},
221 {"_write_trylock", LOCK
, "write_lock", 0, ret_non_zero
},
222 {"raw_write_trylock", LOCK
, "write_lock", 0, ret_non_zero
},
223 {"_raw_write_trylock", LOCK
, "write_lock", 0, ret_non_zero
},
224 {"__write_trylock", LOCK
, "write_lock", 0, ret_non_zero
},
225 {"__raw_write_trylock", LOCK
, "write_lock", 0, ret_non_zero
},
227 {"down", LOCK
, "sem", 0, ret_any
},
228 {"up", UNLOCK
, "sem", 0, ret_any
},
229 {"down_trylock", LOCK
, "sem", 0, ret_zero
},
230 {"down_interruptible", LOCK
, "sem", 0, ret_zero
},
232 {"mutex_lock", LOCK
, "mutex", 0, ret_any
},
233 {"mutex_unlock", UNLOCK
, "mutex", 0, ret_any
},
234 {"mutex_lock_nested", LOCK
, "mutex", 0, ret_any
},
236 {"mutex_lock_interruptible", LOCK
, "mutex", 0, ret_zero
},
237 {"mutex_lock_interruptible_nested", LOCK
, "mutex", 0, ret_zero
},
238 {"mutex_lock_killable", LOCK
, "mutex", 0, ret_zero
},
239 {"mutex_lock_killable_nested", LOCK
, "mutex", 0, ret_zero
},
241 {"mutex_trylock", LOCK
, "mutex", 0, ret_non_zero
},
243 {"raw_local_irq_disable", LOCK
, "irq", NO_ARG
, ret_any
},
244 {"raw_local_irq_enable", UNLOCK
, "irq", NO_ARG
, ret_any
},
245 {"spin_lock_irq", LOCK
, "irq", NO_ARG
, ret_any
},
246 {"spin_unlock_irq", UNLOCK
, "irq", NO_ARG
, ret_any
},
247 {"_spin_lock_irq", LOCK
, "irq", NO_ARG
, ret_any
},
248 {"_spin_unlock_irq", UNLOCK
, "irq", NO_ARG
, ret_any
},
249 {"__spin_lock_irq", LOCK
, "irq", NO_ARG
, ret_any
},
250 {"__spin_unlock_irq", UNLOCK
, "irq", NO_ARG
, ret_any
},
251 {"_raw_spin_lock_irq", LOCK
, "irq", NO_ARG
, ret_any
},
252 {"_raw_spin_unlock_irq", UNLOCK
, "irq", NO_ARG
, ret_any
},
253 {"__raw_spin_unlock_irq", UNLOCK
, "irq", NO_ARG
, ret_any
},
254 {"spin_trylock_irq", LOCK
, "irq", NO_ARG
, ret_non_zero
},
255 {"read_lock_irq", LOCK
, "irq", NO_ARG
, ret_any
},
256 {"read_unlock_irq", UNLOCK
, "irq", NO_ARG
, ret_any
},
257 {"_read_lock_irq", LOCK
, "irq", NO_ARG
, ret_any
},
258 {"_read_unlock_irq", UNLOCK
, "irq", NO_ARG
, ret_any
},
259 {"__read_lock_irq", LOCK
, "irq", NO_ARG
, ret_any
},
260 {"__read_unlock_irq", UNLOCK
, "irq", NO_ARG
, ret_any
},
261 {"write_lock_irq", LOCK
, "irq", NO_ARG
, ret_any
},
262 {"write_unlock_irq", UNLOCK
, "irq", NO_ARG
, ret_any
},
263 {"_write_lock_irq", LOCK
, "irq", NO_ARG
, ret_any
},
264 {"_write_unlock_irq", UNLOCK
, "irq", NO_ARG
, ret_any
},
265 {"__write_lock_irq", LOCK
, "irq", NO_ARG
, ret_any
},
266 {"__write_unlock_irq", UNLOCK
, "irq", NO_ARG
, ret_any
},
268 {"arch_local_irq_save", LOCK
, "irqsave", RETURN_VAL
, ret_any
},
269 {"arch_local_irq_restore", UNLOCK
, "irqsave", 0, ret_any
},
270 {"__raw_local_irq_save", LOCK
, "irqsave", RETURN_VAL
, ret_any
},
271 {"raw_local_irq_restore", UNLOCK
, "irqsave", 0, ret_any
},
272 {"spin_lock_irqsave_nested", LOCK
, "irqsave", RETURN_VAL
, ret_any
},
273 {"spin_lock_irqsave", LOCK
, "irqsave", RETURN_VAL
, ret_any
},
274 {"spin_lock_irqsave", LOCK
, "irqsave", 1, ret_any
},
275 {"spin_unlock_irqrestore", UNLOCK
, "irqsave", 1, ret_any
},
276 {"_spin_lock_irqsave_nested", LOCK
, "irqsave", RETURN_VAL
, ret_any
},
277 {"_spin_lock_irqsave", LOCK
, "irqsave", RETURN_VAL
, ret_any
},
278 {"_spin_lock_irqsave", LOCK
, "irqsave", 1, ret_any
},
279 {"_spin_unlock_irqrestore", UNLOCK
, "irqsave", 1, ret_any
},
280 {"__spin_lock_irqsave_nested", LOCK
, "irqsave", 1, ret_any
},
281 {"__spin_lock_irqsave", LOCK
, "irqsave", 1, ret_any
},
282 {"__spin_unlock_irqrestore", UNLOCK
, "irqsave", 1, ret_any
},
283 {"_raw_spin_lock_irqsave", LOCK
, "irqsave", RETURN_VAL
, ret_any
},
284 {"_raw_spin_lock_irqsave", LOCK
, "irqsave", 1, ret_any
},
285 {"_raw_spin_unlock_irqrestore",UNLOCK
, "irqsave", 1, ret_any
},
286 {"__raw_spin_lock_irqsave", LOCK
, "irqsave", RETURN_VAL
, ret_any
},
287 {"__raw_spin_unlock_irqrestore",UNLOCK
, "irqsave", 1, ret_any
},
288 {"_raw_spin_lock_irqsave_nested", LOCK
, "irqsave", RETURN_VAL
, ret_any
},
289 {"spin_trylock_irqsave", LOCK
, "irqsave", 1, ret_non_zero
},
290 {"read_lock_irqsave", LOCK
, "irqsave", RETURN_VAL
, ret_any
},
291 {"read_lock_irqsave", LOCK
, "irqsave", 1, ret_any
},
292 {"read_unlock_irqrestore", UNLOCK
, "irqsave", 1, ret_any
},
293 {"_read_lock_irqsave", LOCK
, "irqsave", RETURN_VAL
, ret_any
},
294 {"_read_lock_irqsave", LOCK
, "irqsave", 1, ret_any
},
295 {"_read_unlock_irqrestore", UNLOCK
, "irqsave", 1, ret_any
},
296 {"__read_lock_irqsave", LOCK
, "irqsave", RETURN_VAL
, ret_any
},
297 {"__read_unlock_irqrestore", UNLOCK
, "irqsave", 1, ret_any
},
298 {"write_lock_irqsave", LOCK
, "irqsave", RETURN_VAL
, ret_any
},
299 {"write_lock_irqsave", LOCK
, "irqsave", 1, ret_any
},
300 {"write_unlock_irqrestore", UNLOCK
, "irqsave", 1, ret_any
},
301 {"_write_lock_irqsave", LOCK
, "irqsave", RETURN_VAL
, ret_any
},
302 {"_write_lock_irqsave", LOCK
, "irqsave", 1, ret_any
},
303 {"_write_unlock_irqrestore", UNLOCK
, "irqsave", 1, ret_any
},
304 {"__write_lock_irqsave", LOCK
, "irqsave", RETURN_VAL
, ret_any
},
305 {"__write_unlock_irqrestore", UNLOCK
, "irqsave", 1, ret_any
},
307 {"spin_lock_bh", LOCK
, "bottom_half", NO_ARG
, ret_any
},
308 {"spin_unlock_bh", UNLOCK
, "bottom_half", NO_ARG
, ret_any
},
309 {"_spin_lock_bh", LOCK
, "bottom_half", NO_ARG
, ret_any
},
310 {"_spin_unlock_bh", UNLOCK
, "bottom_half", NO_ARG
, ret_any
},
311 {"__spin_lock_bh", LOCK
, "bottom_half", NO_ARG
, ret_any
},
312 {"__spin_unlock_bh", UNLOCK
, "bottom_half", NO_ARG
, ret_any
},
313 {"read_lock_bh", LOCK
, "bottom_half", NO_ARG
, ret_any
},
314 {"read_unlock_bh", UNLOCK
, "bottom_half", NO_ARG
, ret_any
},
315 {"_read_lock_bh", LOCK
, "bottom_half", NO_ARG
, ret_any
},
316 {"_read_unlock_bh", UNLOCK
, "bottom_half", NO_ARG
, ret_any
},
317 {"__read_lock_bh", LOCK
, "bottom_half", NO_ARG
, ret_any
},
318 {"__read_unlock_bh", UNLOCK
, "bottom_half", NO_ARG
, ret_any
},
319 {"_raw_read_lock_bh", LOCK
, "bottom_half", NO_ARG
, ret_any
},
320 {"_raw_read_unlock_bh", UNLOCK
, "bottom_half", NO_ARG
, ret_any
},
321 {"write_lock_bh", LOCK
, "bottom_half", NO_ARG
, ret_any
},
322 {"write_unlock_bh", UNLOCK
, "bottom_half", NO_ARG
, ret_any
},
323 {"_write_lock_bh", LOCK
, "bottom_half", NO_ARG
, ret_any
},
324 {"_write_unlock_bh", UNLOCK
, "bottom_half", NO_ARG
, ret_any
},
325 {"__write_lock_bh", LOCK
, "bottom_half", NO_ARG
, ret_any
},
326 {"__write_unlock_bh", UNLOCK
, "bottom_half", NO_ARG
, ret_any
},
327 {"spin_trylock_bh", LOCK
, "bottom_half", NO_ARG
, ret_non_zero
},
328 {"_spin_trylock_bh", LOCK
, "bottom_half", NO_ARG
, ret_non_zero
},
329 {"__spin_trylock_bh", LOCK
, "bottom_half", NO_ARG
, ret_non_zero
},
332 static struct lock_info
*lock_table
;
334 static struct tracker_list
*starts_locked
;
335 static struct tracker_list
*starts_unlocked
;
337 struct locks_on_return
{
339 struct tracker_list
*locked
;
340 struct tracker_list
*unlocked
;
341 struct range_list
*return_values
;
343 DECLARE_PTR_LIST(return_list
, struct locks_on_return
);
344 static struct return_list
*all_returns
;
346 static char *make_full_name(const char *lock
, const char *var
)
348 static char tmp_buf
[512];
350 snprintf(tmp_buf
, sizeof(tmp_buf
), "%s:%s", lock
, var
);
351 remove_parens(tmp_buf
);
352 return alloc_string(tmp_buf
);
355 static struct expression
*remove_spinlock_check(struct expression
*expr
)
357 if (expr
->type
!= EXPR_CALL
)
359 if (expr
->fn
->type
!= EXPR_SYMBOL
)
361 if (strcmp(expr
->fn
->symbol_name
->name
, "spinlock_check"))
363 expr
= get_argument_from_call_expr(expr
->args
, 0);
367 static char *get_full_name(struct expression
*expr
, int index
)
369 struct expression
*arg
;
371 char *full_name
= NULL
;
372 struct lock_info
*lock
= &lock_table
[index
];
374 if (lock
->arg
== RETURN_VAL
) {
375 name
= expr_to_var(expr
->left
);
376 full_name
= make_full_name(lock
->name
, name
);
377 } else if (lock
->arg
== NO_ARG
) {
378 full_name
= make_full_name(lock
->name
, "");
380 arg
= get_argument_from_call_expr(expr
->args
, lock
->arg
);
383 arg
= remove_spinlock_check(arg
);
384 name
= expr_to_str(arg
);
387 full_name
= make_full_name(lock
->name
, name
);
394 static struct smatch_state
*get_start_state(struct sm_state
*sm
)
399 if (in_tracker_list(starts_locked
, my_id
, sm
->name
, sm
->sym
))
401 if (in_tracker_list(starts_unlocked
, my_id
, sm
->name
, sm
->sym
))
403 if (is_locked
&& is_unlocked
)
412 static struct smatch_state
*unmatched_state(struct sm_state
*sm
)
417 static void do_lock(const char *name
)
424 sm
= get_sm_state(my_id
, name
, NULL
);
426 add_tracker(&starts_unlocked
, my_id
, name
, NULL
);
427 if (sm
&& slist_has_state(sm
->possible
, &locked
) &&
428 strcmp(name
, "bottom_half:") != 0)
429 sm_msg("error: double lock '%s'", name
);
431 func_has_transition
= TRUE
;
432 set_state(my_id
, name
, NULL
, &locked
);
435 static void do_lock_failed(const char *name
)
442 sm
= get_sm_state(my_id
, name
, NULL
);
444 add_tracker(&starts_unlocked
, my_id
, name
, NULL
);
445 set_state(my_id
, name
, NULL
, &unlocked
);
448 static void do_unlock(const char *name
)
454 if (__path_is_null())
456 sm
= get_sm_state(my_id
, name
, NULL
);
458 add_tracker(&starts_locked
, my_id
, name
, NULL
);
459 if (sm
&& slist_has_state(sm
->possible
, &unlocked
) &&
460 strcmp(name
, "bottom_half:") != 0)
461 sm_msg("error: double unlock '%s'", name
);
463 func_has_transition
= TRUE
;
464 set_state(my_id
, name
, NULL
, &unlocked
);
467 static void match_lock_held(const char *fn
, struct expression
*call_expr
,
468 struct expression
*assign_expr
, void *_index
)
470 int index
= PTR_INT(_index
);
472 struct lock_info
*lock
= &lock_table
[index
];
474 if (lock
->arg
== NO_ARG
) {
475 lock_name
= get_full_name(NULL
, index
);
476 } else if (lock
->arg
== RETURN_VAL
) {
479 lock_name
= get_full_name(assign_expr
, index
);
481 lock_name
= get_full_name(call_expr
, index
);
486 free_string(lock_name
);
489 static void match_lock_failed(const char *fn
, struct expression
*call_expr
,
490 struct expression
*assign_expr
, void *_index
)
492 int index
= PTR_INT(_index
);
494 struct lock_info
*lock
= &lock_table
[index
];
496 if (lock
->arg
== NO_ARG
) {
497 lock_name
= get_full_name(NULL
, index
);
498 } else if (lock
->arg
== RETURN_VAL
) {
501 lock_name
= get_full_name(assign_expr
, index
);
503 lock_name
= get_full_name(call_expr
, index
);
507 do_lock_failed(lock_name
);
508 free_string(lock_name
);
511 static void match_returns_locked(const char *fn
, struct expression
*expr
,
514 char *full_name
= NULL
;
515 int index
= PTR_INT(_index
);
516 struct lock_info
*lock
= &lock_table
[index
];
518 if (lock
->arg
!= RETURN_VAL
)
520 full_name
= get_full_name(expr
, index
);
524 static void match_lock_unlock(const char *fn
, struct expression
*expr
, void *_index
)
526 char *full_name
= NULL
;
527 int index
= PTR_INT(_index
);
528 struct lock_info
*lock
= &lock_table
[index
];
533 full_name
= get_full_name(expr
, index
);
536 if (lock
->action
== LOCK
)
539 do_unlock(full_name
);
540 free_string(full_name
);
543 static struct locks_on_return
*alloc_return(struct expression
*expr
)
545 struct locks_on_return
*ret
;
547 ret
= malloc(sizeof(*ret
));
548 if (!get_implied_rl(expr
, &ret
->return_values
))
549 ret
->return_values
= NULL
;
550 ret
->line
= get_lineno();
552 ret
->unlocked
= NULL
;
556 static void check_possible(struct sm_state
*sm
)
558 struct sm_state
*tmp
;
566 FOR_EACH_PTR(sm
->possible
, tmp
) {
567 if (tmp
->state
== &locked
)
569 if (tmp
->state
== &unlocked
)
571 if (tmp
->state
== &start_state
) {
572 struct smatch_state
*s
;
574 s
= get_start_state(tmp
);
577 else if (s
== &unlocked
)
582 if (tmp
->state
== &undefined
)
583 undef
= 1; // i don't think this is possible any more.
584 } END_FOR_EACH_PTR(tmp
);
585 if ((islocked
&& isunlocked
) || undef
)
586 sm_msg("warn: '%s' is sometimes locked here and sometimes unlocked.", sm
->name
);
589 static void match_return(int return_id
, char *return_ranges
,
590 struct expression
*expr
,
591 struct state_list
*fake_cur_slist
)
593 struct locks_on_return
*ret
;
594 struct state_list
*slist
;
595 struct sm_state
*tmp
;
602 ret
= alloc_return(expr
);
604 slist
= get_all_states_slist(my_id
, fake_cur_slist
);
605 FOR_EACH_PTR(slist
, tmp
) {
606 if (tmp
->state
== &locked
) {
607 add_tracker(&ret
->locked
, tmp
->owner
, tmp
->name
,
609 } else if (tmp
->state
== &unlocked
) {
610 add_tracker(&ret
->unlocked
, tmp
->owner
, tmp
->name
,
612 } else if (tmp
->state
== &start_state
) {
613 struct smatch_state
*s
;
615 s
= get_start_state(tmp
);
617 add_tracker(&ret
->locked
, tmp
->owner
, tmp
->name
,
620 add_tracker(&ret
->unlocked
, tmp
->owner
,tmp
->name
,
625 } END_FOR_EACH_PTR(tmp
);
627 add_ptr_list(&all_returns
, ret
);
630 static void print_inconsistent_returns(struct tracker
*lock
,
631 struct smatch_state
*start
)
633 struct locks_on_return
*tmp
;
637 sm_printf("warn: inconsistent returns %s:", lock
->name
);
638 sm_printf(" locked (");
640 FOR_EACH_PTR(all_returns
, tmp
) {
641 if (in_tracker_list(tmp
->unlocked
, lock
->owner
, lock
->name
, lock
->sym
))
643 if (in_tracker_list(tmp
->locked
, lock
->owner
, lock
->name
, lock
->sym
)) {
646 sm_printf("%d", tmp
->line
);
647 if (tmp
->return_values
)
648 sm_printf(" [%s]", show_rl(tmp
->return_values
));
651 if (start
== &locked
) {
654 sm_printf("%d", tmp
->line
);
655 if (tmp
->return_values
)
656 sm_printf(" [%s]", show_rl(tmp
->return_values
));
658 } END_FOR_EACH_PTR(tmp
);
660 sm_printf(") unlocked (");
662 FOR_EACH_PTR(all_returns
, tmp
) {
663 if (in_tracker_list(tmp
->unlocked
, lock
->owner
, lock
->name
, lock
->sym
)) {
666 sm_printf("%d", tmp
->line
);
667 if (tmp
->return_values
)
668 sm_printf(" [%s]", show_rl(tmp
->return_values
));
671 if (in_tracker_list(tmp
->locked
, lock
->owner
, lock
->name
, lock
->sym
))
673 if (start
== &unlocked
) {
676 sm_printf("%d", tmp
->line
);
677 if (tmp
->return_values
)
678 sm_printf(" [%s]", show_rl(tmp
->return_values
));
680 } END_FOR_EACH_PTR(tmp
);
684 static int matches_return_type(struct range_list
*rl
, enum return_type type
)
686 sval_t zero_sval
= ll_to_sval(0);
688 /* All these double negatives are super ugly! */
692 return !possibly_true_rl(rl
, SPECIAL_NOTEQUAL
, alloc_rl(zero_sval
, zero_sval
));
694 return !possibly_true_rl(rl
, SPECIAL_EQUAL
, alloc_rl(zero_sval
, zero_sval
));
696 return !possibly_true_rl(rl
, SPECIAL_GTE
, alloc_rl(zero_sval
, zero_sval
));
698 return !possibly_true_rl(rl
, '<', alloc_rl(zero_sval
, zero_sval
));
705 static int match_held(struct tracker
*lock
, struct locks_on_return
*this_return
, struct smatch_state
*start
)
707 if (in_tracker_list(this_return
->unlocked
, lock
->owner
, lock
->name
, lock
->sym
))
709 if (in_tracker_list(this_return
->locked
, lock
->owner
, lock
->name
, lock
->sym
))
711 if (start
== &unlocked
)
716 static int match_released(struct tracker
*lock
, struct locks_on_return
*this_return
, struct smatch_state
*start
)
718 if (in_tracker_list(this_return
->unlocked
, lock
->owner
, lock
->name
, lock
->sym
))
720 if (in_tracker_list(this_return
->locked
, lock
->owner
, lock
->name
, lock
->sym
))
722 if (start
== &unlocked
)
727 static int held_on_return(struct tracker
*lock
, struct smatch_state
*start
, enum return_type type
)
729 struct locks_on_return
*tmp
;
731 FOR_EACH_PTR(all_returns
, tmp
) {
732 if (!matches_return_type(tmp
->return_values
, type
))
734 if (match_held(lock
, tmp
, start
))
736 } END_FOR_EACH_PTR(tmp
);
740 static int released_on_return(struct tracker
*lock
, struct smatch_state
*start
, enum return_type type
)
742 struct locks_on_return
*tmp
;
744 FOR_EACH_PTR(all_returns
, tmp
) {
745 if (!matches_return_type(tmp
->return_values
, type
))
747 if (match_released(lock
, tmp
, start
))
749 } END_FOR_EACH_PTR(tmp
);
753 static void check_returns_consistently(struct tracker
*lock
,
754 struct smatch_state
*start
)
756 if (!held_on_return(lock
, start
, ret_any
) ||
757 !released_on_return(lock
, start
, ret_any
))
760 if (held_on_return(lock
, start
, ret_zero
) &&
761 !held_on_return(lock
, start
, ret_non_zero
))
764 if (held_on_return(lock
, start
, ret_positive
) &&
765 !held_on_return(lock
, start
, ret_zero
))
768 if (held_on_return(lock
, start
, ret_positive
) &&
769 !held_on_return(lock
, start
, ret_negative
))
772 print_inconsistent_returns(lock
, start
);
775 static void check_consistency(struct symbol
*sym
)
779 FOR_EACH_PTR(starts_locked
, tmp
) {
780 if (in_tracker_list(starts_unlocked
, tmp
->owner
, tmp
->name
,
782 sm_msg("error: locking inconsistency. We assume "
783 "'%s' is both locked and unlocked at the "
786 } END_FOR_EACH_PTR(tmp
);
788 FOR_EACH_PTR(starts_locked
, tmp
) {
789 check_returns_consistently(tmp
, &locked
);
790 } END_FOR_EACH_PTR(tmp
);
792 FOR_EACH_PTR(starts_unlocked
, tmp
) {
793 check_returns_consistently(tmp
, &unlocked
);
794 } END_FOR_EACH_PTR(tmp
);
797 static void clear_lists(void)
799 struct locks_on_return
*tmp
;
801 func_has_transition
= FALSE
;
803 free_trackers_and_list(&starts_locked
);
804 free_trackers_and_list(&starts_unlocked
);
806 FOR_EACH_PTR(all_returns
, tmp
) {
807 free_trackers_and_list(&tmp
->locked
);
808 free_trackers_and_list(&tmp
->unlocked
);
810 } END_FOR_EACH_PTR(tmp
);
811 __free_ptr_list((struct ptr_list
**)&all_returns
);
814 static void match_func_end(struct symbol
*sym
)
819 if (func_has_transition
)
820 check_consistency(sym
);
824 static void register_lock(int index
)
826 struct lock_info
*lock
= &lock_table
[index
];
827 void *idx
= INT_PTR(index
);
829 if (lock
->return_type
== ret_non_zero
) {
830 return_implies_state(lock
->function
, valid_ptr_min
, valid_ptr_max
, &match_lock_held
, idx
);
831 return_implies_state(lock
->function
, 0, 0, &match_lock_failed
, idx
);
832 } else if (lock
->return_type
== ret_any
&& lock
->arg
== RETURN_VAL
) {
833 add_function_assign_hook(lock
->function
, &match_returns_locked
, idx
);
834 } else if (lock
->return_type
== ret_any
) {
835 add_function_hook(lock
->function
, &match_lock_unlock
, idx
);
836 } else if (lock
->return_type
== ret_zero
) {
837 return_implies_state(lock
->function
, 0, 0, &match_lock_held
, idx
);
838 return_implies_state(lock
->function
, -4095, -1, &match_lock_failed
, idx
);
842 static void load_table(struct lock_info
*_lock_table
, int size
)
846 lock_table
= _lock_table
;
848 for (i
= 0; i
< size
; i
++) {
849 if (lock_table
[i
].action
== LOCK
)
852 add_function_hook(lock_table
[i
].function
, &match_lock_unlock
, INT_PTR(i
));
856 /* print_held_locks() is used in check_call_tree.c */
857 void print_held_locks()
859 struct state_list
*slist
;
863 slist
= get_all_states(my_id
);
864 FOR_EACH_PTR(slist
, sm
) {
865 if (sm
->state
!= &locked
)
869 sm_printf("'%s'", sm
->name
);
870 } END_FOR_EACH_PTR(sm
);
874 void check_locking(int id
)
878 if (option_project
== PROJ_WINE
)
879 load_table(wine_lock_table
, ARRAY_SIZE(wine_lock_table
));
880 else if (option_project
== PROJ_KERNEL
)
881 load_table(kernel_lock_table
, ARRAY_SIZE(kernel_lock_table
));
885 add_unmatched_state_hook(my_id
, &unmatched_state
);
886 add_returned_state_callback(match_return
);
887 add_hook(&match_func_end
, END_FUNC_HOOK
);