?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
capped: change += assignments
[smatch.git] / check_locking.c
blobea3473224f000aa9255c17974ecef6ae158745d2
1 /*
2 * Copyright (C) 2009 Dan Carpenter.
3 * Copyright (C) 2019 Oracle.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
17 */
18
19 #include <ctype.h>
20 #include "parse.h"
21 #include "smatch.h"
22 #include "smatch_extra.h"
23 #include "smatch_slist.h"
24
25 static int my_id;
26
27 STATE(locked);
28 STATE(half_locked);
29 STATE(start_state);
30 STATE(unlocked);
31 STATE(impossible);
32 STATE(restore);
33
34 enum action {
35 LOCK,
36 UNLOCK,
37 RESTORE,
38 };
39
40 enum lock_type {
41 spin_lock,
42 read_lock,
43 write_lock,
44 mutex,
45 bottom_half,
46 irq,
47 sem,
48 prepare_lock,
49 enable_lock,
50 };
51
52 const char *get_lock_name(enum lock_type type)
53 {
54 static const char *names[] = {
55 [spin_lock] = "spin_lock",
56 [read_lock] = "read_lock",
57 [write_lock] = "write_lock",
58 [mutex] = "mutex",
59 [bottom_half] = "bottom_half",
60 [irq] = "irq",
61 [sem] = "sem",
62 [prepare_lock] = "prepare_lock",
63 [enable_lock] = "enable_lock",
64 };
65
66 return names[type];
67 }
68
69 enum return_type {
70 ret_any,
71 ret_zero,
72 ret_one,
73 ret_negative,
74 ret_positive,
75 ret_valid_ptr,
76 };
77
78 #define RETURN_VAL -1
79 #define NO_ARG -2
80
81 struct lock_info {
82 const char *function;
83 enum action action;
84 enum lock_type type;
85 int arg;
86 enum return_type return_type;
87 };
88
89 static struct lock_info lock_table[] = {
90 {"spin_lock", LOCK, spin_lock, 0, ret_any},
91 {"spin_unlock", UNLOCK, spin_lock, 0, ret_any},
92 {"spin_lock_nested", LOCK, spin_lock, 0, ret_any},
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 {"raw_spin_lock", LOCK, spin_lock, 0, ret_any},
100 {"raw_spin_unlock", UNLOCK, spin_lock, 0, ret_any},
101 {"_raw_spin_lock", LOCK, spin_lock, 0, ret_any},
102 {"_raw_spin_lock_nested", 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
107 {"spin_lock_irq", LOCK, spin_lock, 0, ret_any},
108 {"spin_unlock_irq", UNLOCK, spin_lock, 0, ret_any},
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 {"_raw_spin_lock_irq", LOCK, spin_lock, 0, ret_any},
114 {"_raw_spin_unlock_irq", UNLOCK, spin_lock, 0, ret_any},
115 {"__raw_spin_unlock_irq", UNLOCK, spin_lock, 0, ret_any},
116 {"spin_lock_irqsave", LOCK, spin_lock, 0, ret_any},
117 {"spin_unlock_irqrestore", 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 {"_raw_spin_lock_irqsave", LOCK, spin_lock, 0, ret_any},
123 {"_raw_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 {"spin_lock_irqsave_nested", LOCK, spin_lock, 0, ret_any},
127 {"_spin_lock_irqsave_nested", LOCK, spin_lock, 0, ret_any},
128 {"__spin_lock_irqsave_nested", LOCK, spin_lock, 0, ret_any},
129 {"_raw_spin_lock_irqsave_nested", LOCK, spin_lock, 0, ret_any},
130 {"spin_lock_bh", LOCK, spin_lock, 0, ret_any},
131 {"spin_unlock_bh", UNLOCK, 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
137 {"spin_trylock", LOCK, spin_lock, 0, ret_one},
138 {"_spin_trylock", LOCK, spin_lock, 0, ret_one},
139 {"__spin_trylock", LOCK, spin_lock, 0, ret_one},
140 {"raw_spin_trylock", LOCK, spin_lock, 0, ret_one},
141 {"_raw_spin_trylock", LOCK, spin_lock, 0, ret_one},
142 {"spin_trylock_irq", LOCK, spin_lock, 0, ret_one},
143 {"spin_trylock_irqsave", LOCK, spin_lock, 0, ret_one},
144 {"spin_trylock_bh", LOCK, spin_lock, 0, ret_one},
145 {"_spin_trylock_bh", LOCK, spin_lock, 0, ret_one},
146 {"__spin_trylock_bh", LOCK, spin_lock, 0, ret_one},
147 {"__raw_spin_trylock", LOCK, spin_lock, 0, ret_one},
148 {"_atomic_dec_and_lock", LOCK, spin_lock, 1, ret_one},
149
150 {"read_lock", LOCK, read_lock, 0, ret_any},
151 {"down_read", LOCK, read_lock, 0, ret_any},
152 {"down_read_nested", LOCK, read_lock, 0, ret_any},
153 {"down_read_trylock", LOCK, read_lock, 0, ret_one},
154 {"up_read", UNLOCK, 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", LOCK, read_lock, 0, ret_any},
159 {"__read_unlock", UNLOCK, read_lock, 0, ret_any},
160 {"_raw_read_lock", LOCK, read_lock, 0, ret_any},
161 {"_raw_read_unlock", UNLOCK, read_lock, 0, ret_any},
162 {"__raw_read_lock", LOCK, read_lock, 0, ret_any},
163 {"__raw_read_unlock", UNLOCK, read_lock, 0, ret_any},
164 {"read_lock_irq", LOCK, read_lock, 0, ret_any},
165 {"read_unlock_irq" , 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 {"_raw_read_unlock_irq", UNLOCK, read_lock, 0, ret_any},
171 {"_raw_read_lock_irq", LOCK, read_lock, 0, ret_any},
172 {"_raw_read_lock_bh", LOCK, read_lock, 0, ret_any},
173 {"_raw_read_unlock_bh", 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_irqsave", LOCK, read_lock, 0, ret_any},
179 {"__read_unlock_irqrestore", 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 {"__read_lock_bh", LOCK, read_lock, 0, ret_any},
185 {"__read_unlock_bh", UNLOCK, read_lock, 0, ret_any},
186 {"__raw_read_lock_bh", LOCK, read_lock, 0, ret_any},
187 {"__raw_read_unlock_bh", UNLOCK, read_lock, 0, ret_any},
188
189 {"_raw_read_lock_irqsave", LOCK, read_lock, 0, ret_any},
190 {"_raw_read_lock_irqsave", LOCK, irq, RETURN_VAL, ret_any},
191 {"_raw_read_unlock_irqrestore", UNLOCK, read_lock, 0, ret_any},
192 {"_raw_read_unlock_irqrestore", RESTORE, irq, 1, ret_any},
193 {"_raw_spin_lock_bh", LOCK, read_lock, 0, ret_any},
194 {"_raw_spin_lock_bh", LOCK, bottom_half, NO_ARG, ret_any},
195 {"_raw_spin_lock_nest_lock", LOCK, read_lock, 0, ret_any},
196 {"_raw_spin_unlock_bh", UNLOCK, read_lock, 0, ret_any},
197 {"_raw_spin_unlock_bh", UNLOCK, bottom_half, NO_ARG, ret_any},
198 {"_raw_write_lock_irqsave", LOCK, write_lock, 0, ret_any},
199 {"_raw_write_lock_irqsave", LOCK, irq, RETURN_VAL, ret_any},
200 {"_raw_write_unlock_irqrestore", UNLOCK, write_lock, 0, ret_any},
201 {"_raw_write_unlock_irqrestore", RESTORE, irq, 1, ret_any},
202 {"__raw_write_unlock_irqrestore", UNLOCK, write_lock, 0, ret_any},
203 {"__raw_write_unlock_irqrestore", RESTORE, irq, 1, ret_any},
204
205 {"generic__raw_read_trylock", LOCK, read_lock, 0, ret_one},
206 {"read_trylock", LOCK, read_lock, 0, ret_one},
207 {"_read_trylock", LOCK, read_lock, 0, ret_one},
208 {"raw_read_trylock", LOCK, read_lock, 0, ret_one},
209 {"_raw_read_trylock", LOCK, read_lock, 0, ret_one},
210 {"__raw_read_trylock", LOCK, read_lock, 0, ret_one},
211 {"__read_trylock", LOCK, read_lock, 0, ret_one},
212
213 {"write_lock", LOCK, write_lock, 0, ret_any},
214 {"down_write", LOCK, write_lock, 0, ret_any},
215 {"down_write_nested", LOCK, write_lock, 0, ret_any},
216 {"up_write", UNLOCK, write_lock, 0, ret_any},
217 {"write_unlock", UNLOCK, write_lock, 0, ret_any},
218 {"_write_lock", LOCK, write_lock, 0, ret_any},
219 {"_write_unlock", UNLOCK, write_lock, 0, ret_any},
220 {"__write_lock", LOCK, write_lock, 0, ret_any},
221 {"__write_unlock", UNLOCK, write_lock, 0, ret_any},
222 {"write_lock_irq", LOCK, write_lock, 0, ret_any},
223 {"write_unlock_irq", UNLOCK, write_lock, 0, ret_any},
224 {"_write_lock_irq", LOCK, write_lock, 0, ret_any},
225 {"_write_unlock_irq", UNLOCK, write_lock, 0, ret_any},
226 {"__write_lock_irq", LOCK, write_lock, 0, ret_any},
227 {"__write_unlock_irq", UNLOCK, write_lock, 0, ret_any},
228 {"_raw_write_unlock_irq", UNLOCK, write_lock, 0, ret_any},
229 {"write_lock_irqsave", LOCK, write_lock, 0, ret_any},
230 {"write_unlock_irqrestore", UNLOCK, write_lock, 0, ret_any},
231 {"_write_lock_irqsave", LOCK, write_lock, 0, ret_any},
232 {"_write_unlock_irqrestore", UNLOCK, write_lock, 0, ret_any},
233 {"__write_lock_irqsave", LOCK, write_lock, 0, ret_any},
234 {"__write_unlock_irqrestore", UNLOCK, write_lock, 0, ret_any},
235 {"write_lock_bh", LOCK, write_lock, 0, ret_any},
236 {"write_unlock_bh", UNLOCK, write_lock, 0, ret_any},
237 {"_write_lock_bh", LOCK, write_lock, 0, ret_any},
238 {"_write_unlock_bh", UNLOCK, write_lock, 0, ret_any},
239 {"__write_lock_bh", LOCK, write_lock, 0, ret_any},
240 {"__write_unlock_bh", UNLOCK, write_lock, 0, ret_any},
241 {"_raw_write_lock", LOCK, write_lock, 0, ret_any},
242 {"__raw_write_lock", LOCK, write_lock, 0, ret_any},
243 {"_raw_write_unlock", UNLOCK, write_lock, 0, ret_any},
244 {"__raw_write_unlock", UNLOCK, write_lock, 0, ret_any},
245 {"_raw_write_lock_bh", LOCK, write_lock, 0, ret_any},
246 {"_raw_write_unlock_bh", UNLOCK, write_lock, 0, ret_any},
247 {"_raw_write_lock_irq", LOCK, write_lock, 0, ret_any},
248
249 {"write_trylock", LOCK, write_lock, 0, ret_one},
250 {"_write_trylock", LOCK, write_lock, 0, ret_one},
251 {"raw_write_trylock", LOCK, write_lock, 0, ret_one},
252 {"_raw_write_trylock", LOCK, write_lock, 0, ret_one},
253 {"__write_trylock", LOCK, write_lock, 0, ret_one},
254 {"__raw_write_trylock", LOCK, write_lock, 0, ret_one},
255 {"down_write_trylock", LOCK, write_lock, 0, ret_one},
256 {"down_write_killable", LOCK, write_lock, 0, ret_zero},
257
258 {"down", LOCK, sem, 0, ret_any},
259 {"up", UNLOCK, sem, 0, ret_any},
260 {"down_trylock", LOCK, sem, 0, ret_zero},
261 {"down_timeout", LOCK, sem, 0, ret_zero},
262 {"down_interruptible", LOCK, sem, 0, ret_zero},
263 {"down_killable", LOCK, sem, 0, ret_zero},
264
265
266 {"mutex_lock", LOCK, mutex, 0, ret_any},
267 {"mutex_unlock", UNLOCK, mutex, 0, ret_any},
268 {"mutex_lock_nested", LOCK, mutex, 0, ret_any},
269 {"mutex_lock_io", LOCK, mutex, 0, ret_any},
270 {"mutex_lock_io_nested", LOCK, mutex, 0, ret_any},
271
272 {"mutex_lock_interruptible", LOCK, mutex, 0, ret_zero},
273 {"mutex_lock_interruptible_nested", LOCK, mutex, 0, ret_zero},
274 {"mutex_lock_killable", LOCK, mutex, 0, ret_zero},
275 {"mutex_lock_killable_nested", LOCK, mutex, 0, ret_zero},
276
277 {"mutex_trylock", LOCK, mutex, 0, ret_one},
278
279 {"ww_mutex_lock", LOCK, mutex, 0, ret_any},
280 {"__ww_mutex_lock", LOCK, mutex, 0, ret_any},
281 {"ww_mutex_lock_interruptible", LOCK, mutex, 0, ret_zero},
282 {"ww_mutex_unlock", UNLOCK, mutex, 0, ret_any},
283
284 {"raw_local_irq_disable", LOCK, irq, NO_ARG, ret_any},
285 {"raw_local_irq_enable", UNLOCK, irq, NO_ARG, ret_any},
286 {"spin_lock_irq", LOCK, irq, NO_ARG, ret_any},
287 {"spin_unlock_irq", UNLOCK, irq, NO_ARG, ret_any},
288 {"_spin_lock_irq", LOCK, irq, NO_ARG, ret_any},
289 {"_spin_unlock_irq", UNLOCK, irq, NO_ARG, ret_any},
290 {"__spin_lock_irq", LOCK, irq, NO_ARG, ret_any},
291 {"__spin_unlock_irq", UNLOCK, irq, NO_ARG, ret_any},
292 {"_raw_spin_lock_irq", LOCK, irq, NO_ARG, ret_any},
293 {"_raw_spin_unlock_irq", UNLOCK, irq, NO_ARG, ret_any},
294 {"__raw_spin_unlock_irq", UNLOCK, irq, NO_ARG, ret_any},
295 {"spin_trylock_irq", LOCK, irq, NO_ARG, ret_one},
296 {"read_lock_irq", LOCK, irq, NO_ARG, ret_any},
297 {"read_unlock_irq", UNLOCK, irq, NO_ARG, ret_any},
298 {"_read_lock_irq", LOCK, irq, NO_ARG, ret_any},
299 {"_read_unlock_irq", UNLOCK, irq, NO_ARG, ret_any},
300 {"__read_lock_irq", LOCK, irq, NO_ARG, ret_any},
301 {"_raw_read_lock_irq", LOCK, irq, NO_ARG, ret_any},
302 {"__read_unlock_irq", UNLOCK, irq, NO_ARG, ret_any},
303 {"_raw_read_unlock_irq", UNLOCK, irq, NO_ARG, ret_any},
304 {"write_lock_irq", LOCK, irq, NO_ARG, ret_any},
305 {"write_unlock_irq", UNLOCK, irq, NO_ARG, ret_any},
306 {"_write_lock_irq", LOCK, irq, NO_ARG, ret_any},
307 {"_write_unlock_irq", UNLOCK, irq, NO_ARG, ret_any},
308 {"__write_lock_irq", LOCK, irq, NO_ARG, ret_any},
309 {"__write_unlock_irq", UNLOCK, irq, NO_ARG, ret_any},
310 {"_raw_write_lock_irq", LOCK, irq, NO_ARG, ret_any},
311 {"_raw_write_unlock_irq", UNLOCK, irq, NO_ARG, ret_any},
312
313 {"arch_local_irq_save", LOCK, irq, RETURN_VAL, ret_any},
314 {"arch_local_irq_restore", RESTORE, irq, 0, ret_any},
315 {"__raw_local_irq_save", LOCK, irq, RETURN_VAL, ret_any},
316 {"raw_local_irq_restore", RESTORE, irq, 0, ret_any},
317 {"spin_lock_irqsave_nested", LOCK, irq, RETURN_VAL, ret_any},
318 {"spin_lock_irqsave", LOCK, irq, 1, ret_any},
319 {"spin_unlock_irqrestore", RESTORE, irq, 1, ret_any},
320 {"_spin_lock_irqsave_nested", LOCK, irq, RETURN_VAL, ret_any},
321 {"_spin_lock_irqsave", LOCK, irq, RETURN_VAL, ret_any},
322 {"_spin_lock_irqsave", LOCK, irq, 1, ret_any},
323 {"_spin_unlock_irqrestore", RESTORE, irq, 1, ret_any},
324 {"__spin_lock_irqsave_nested", LOCK, irq, 1, ret_any},
325 {"__spin_lock_irqsave", LOCK, irq, 1, ret_any},
326 {"__spin_unlock_irqrestore", RESTORE, irq, 1, ret_any},
327 {"_raw_spin_lock_irqsave", LOCK, irq, RETURN_VAL, ret_any},
328 {"_raw_spin_lock_irqsave", LOCK, irq, 1, ret_any},
329 {"_raw_spin_unlock_irqrestore", RESTORE, irq, 1, ret_any},
330 {"__raw_spin_lock_irqsave", LOCK, irq, RETURN_VAL, ret_any},
331 {"__raw_spin_unlock_irqrestore", RESTORE, irq, 1, ret_any},
332 {"_raw_spin_lock_irqsave_nested", LOCK, irq, RETURN_VAL, ret_any},
333 {"spin_trylock_irqsave", LOCK, irq, 1, ret_one},
334 {"read_lock_irqsave", LOCK, irq, RETURN_VAL, ret_any},
335 {"read_lock_irqsave", LOCK, irq, 1, ret_any},
336 {"read_unlock_irqrestore", RESTORE, irq, 1, ret_any},
337 {"_read_lock_irqsave", LOCK, irq, RETURN_VAL, ret_any},
338 {"_read_lock_irqsave", LOCK, irq, 1, ret_any},
339 {"_read_unlock_irqrestore", RESTORE, irq, 1, ret_any},
340 {"__read_lock_irqsave", LOCK, irq, RETURN_VAL, ret_any},
341 {"__read_unlock_irqrestore", RESTORE, irq, 1, ret_any},
342 {"write_lock_irqsave", LOCK, irq, RETURN_VAL, ret_any},
343 {"write_lock_irqsave", LOCK, irq, 1, ret_any},
344 {"write_unlock_irqrestore", RESTORE, irq, 1, ret_any},
345 {"_write_lock_irqsave", LOCK, irq, RETURN_VAL, ret_any},
346 {"_write_lock_irqsave", LOCK, irq, 1, ret_any},
347 {"_write_unlock_irqrestore", RESTORE, irq, 1, ret_any},
348 {"__write_lock_irqsave", LOCK, irq, RETURN_VAL, ret_any},
349 {"__write_unlock_irqrestore", RESTORE, irq, 1, ret_any},
350
351 {"local_bh_disable", LOCK, bottom_half, NO_ARG, ret_any},
352 {"_local_bh_disable", LOCK, bottom_half, NO_ARG, ret_any},
353 {"__local_bh_disable", LOCK, bottom_half, NO_ARG, ret_any},
354 {"local_bh_enable", UNLOCK, bottom_half, NO_ARG, ret_any},
355 {"_local_bh_enable", UNLOCK, bottom_half, NO_ARG, ret_any},
356 {"__local_bh_enable", UNLOCK, bottom_half, NO_ARG, ret_any},
357 {"spin_lock_bh", LOCK, bottom_half, NO_ARG, ret_any},
358 {"spin_unlock_bh", UNLOCK, bottom_half, NO_ARG, ret_any},
359 {"_spin_lock_bh", LOCK, bottom_half, NO_ARG, ret_any},
360 {"_spin_unlock_bh", UNLOCK, bottom_half, NO_ARG, ret_any},
361 {"__spin_lock_bh", LOCK, bottom_half, NO_ARG, ret_any},
362 {"__spin_unlock_bh", UNLOCK, bottom_half, NO_ARG, ret_any},
363 {"read_lock_bh", LOCK, bottom_half, NO_ARG, ret_any},
364 {"read_unlock_bh", UNLOCK, bottom_half, NO_ARG, ret_any},
365 {"_read_lock_bh", LOCK, bottom_half, NO_ARG, ret_any},
366 {"_read_unlock_bh", UNLOCK, bottom_half, NO_ARG, ret_any},
367 {"__read_lock_bh", LOCK, bottom_half, NO_ARG, ret_any},
368 {"__read_unlock_bh", UNLOCK, bottom_half, NO_ARG, ret_any},
369 {"_raw_read_lock_bh", LOCK, bottom_half, NO_ARG, ret_any},
370 {"_raw_read_unlock_bh", UNLOCK, bottom_half, NO_ARG, ret_any},
371 {"write_lock_bh", LOCK, bottom_half, NO_ARG, ret_any},
372 {"write_unlock_bh", UNLOCK, bottom_half, NO_ARG, ret_any},
373 {"_write_lock_bh", LOCK, bottom_half, NO_ARG, ret_any},
374 {"_write_unlock_bh", UNLOCK, bottom_half, NO_ARG, ret_any},
375 {"__write_lock_bh", LOCK, bottom_half, NO_ARG, ret_any},
376 {"__write_unlock_bh", UNLOCK, bottom_half, NO_ARG, ret_any},
377 {"_raw_write_lock_bh", LOCK, bottom_half, NO_ARG, ret_any},
378 {"_raw_write_unlock_bh",UNLOCK, bottom_half, NO_ARG, ret_any},
379 {"spin_trylock_bh", LOCK, bottom_half, NO_ARG, ret_one},
380 {"_spin_trylock_bh", LOCK, bottom_half, NO_ARG, ret_one},
381 {"__spin_trylock_bh", LOCK, bottom_half, NO_ARG, ret_one},
382
383 {"ffs_mutex_lock", LOCK, mutex, 0, ret_zero},
384
385 {"clk_prepare_lock", LOCK, prepare_lock, NO_ARG, ret_any},
386 {"clk_prepare_unlock", UNLOCK, prepare_lock, NO_ARG, ret_any},
387 {"clk_enable_lock", LOCK, enable_lock, -1, ret_any},
388 {"clk_enable_unlock", UNLOCK, enable_lock, 0, ret_any},
389
390 {"dma_resv_lock", LOCK, mutex, 0, ret_zero},
391 {"dma_resv_trylock", LOCK, mutex, 0, ret_one},
392 {"dma_resv_lock_interruptible", LOCK, mutex, 0, ret_zero},
393 {"dma_resv_unlock", UNLOCK, mutex, 0, ret_any},
394
395 {"modeset_lock", LOCK, mutex, 0, ret_zero},
396 {"drm_ modeset_lock", LOCK, mutex, 0, ret_zero},
397 {"drm_modeset_lock_single_interruptible", LOCK, mutex, 0, ret_zero},
398 {"modeset_unlock", UNLOCK, mutex, 0, ret_any},
399
400 {"reiserfs_write_lock_nested", LOCK, mutex, 0, ret_any},
401 {"reiserfs_write_unlock_nested", UNLOCK, mutex, 0, ret_any},
402
403 {"rw_lock", LOCK, write_lock, 1, ret_any},
404 {"rw_unlock", UNLOCK, write_lock, 1, ret_any},
405
406 {"sem_lock", LOCK, mutex, 0, ret_any},
407 {"sem_unlock", UNLOCK, mutex, 0, ret_any},
408
409 {},
410 };
411
412 struct macro_info {
413 const char *macro;
414 enum action action;
415 int param;
416 };
417
418 static struct macro_info macro_table[] = {
419 {"genpd_lock", LOCK, 0},
420 {"genpd_lock_nested", LOCK, 0},
421 {"genpd_lock_interruptible", LOCK, 0},
422 {"genpd_unlock", UNLOCK, 0},
423 };
424
425 static const char *false_positives[][2] = {
426 {"fs/jffs2/", "->alloc_sem"},
427 {"fs/xfs/", "->b_sema"},
428 {"mm/", "pvmw->ptl"},
429 };
430
431 static struct stree *start_states;
432
433 static struct tracker_list *locks;
434
435 static void reset(struct sm_state *sm, struct expression *mod_expr)
436 {
437 set_state(my_id, sm->name, sm->sym, &start_state);
438 }
439
440 static struct expression *remove_spinlock_check(struct expression *expr)
441 {
442 if (expr->type != EXPR_CALL)
443 return expr;
444 if (expr->fn->type != EXPR_SYMBOL)
445 return expr;
446 if (strcmp(expr->fn->symbol_name->name, "spinlock_check"))
447 return expr;
448 expr = get_argument_from_call_expr(expr->args, 0);
449 return expr;
450 }
451
452 static struct expression *filter_kernel_args(struct expression *arg)
453 {
454 if (arg->type == EXPR_PREOP && arg->op == '&')
455 return strip_expr(arg->unop);
456 if (!is_pointer(arg))
457 return arg;
458 return deref_expression(strip_expr(arg));
459 }
460
461 static char *lock_to_name_sym(struct expression *expr, struct symbol **sym)
462 {
463 expr = remove_spinlock_check(expr);
464 expr = filter_kernel_args(expr);
465 return expr_to_str_sym(expr, sym);
466 }
467
468 static char *get_full_name(struct expression *expr, int index, struct symbol **sym)
469 {
470 struct lock_info *lock = &lock_table[index];
471 struct expression *arg;
472
473 *sym = NULL;
474 if (lock->arg == RETURN_VAL) {
475 return expr_to_var_sym(strip_expr(expr->left), sym);
476 } else if (lock->arg == NO_ARG) {
477 return alloc_string(get_lock_name(lock->type));
478 } else {
479 arg = get_argument_from_call_expr(expr->args, lock->arg);
480 if (!arg)
481 return NULL;
482 return lock_to_name_sym(arg, sym);
483 }
484 }
485
486 static struct smatch_state *unmatched_state(struct sm_state *sm)
487 {
488 return &start_state;
489 }
490
491 static void pre_merge_hook(struct sm_state *cur, struct sm_state *other)
492 {
493 if (is_impossible_path())
494 set_state(my_id, cur->name, cur->sym, &impossible);
495 }
496
497 static struct smatch_state *merge_func(struct smatch_state *s1, struct smatch_state *s2)
498 {
499 if (s1 == &impossible)
500 return s2;
501 if (s2 == &impossible)
502 return s1;
503 return &merged;
504 }
505
506 static struct smatch_state *action_to_state(enum action lock_unlock)
507 {
508 switch (lock_unlock) {
509 case LOCK:
510 return &locked;
511 case UNLOCK:
512 return &unlocked;
513 case RESTORE:
514 return &restore;
515 }
516 return NULL;
517 }
518
519 static struct sm_state *get_best_match(const char *key, enum action lock_unlock)
520 {
521 struct sm_state *sm;
522 struct sm_state *match;
523 int cnt = 0;
524 int start_pos, state_len, key_len, chunks, i;
525
526 if (strncmp(key, "$->", 3) == 0)
527 key += 3;
528
529 key_len = strlen(key);
530 chunks = 0;
531 for (i = key_len - 1; i > 0; i--) {
532 if (key[i] == '>' || key[i] == '.')
533 chunks++;
534 if (chunks == 2) {
535 key += (i + 1);
536 key_len = strlen(key);
537 break;
538 }
539 }
540
541 FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
542 if (((lock_unlock == UNLOCK || lock_unlock == RESTORE) &&
543 sm->state != &locked) ||
544 (lock_unlock == LOCK && sm->state != &unlocked))
545 continue;
546 state_len = strlen(sm->name);
547 if (state_len < key_len)
548 continue;
549 start_pos = state_len - key_len;
550 if ((start_pos == 0 || !isalnum(sm->name[start_pos - 1])) &&
551 strcmp(sm->name + start_pos, key) == 0) {
552 cnt++;
553 match = sm;
554 }
555 } END_FOR_EACH_SM(sm);
556
557 if (cnt == 1)
558 return match;
559 return NULL;
560 }
561
562 static void use_best_match(char *key, enum action lock_unlock)
563 {
564 struct sm_state *match;
565
566 match = get_best_match(key, lock_unlock);
567 if (match)
568 set_state(my_id, match->name, match->sym, action_to_state(lock_unlock));
569 else
570 set_state(my_id, key, NULL, action_to_state(lock_unlock));
571 }
572
573 static void set_start_state(const char *name, struct symbol *sym, struct smatch_state *start)
574 {
575 struct smatch_state *orig;
576
577 orig = get_state_stree(start_states, my_id, name, sym);
578 if (!orig)
579 set_state_stree(&start_states, my_id, name, sym, start);
580 else if (orig != start)
581 set_state_stree(&start_states, my_id, name, sym, &undefined);
582 }
583
584 static bool common_false_positive(const char *name)
585 {
586 const char *path, *lname;
587 int i, len_total, len_path, len_name, skip;
588
589 if (!get_filename())
590 return false;
591
592 len_total = strlen(name);
593 for (i = 0; i < ARRAY_SIZE(false_positives); i++) {
594 path = false_positives[i][0];
595 lname = false_positives[i][1];
596
597 len_path = strlen(path);
598 len_name = strlen(lname);
599
600 if (len_name > len_total)
601 continue;
602 skip = len_total - len_name;
603
604 if (strncmp(get_filename(), path, len_path) == 0 &&
605 strcmp(name + skip, lname) == 0)
606 return true;
607 }
608
609 return false;
610 }
611
612 static void warn_on_double(struct sm_state *sm, struct smatch_state *state)
613 {
614 struct sm_state *tmp;
615
616 if (!sm)
617 return;
618
619 FOR_EACH_PTR(sm->possible, tmp) {
620 if (tmp->state == state)
621 goto found;
622 } END_FOR_EACH_PTR(tmp);
623
624 return;
625 found:
626 if (strcmp(sm->name, "bottom_half") == 0)
627 return;
628 if (common_false_positive(sm->name))
629 return;
630 sm_msg("error: double %s '%s' (orig line %u)",
631 state->name, sm->name, tmp->line);
632 }
633
634 static bool handle_macro_lock_unlock(void)
635 {
636 struct expression *expr, *arg;
637 struct macro_info *info;
638 struct sm_state *sm;
639 struct symbol *sym;
640 const char *macro;
641 char *name;
642 bool ret = false;
643 int i;
644
645 expr = last_ptr_list((struct ptr_list *)big_expression_stack);
646 while (expr && expr->type == EXPR_ASSIGNMENT)
647 expr = strip_expr(expr->right);
648 if (!expr || expr->type != EXPR_CALL)
649 return false;
650
651 macro = get_macro_name(expr->pos);
652 if (!macro)
653 return false;
654
655 for (i = 0; i < ARRAY_SIZE(macro_table); i++) {
656 info = &macro_table[i];
657
658 if (strcmp(macro, info->macro) != 0)
659 continue;
660 arg = get_argument_from_call_expr(expr->args, info->param);
661 name = expr_to_str_sym(arg, &sym);
662 if (!name || !sym)
663 goto free;
664 sm = get_sm_state(my_id, name, sym);
665
666 if (info->action == LOCK) {
667 if (!sm)
668 set_start_state(name, sym, &unlocked);
669 if (sm && sm->line != expr->pos.line)
670 warn_on_double(sm, &locked);
671 set_state(my_id, name, sym, &locked);
672 } else {
673 if (!sm)
674 set_start_state(name, sym, &locked);
675 if (sm && sm->line != expr->pos.line)
676 warn_on_double(sm, &unlocked);
677 set_state(my_id, name, sym, &unlocked);
678 }
679 ret = true;
680 free:
681 free_string(name);
682 return ret;
683 }
684 return false;
685 }
686
687 static void do_lock(const char *name, struct symbol *sym, struct lock_info *info)
688 {
689 struct sm_state *sm;
690
691 if (handle_macro_lock_unlock())
692 return;
693
694 add_tracker(&locks, my_id, name, sym);
695
696 sm = get_sm_state(my_id, name, sym);
697 if (!sm)
698 set_start_state(name, sym, &unlocked);
699 warn_on_double(sm, &locked);
700 set_state(my_id, name, sym, &locked);
701 }
702
703 static void do_lock_failed(const char *name, struct symbol *sym)
704 {
705 add_tracker(&locks, my_id, name, sym);
706 set_state(my_id, name, sym, &unlocked);
707 }
708
709 static void do_unlock(const char *name, struct symbol *sym, struct lock_info *info)
710 {
711 struct sm_state *sm;
712
713 if (__path_is_null())
714 return;
715
716 if (handle_macro_lock_unlock())
717 return;
718
719 add_tracker(&locks, my_id, name, sym);
720 sm = get_sm_state(my_id, name, sym);
721 if (!sm) {
722 sm = get_best_match(name, UNLOCK);
723 if (sm) {
724 name = sm->name;
725 sym = sm->sym;
726 }
727 }
728 if (!sm)
729 set_start_state(name, sym, &locked);
730 warn_on_double(sm, &unlocked);
731 set_state(my_id, name, sym, &unlocked);
732 }
733
734 static void do_restore(const char *name, struct symbol *sym, struct lock_info *info)
735 {
736 if (__path_is_null())
737 return;
738
739 if (!get_state(my_id, name, sym))
740 set_start_state(name, sym, &locked);
741
742 add_tracker(&locks, my_id, name, sym);
743 set_state(my_id, name, sym, &restore);
744 }
745
746 static void match_lock_held(const char *fn, struct expression *call_expr,
747 struct expression *assign_expr, void *_index)
748 {
749 int index = PTR_INT(_index);
750 struct lock_info *lock = &lock_table[index];
751 char *lock_name;
752 struct symbol *sym;
753
754 if (lock->arg == NO_ARG) {
755 lock_name = get_full_name(NULL, index, &sym);
756 } else if (lock->arg == RETURN_VAL) {
757 if (!assign_expr)
758 return;
759 lock_name = get_full_name(assign_expr, index, &sym);
760 } else {
761 lock_name = get_full_name(call_expr, index, &sym);
762 }
763 if (!lock_name)
764 return;
765 do_lock(lock_name, sym, lock);
766 free_string(lock_name);
767 }
768
769 static void match_lock_failed(const char *fn, struct expression *call_expr,
770 struct expression *assign_expr, void *_index)
771 {
772 int index = PTR_INT(_index);
773 struct lock_info *lock = &lock_table[index];
774 char *lock_name;
775 struct symbol *sym;
776
777 if (lock->arg == NO_ARG) {
778 lock_name = get_full_name(NULL, index, &sym);
779 } else if (lock->arg == RETURN_VAL) {
780 if (!assign_expr)
781 return;
782 lock_name = get_full_name(assign_expr, index, &sym);
783 } else {
784 lock_name = get_full_name(call_expr, index, &sym);
785 }
786 if (!lock_name)
787 return;
788 do_lock_failed(lock_name, sym);
789 free_string(lock_name);
790 }
791
792 static void match_returns_locked(const char *fn, struct expression *expr,
793 void *_index)
794 {
795 int index = PTR_INT(_index);
796 struct lock_info *lock = &lock_table[index];
797 char *full_name;
798 struct symbol *sym;
799
800 if (lock->arg != RETURN_VAL)
801 return;
802 full_name = get_full_name(expr, index, &sym);
803 if (!full_name)
804 return;
805 do_lock(full_name, sym, lock);
806 }
807
808 static void match_lock_unlock(const char *fn, struct expression *expr, void *_index)
809 {
810 int index = PTR_INT(_index);
811 struct lock_info *lock = &lock_table[index];
812 char *full_name;
813 struct symbol *sym;
814
815 full_name = get_full_name(expr, index, &sym);
816 if (!full_name)
817 return;
818 switch (lock->action) {
819 case LOCK:
820 do_lock(full_name, sym, lock);
821 break;
822 case UNLOCK:
823 do_unlock(full_name, sym, lock);
824 break;
825 case RESTORE:
826 do_restore(full_name, sym, lock);
827 break;
828 }
829 free_string(full_name);
830 }
831
832 static struct smatch_state *get_start_state(struct sm_state *sm)
833 {
834 struct smatch_state *orig;
835
836 orig = get_state_stree(start_states, my_id, sm->name, sm->sym);
837 if (orig)
838 return orig;
839 return &undefined;
840 }
841
842 static int get_db_type(struct sm_state *sm)
843 {
844 if (sm->state == get_start_state(sm)) {
845 if (sm->state == &locked)
846 return KNOWN_LOCKED;
847 if (sm->state == &unlocked)
848 return KNOWN_UNLOCKED;
849 }
850
851 if (sm->state == &locked)
852 return LOCKED;
853 if (sm->state == &unlocked)
854 return UNLOCKED;
855 if (sm->state == &restore)
856 return LOCK_RESTORED;
857 return LOCKED;
858 }
859
860 static void match_return_info(int return_id, char *return_ranges, struct expression *expr)
861 {
862 struct sm_state *sm;
863 const char *param_name;
864 int param;
865
866 FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
867 if (sm->state != &locked &&
868 sm->state != &unlocked &&
869 sm->state != &restore)
870 continue;
871
872 param = get_param_key_from_sm(sm, expr, &param_name);
873 sql_insert_return_states(return_id, return_ranges,
874 get_db_type(sm),
875 param, param_name, "");
876 } END_FOR_EACH_SM(sm);
877 }
878
879 enum {
880 ERR_PTR, VALID_PTR, NEGATIVE, ZERO, POSITIVE, NUM_BUCKETS,
881 };
882
883 static bool is_EINTR(struct range_list *rl)
884 {
885 sval_t sval;
886
887 if (!rl_to_sval(rl, &sval))
888 return false;
889 return sval.value == -4;
890 }
891
892 static int success_fail_positive(struct range_list *rl)
893 {
894 /* void returns are the same as success (zero in the kernel) */
895 if (!rl)
896 return ZERO;
897
898 if (rl_type(rl)->type != SYM_PTR && sval_is_negative(rl_min(rl)))
899 return NEGATIVE;
900
901 if (rl_min(rl).value == 0 && rl_max(rl).value == 0)
902 return ZERO;
903
904 if (is_err_ptr(rl_min(rl)) &&
905 is_err_ptr(rl_max(rl)))
906 return ERR_PTR;
907
908 /*
909 * Trying to match ERR_PTR(ret) but without the expression struct.
910 * Ugly...
911 */
912 if (type_bits(&long_ctype) == 64 &&
913 rl_type(rl)->type == SYM_PTR &&
914 rl_min(rl).value == INT_MIN)
915 return ERR_PTR;
916
917 return POSITIVE;
918 }
919
920 static bool sym_in_lock_table(struct symbol *sym)
921 {
922 int i;
923
924 if (!sym || !sym->ident)
925 return false;
926
927 for (i = 0; lock_table[i].function != NULL; i++) {
928 if (strcmp(lock_table[i].function, sym->ident->name) == 0)
929 return true;
930 }
931 return false;
932 }
933
934 static bool func_in_lock_table(struct expression *expr)
935 {
936 if (expr->type != EXPR_SYMBOL)
937 return false;
938 return sym_in_lock_table(expr->symbol);
939 }
940
941 static void check_lock(char *name, struct symbol *sym)
942 {
943 struct range_list *locked_lines = NULL;
944 struct range_list *unlocked_lines = NULL;
945 int locked_buckets[NUM_BUCKETS] = {};
946 int unlocked_buckets[NUM_BUCKETS] = {};
947 struct stree *stree, *orig;
948 struct sm_state *return_sm;
949 struct sm_state *sm;
950 sval_t line = sval_type_val(&int_ctype, 0);
951 int bucket;
952 int i;
953
954 if (sym_in_lock_table(cur_func_sym))
955 return;
956
957 FOR_EACH_PTR(get_all_return_strees(), stree) {
958 orig = __swap_cur_stree(stree);
959
960 if (is_impossible_path())
961 goto swap_stree;
962
963 return_sm = get_sm_state(RETURN_ID, "return_ranges", NULL);
964 if (!return_sm)
965 goto swap_stree;
966 line.value = return_sm->line;
967
968 sm = get_sm_state(my_id, name, sym);
969 if (!sm)
970 goto swap_stree;
971
972 if (parent_is_gone_var_sym(sm->name, sm->sym))
973 goto swap_stree;
974
975 if (sm->state != &locked &&
976 sm->state != &unlocked &&
977 sm->state != &restore)
978 goto swap_stree;
979
980 if ((sm->state == &unlocked || sm->state == &restore) &&
981 is_EINTR(estate_rl(return_sm->state)))
982 goto swap_stree;
983
984 bucket = success_fail_positive(estate_rl(return_sm->state));
985 if (sm->state == &locked) {
986 add_range(&locked_lines, line, line);
987 locked_buckets[bucket] = true;
988 }
989 if (sm->state == &unlocked || sm->state == &restore) {
990 add_range(&unlocked_lines, line, line);
991 unlocked_buckets[bucket] = true;
992 }
993 swap_stree:
994 __swap_cur_stree(orig);
995 } END_FOR_EACH_PTR(stree);
996
997
998 if (!locked_lines || !unlocked_lines)
999 return;
1000
1001 for (i = 0; i < NUM_BUCKETS; i++) {
1002 if (locked_buckets[i] && unlocked_buckets[i])
1003 goto complain;
1004 }
1005 if (locked_buckets[NEGATIVE] &&
1006 (unlocked_buckets[ZERO] || unlocked_buckets[POSITIVE]))
1007 goto complain;
1008
1009 if (locked_buckets[ERR_PTR])
1010 goto complain;
1011
1012 return;
1013
1014 complain:
1015 sm_msg("warn: inconsistent returns '%s'.", name);
1016 sm_printf(" Locked on : %s\n", show_rl(locked_lines));
1017 sm_printf(" Unlocked on: %s\n", show_rl(unlocked_lines));
1018 }
1019
1020 static void match_func_end(struct symbol *sym)
1021 {
1022 struct tracker *tracker;
1023
1024 FOR_EACH_PTR(locks, tracker) {
1025 check_lock(tracker->name, tracker->sym);
1026 } END_FOR_EACH_PTR(tracker);
1027 }
1028
1029 static void register_lock(int index)
1030 {
1031 struct lock_info *lock = &lock_table[index];
1032 void *idx = INT_PTR(index);
1033
1034 if (lock->return_type == ret_one) {
1035 return_implies_state(lock->function, 1, 1, &match_lock_held, idx);
1036 return_implies_state(lock->function, 0, 0, &match_lock_failed, idx);
1037 } else if (lock->return_type == ret_any && lock->arg == RETURN_VAL) {
1038 add_function_assign_hook(lock->function, &match_returns_locked, idx);
1039 } else if (lock->return_type == ret_any) {
1040 add_function_hook(lock->function, &match_lock_unlock, idx);
1041 } else if (lock->return_type == ret_zero) {
1042 return_implies_state(lock->function, 0, 0, &match_lock_held, idx);
1043 return_implies_state(lock->function, -4095, -1, &match_lock_failed, idx);
1044 } else if (lock->return_type == ret_valid_ptr) {
1045 return_implies_state_sval(lock->function, valid_ptr_min_sval, valid_ptr_max_sval, &match_lock_held, idx);
1046 }
1047 }
1048
1049 static void load_table(struct lock_info *lock_table)
1050 {
1051 int i;
1052
1053 for (i = 0; lock_table[i].function != NULL; i++) {
1054 if (lock_table[i].action == LOCK)
1055 register_lock(i);
1056 else
1057 add_function_hook(lock_table[i].function, &match_lock_unlock, INT_PTR(i));
1058 }
1059 }
1060
1061 static void db_param_locked_unlocked(struct expression *expr, int param, char *key, char *value, enum action lock_unlock)
1062 {
1063 struct expression *call, *arg;
1064 char *name;
1065 struct symbol *sym;
1066
1067 call = expr;
1068 while (call->type == EXPR_ASSIGNMENT)
1069 call = strip_expr(call->right);
1070 if (call->type != EXPR_CALL)
1071 return;
1072
1073 if (func_in_lock_table(call->fn))
1074 return;
1075
1076 if (param == -2) {
1077 use_best_match(key, lock_unlock);
1078 return;
1079 }
1080
1081 if (param == -1) {
1082 if (expr->type != EXPR_ASSIGNMENT)
1083 return;
1084 name = get_variable_from_key(expr->left, key, &sym);
1085 } else {
1086 arg = get_argument_from_call_expr(call->args, param);
1087 if (!arg)
1088 return;
1089
1090 name = get_variable_from_key(arg, key, &sym);
1091 }
1092 if (!name || !sym)
1093 goto free;
1094
1095 if (lock_unlock == LOCK)
1096 do_lock(name, sym, NULL);
1097 else if (lock_unlock == UNLOCK)
1098 do_unlock(name, sym, NULL);
1099 else if (lock_unlock == RESTORE)
1100 do_restore(name, sym, NULL);
1101
1102 free:
1103 free_string(name);
1104 }
1105
1106 static void db_param_locked(struct expression *expr, int param, char *key, char *value)
1107 {
1108 db_param_locked_unlocked(expr, param, key, value, LOCK);
1109 }
1110
1111 static void db_param_unlocked(struct expression *expr, int param, char *key, char *value)
1112 {
1113 db_param_locked_unlocked(expr, param, key, value, UNLOCK);
1114 }
1115
1116 static void db_param_restore(struct expression *expr, int param, char *key, char *value)
1117 {
1118 db_param_locked_unlocked(expr, param, key, value, RESTORE);
1119 }
1120
1121 static int get_caller_param_lock_name(struct expression *call, struct sm_state *sm, const char **name)
1122 {
1123 struct expression *arg;
1124 char *arg_name;
1125 int param;
1126
1127 param = 0;
1128 FOR_EACH_PTR(call->args, arg) {
1129 arg_name = sm_to_arg_name(arg, sm);
1130 if (arg_name) {
1131 *name = arg_name;
1132 return param;
1133 }
1134 param++;
1135 } END_FOR_EACH_PTR(arg);
1136
1137 *name = sm->name;
1138 return -2;
1139 }
1140
1141 static void match_call_info(struct expression *expr)
1142 {
1143 struct sm_state *sm;
1144 const char *param_name;
1145 int locked_type;
1146 int param;
1147
1148 FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
1149 param = get_caller_param_lock_name(expr, sm, &param_name);
1150 if (sm->state == &locked)
1151 locked_type = LOCKED;
1152 else if (sm->state == &half_locked ||
1153 slist_has_state(sm->possible, &locked))
1154 locked_type = HALF_LOCKED;
1155 else
1156 continue;
1157 sql_insert_caller_info(expr, locked_type, param, param_name, "xxx type");
1158
1159 } END_FOR_EACH_SM(sm);
1160 }
1161
1162 static void match_save_states(struct expression *expr)
1163 {
1164 push_stree(&saved_stack, start_states);
1165 start_states = NULL;
1166 }
1167
1168 static void match_restore_states(struct expression *expr)
1169 {
1170 start_states = pop_stree(&saved_stack);
1171 }
1172
1173 static void match_after_func(struct symbol *sym)
1174 {
1175 free_stree(&start_states);
1176 }
1177
1178 static void match_dma_resv_lock_NULL(const char *fn, struct expression *call_expr,
1179 struct expression *assign_expr, void *_index)
1180 {
1181 struct expression *lock, *ctx;
1182 char *lock_name;
1183 struct symbol *sym;
1184
1185 lock = get_argument_from_call_expr(call_expr->args, 0);
1186 ctx = get_argument_from_call_expr(call_expr->args, 1);
1187 if (!expr_is_zero(ctx))
1188 return;
1189
1190 lock_name = lock_to_name_sym(lock, &sym);
1191 if (!lock_name || !sym)
1192 goto free;
1193 do_lock(lock_name, sym, NULL);
1194 free:
1195 free_string(lock_name);
1196 }
1197
1198 /* print_held_locks() is used in check_call_tree.c */
1199 void print_held_locks(void)
1200 {
1201 struct stree *stree;
1202 struct sm_state *sm;
1203 int i = 0;
1204
1205 stree = __get_cur_stree();
1206 FOR_EACH_MY_SM(my_id, stree, sm) {
1207 if (sm->state != &locked)
1208 continue;
1209 if (i++)
1210 sm_printf(" ");
1211 sm_printf("'%s'", sm->name);
1212 } END_FOR_EACH_SM(sm);
1213 }
1214
1215 static bool is_smp_config(void)
1216 {
1217 struct ident *id;
1218
1219 id = built_in_ident("CONFIG_SMP");
1220 return !!lookup_symbol(id, NS_MACRO);
1221 }
1222
1223 void check_locking(int id)
1224 {
1225 my_id = id;
1226
1227 if (option_project != PROJ_KERNEL)
1228 return;
1229
1230 if (!is_smp_config())
1231 return;
1232
1233 load_table(lock_table);
1234
1235 set_dynamic_states(my_id);
1236 add_unmatched_state_hook(my_id, &unmatched_state);
1237 add_pre_merge_hook(my_id, &pre_merge_hook);
1238 add_merge_hook(my_id, &merge_func);
1239 add_modification_hook(my_id, &reset);
1240
1241 add_hook(&match_func_end, END_FUNC_HOOK);
1242
1243 add_hook(&match_after_func, AFTER_FUNC_HOOK);
1244 add_hook(&match_save_states, INLINE_FN_START);
1245 add_hook(&match_restore_states, INLINE_FN_END);
1246
1247 add_hook(&match_call_info, FUNCTION_CALL_HOOK);
1248
1249 add_split_return_callback(match_return_info);
1250 select_return_states_hook(LOCKED, &db_param_locked);
1251 select_return_states_hook(UNLOCKED, &db_param_unlocked);
1252 select_return_states_hook(LOCK_RESTORED, &db_param_restore);
1253
1254 return_implies_state("dma_resv_lock", -4095, -1, &match_dma_resv_lock_NULL, 0);
1255 }
Static analysis for C