Print this page
new smatch
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/tools/smatch/src/check_unwind.c
+++ new/usr/src/tools/smatch/src/check_unwind.c
1 1 /*
2 2 * Copyright (C) 2010 Dan Carpenter.
3 3 *
4 4 * This program is free software; you can redistribute it and/or
5 5 * modify it under the terms of the GNU General Public License
6 6 * as published by the Free Software Foundation; either version 2
7 7 * of the License, or (at your option) any later version.
8 8 *
9 9 * This program is distributed in the hope that it will be useful,
10 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 12 * GNU General Public License for more details.
13 13 *
14 14 * You should have received a copy of the GNU General Public License
15 15 * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
16 16 */
17 17
18 18 /*
19 19 * This is a kernel check to make sure we unwind everything on
20 20 * on errors.
21 21 *
22 22 */
23 23
24 24 #include "smatch.h"
25 25 #include "smatch_extra.h"
26 26 #include "smatch_slist.h"
27 27
28 28 #define EBUSY 16
29 29 #define MAX_ERRNO 4095
30 30
31 31 static int my_id;
32 32
33 33 STATE(allocated);
34 34 STATE(unallocated);
35 35
36 36 /* state of unwind function */
37 37 STATE(called);
38 38
39 39 static int was_passed_as_param(struct expression *expr)
40 40 {
41 41 char *name;
42 42 struct symbol *sym;
43 43 struct symbol *arg;
44 44
45 45 name = expr_to_var_sym(expr, &sym);
46 46 if (!name)
47 47 return 0;
48 48 free_string(name);
49 49
50 50 FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, arg) {
51 51 if (arg == sym)
52 52 return 1;
53 53 } END_FOR_EACH_PTR(arg);
54 54 return 0;
55 55 }
56 56
57 57 static void print_unwind_functions(const char *fn, struct expression *expr, void *_arg_no)
58 58 {
59 59 struct expression *arg_expr;
60 60 int arg_no = PTR_INT(_arg_no);
61 61 static struct symbol *last_printed = NULL;
62 62
63 63 arg_expr = get_argument_from_call_expr(expr->args, arg_no);
64 64 if (!was_passed_as_param(arg_expr))
65 65 return;
66 66 if (last_printed == cur_func_sym)
67 67 return;
68 68 last_printed = cur_func_sym;
69 69 sm_msg("info: is unwind function");
70 70 }
71 71
72 72 static void request_granted(const char *fn, struct expression *call_expr,
73 73 struct expression *assign_expr, void *_arg_no)
74 74 {
75 75 struct expression *arg_expr;
76 76 int arg_no = PTR_INT(_arg_no);
77 77
78 78 if (arg_no == -1) {
79 79 if (!assign_expr)
80 80 return;
81 81 arg_expr = assign_expr->left;
82 82 } else {
83 83 arg_expr = get_argument_from_call_expr(call_expr->args, arg_no);
84 84 }
85 85 set_state_expr(my_id, arg_expr, &allocated);
86 86 }
87 87
88 88 static void request_denied(const char *fn, struct expression *call_expr,
89 89 struct expression *assign_expr, void *_arg_no)
90 90 {
91 91 struct expression *arg_expr;
92 92 int arg_no = PTR_INT(_arg_no);
93 93
94 94 if (arg_no == -1) {
95 95 if (!assign_expr)
96 96 return;
97 97 arg_expr = assign_expr->left;
98 98 } else {
99 99 arg_expr = get_argument_from_call_expr(call_expr->args, arg_no);
100 100 }
101 101 set_state_expr(my_id, arg_expr, &unallocated);
102 102 }
103 103
104 104 static void match_release(const char *fn, struct expression *expr, void *_arg_no)
105 105 {
106 106 struct expression *arg_expr;
107 107 int arg_no = PTR_INT(_arg_no);
108 108
109 109 arg_expr = get_argument_from_call_expr(expr->args, arg_no);
110 110 if (get_state_expr(my_id, arg_expr))
111 111 set_state_expr(my_id, arg_expr, &unallocated);
112 112 set_equiv_state_expr(my_id, arg_expr, &unallocated);
113 113 }
114 114
115 115 static void match_unwind_function(const char *fn, struct expression *expr, void *unused)
116 116 {
117 117 set_state(my_id, "unwind_function", NULL, &called);
|
↓ open down ↓ |
117 lines elided |
↑ open up ↑ |
118 118 }
119 119
120 120 static int func_returns_int(void)
121 121 {
122 122 struct symbol *type;
123 123
124 124 type = get_base_type(cur_func_sym);
125 125 if (!type || type->type != SYM_FN)
126 126 return 0;
127 127 type = get_base_type(type);
128 - if (type->ctype.base_type == &int_type) {
128 + if (type && type->ctype.base_type == &int_type) {
129 129 return 1;
130 130 }
131 131 return 0;
132 132 }
133 133
134 134 static void match_return(struct expression *ret_value)
135 135 {
136 136 struct stree *stree;
137 137 struct sm_state *tmp;
138 138 sval_t sval;
139 139
140 140 if (!func_returns_int())
141 141 return;
142 142 if (get_value(ret_value, &sval) && sval_cmp_val(sval, 0) >= 0)
143 143 return;
144 144 if (!implied_not_equal(ret_value, 0))
145 145 return;
146 146 if (get_state(my_id, "unwind_function", NULL) == &called)
147 147 return;
148 148
149 149 stree = __get_cur_stree();
150 150 FOR_EACH_MY_SM(my_id, stree, tmp) {
151 151 if (slist_has_state(tmp->possible, &allocated))
152 152 sm_warning("'%s' was not released on error", tmp->name);
153 153 } END_FOR_EACH_SM(tmp);
154 154 }
155 155
156 156 static void register_unwind_functions(void)
157 157 {
158 158 struct token *token;
159 159 const char *func;
160 160
161 161 token = get_tokens_file("kernel.unwind_functions");
162 162 if (!token)
163 163 return;
164 164 if (token_type(token) != TOKEN_STREAMBEGIN)
165 165 return;
166 166 token = token->next;
167 167 while (token_type(token) != TOKEN_STREAMEND) {
168 168 if (token_type(token) != TOKEN_IDENT)
169 169 return;
170 170 func = show_ident(token->ident);
171 171 add_function_hook(func, &match_unwind_function, NULL);
172 172 token = token->next;
173 173 }
174 174 clear_token_alloc();
175 175 }
176 176
177 177 static void release_function_indicator(const char *name)
178 178 {
179 179 if (!option_info)
180 180 return;
181 181 add_function_hook(name, &print_unwind_functions, INT_PTR(0));
182 182 }
183 183
184 184 void check_unwind(int id)
185 185 {
186 186 if (option_project != PROJ_KERNEL || !option_spammy)
187 187 return;
188 188 my_id = id;
189 189
190 190 register_unwind_functions();
191 191
192 192 return_implies_state("request_resource", 0, 0, &request_granted, INT_PTR(1));
193 193 return_implies_state("request_resource", -EBUSY, -EBUSY, &request_denied, INT_PTR(1));
194 194 add_function_hook("release_resource", &match_release, INT_PTR(0));
195 195 release_function_indicator("release_resource");
196 196
197 197 return_implies_state_sval("__request_region", valid_ptr_min_sval, valid_ptr_max_sval, &request_granted, INT_PTR(1));
198 198 return_implies_state("__request_region", 0, 0, &request_denied, INT_PTR(1));
199 199 add_function_hook("__release_region", &match_release, INT_PTR(1));
200 200 release_function_indicator("__release_region");
201 201
202 202 return_implies_state_sval("ioremap", valid_ptr_min_sval, valid_ptr_max_sval, &request_granted, INT_PTR(-1));
203 203 return_implies_state("ioremap", 0, 0, &request_denied, INT_PTR(-1));
204 204 add_function_hook("iounmap", &match_release, INT_PTR(0));
205 205
206 206 return_implies_state_sval("pci_iomap", valid_ptr_min_sval, valid_ptr_max_sval, &request_granted, INT_PTR(-1));
207 207 return_implies_state("pci_iomap", 0, 0, &request_denied, INT_PTR(-1));
208 208 add_function_hook("pci_iounmap", &match_release, INT_PTR(1));
209 209 release_function_indicator("pci_iounmap");
210 210
211 211 return_implies_state_sval("__create_workqueue_key", valid_ptr_min_sval, valid_ptr_max_sval, &request_granted,
212 212 INT_PTR(-1));
213 213 return_implies_state("__create_workqueue_key", 0, 0, &request_denied, INT_PTR(-1));
214 214 add_function_hook("destroy_workqueue", &match_release, INT_PTR(0));
215 215
216 216 return_implies_state("request_irq", 0, 0, &request_granted, INT_PTR(0));
217 217 return_implies_state("request_irq", -MAX_ERRNO, -1, &request_denied, INT_PTR(0));
218 218 add_function_hook("free_irq", &match_release, INT_PTR(0));
219 219 release_function_indicator("free_irq");
220 220
221 221 return_implies_state("register_netdev", 0, 0, &request_granted, INT_PTR(0));
222 222 return_implies_state("register_netdev", -MAX_ERRNO, -1, &request_denied, INT_PTR(0));
223 223 add_function_hook("unregister_netdev", &match_release, INT_PTR(0));
224 224 release_function_indicator("unregister_netdev");
225 225
226 226 return_implies_state("misc_register", 0, 0, &request_granted, INT_PTR(0));
227 227 return_implies_state("misc_register", -MAX_ERRNO, -1, &request_denied, INT_PTR(0));
228 228 add_function_hook("misc_deregister", &match_release, INT_PTR(0));
229 229 release_function_indicator("misc_deregister");
230 230
231 231 add_hook(&match_return, RETURN_HOOK);
232 232 }
|
↓ open down ↓ |
94 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX