2 * Copyright (C) 2018 Oracle.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
19 #include "smatch_slist.h"
23 GLOBAL_STATE(unit_bit
);
24 GLOBAL_STATE(unit_byte
);
25 GLOBAL_STATE(unit_array_size
);
26 GLOBAL_STATE(unit_long
);
27 GLOBAL_STATE(unit_page
);
28 GLOBAL_STATE(unit_msec
);
29 GLOBAL_STATE(unit_ns
);
30 GLOBAL_STATE(unit_jiffy
);
40 static struct type_info func_table
[] = {
41 { "unit_msecs_to_jiffies_timeout", UNITS
, -1, "$", "unit_jiffy" },
42 { "round_jiffies_up_relative", UNITS
, -1, "$", "unit_jiffy" },
45 static struct smatch_state
*str_to_units(const char *str
)
50 if (strcmp(str
, "unit_bit") == 0)
52 if (strcmp(str
, "unit_byte") == 0)
54 if (strcmp(str
, "unit_page") == 0)
56 if (strcmp(str
, "unit_msec") == 0)
58 if (strcmp(str
, "unit_jiffy") == 0)
60 if (strcmp(str
, "unit_long") == 0)
62 if (strcmp(str
, "unit_array_size") == 0)
63 return &unit_array_size
;
64 if (strcmp(str
, "unknown") == 0)
70 static struct smatch_state
*get_units_from_type(struct expression
*expr
);
72 static struct smatch_state
*merge_units(struct smatch_state
*s1
, struct smatch_state
*s2
)
81 static bool is_ignored_type(char *name
)
85 if (strcmp(name
, "(union anonymous)->__val") == 0)
87 if (strncmp(name
, "(struct fs_parse_result)", 24) == 0)
92 static void store_type_in_db(struct expression
*expr
, struct smatch_state
*state
)
96 member
= get_member_name(expr
);
99 if (is_ignored_type(member
))
102 sql_insert_cache(type_info
, "0x%llx, %d, '%s', '%s'", get_base_file_id(), UNITS
, member
, state
->name
);
105 static void set_units(struct expression
*expr
, struct smatch_state
*state
)
110 set_state_expr(my_id
, expr
, state
);
111 store_type_in_db(expr
, state
);
114 static bool is_PAGE_SHIFT(struct expression
*expr
)
118 macro
= get_macro_name(expr
->pos
);
119 if (macro
&& strcmp(macro
, "PAGE_SHIFT") == 0)
124 static bool is_PAGE_SIZE(struct expression
*expr
)
128 macro
= get_macro_name(expr
->pos
);
129 if (macro
&& strcmp(macro
, "PAGE_SIZE") == 0)
134 static bool is_BITS_PER_LONG(struct expression
*expr
)
138 macro
= get_macro_name(expr
->pos
);
139 if (macro
&& strcmp(macro
, "BITS_PER_LONG") == 0)
144 static struct smatch_state
*binop_helper(struct expression
*left
, int op
, struct expression
*right
)
146 struct smatch_state
*left_state
, *right_state
;
151 // subtracting pointers gives unit_byte
154 left_state
= get_units(left
);
155 right_state
= get_units(right
);
156 if (left_state
== &unit_array_size
||
157 right_state
== &unit_array_size
)
160 return left_state
? left_state
: right_state
;
162 /* FIXME: A multiply is almost always bytes but it can be bits. */
163 if (is_PAGE_SIZE(right
))
165 if (!get_implied_value(right
, &val
))
167 /* 4096 is almost always a unit_page -> bytes converstion */
168 if (val
.value
== 4096)
172 if (is_BITS_PER_LONG(right
))
174 if (is_PAGE_SIZE(right
))
176 if (!get_implied_value(right
, &val
))
178 if (val
.value
== 4096)
181 case SPECIAL_LEFTSHIFT
:
182 if (is_PAGE_SHIFT(right
))
185 case SPECIAL_RIGHTSHIFT
:
186 if (is_PAGE_SHIFT(right
))
193 static struct smatch_state
*get_units_binop(struct expression
*expr
)
195 return binop_helper(expr
->left
, expr
->op
, expr
->right
);
198 static struct smatch_state
*get_units_call(struct expression
*expr
)
200 expr
= strip_expr(expr
);
201 if (!expr
|| expr
->type
!= EXPR_CALL
)
204 if (sym_name_is("unit_msecs_to_jiffies", expr
->fn
))
206 if (sym_name_is("jiffies_to_unit_msecs", expr
->fn
))
212 static int db_units(void *_units
, int argc
, char **argv
, char **azColName
)
214 char **units
= _units
;
217 if (strcmp(*units
, argv
[0]) == 0)
220 *units
= alloc_string("unknown");
224 *units
= alloc_string(argv
[0]);
228 static struct smatch_state
*get_units_from_type(struct expression
*expr
)
232 struct smatch_state
*ret
= NULL
;
234 member
= get_member_name(expr
);
237 if (strcmp(member
, "(struct vm_area_struct)->vm_pgoff") == 0)
239 cache_sql(&db_units
, &units
, "select value from type_info where type = %d and key = '%s';",
241 run_sql(&db_units
, &units
, "select value from type_info where type = %d and key = '%s';",
247 ret
= str_to_units(units
);
254 struct smatch_state
*get_units(struct expression
*expr
)
256 struct smatch_state
*state
;
259 expr
= strip_expr(expr
);
263 if (expr
->type
== EXPR_PTRSIZEOF
||
264 expr
->type
== EXPR_SIZEOF
)
267 ident
= pos_ident(expr
->pos
);
269 if (strcmp(ident
, "sizeof") == 0 ||
270 strcmp(ident
, "PAGE_SIZE") == 0)
272 if (strcmp(ident
, "jiffies") == 0)
274 if (strcmp(ident
, "BITS_PER_LONG") == 0)
276 if (strcmp(ident
, "BITS_PER_LONG_LONG") == 0)
278 if (strcmp(ident
, "ARRAY_SIZE") == 0)
279 return &unit_array_size
;
282 if (expr
->type
== EXPR_BINOP
)
283 return get_units_binop(expr
);
285 if (expr
->type
== EXPR_CALL
)
286 return get_units_call(expr
);
288 state
= get_state_expr(my_id
, expr
);
289 if (state
== &merged
|| state
== &undefined
)
294 return get_units_from_type(expr
);
297 bool is_array_size_units(struct expression
*expr
)
299 return get_units(expr
) == &unit_array_size
;
302 static void match_allocation(struct expression
*expr
,
303 const char *name
, struct symbol
*sym
,
304 struct allocation_info
*info
)
306 struct expression
*right
, *left
;
308 if (info
->nr_elems
&& info
->elem_size
) {
309 left
= info
->nr_elems
;
310 right
= info
->elem_size
;
311 } else if (info
->total_size
&&
312 info
->total_size
->type
== EXPR_BINOP
&&
313 info
->total_size
->op
== '*') {
314 left
= strip_expr(info
->total_size
->left
);
315 right
= strip_expr(info
->total_size
->right
);
320 if (get_units(left
) == &unit_byte
)
321 set_units(right
, &unit_array_size
);
322 if (get_units(right
) == &unit_byte
)
323 set_units(left
, &unit_array_size
);
326 static void match_binop_set(struct expression
*expr
)
328 struct smatch_state
*left
, *right
;
331 if (expr
->op
== SPECIAL_LEFTSHIFT
&& is_PAGE_SHIFT(expr
->right
)) {
332 set_units(expr
->left
, &unit_page
);
336 if (expr
->op
== SPECIAL_RIGHTSHIFT
&& is_PAGE_SHIFT(expr
->right
)) {
337 set_units(expr
->left
, &unit_byte
);
341 if (expr
->op
!= '+' && expr
->op
!= '-')
344 type
= get_type(expr
->left
);
345 if (type
&& (type
->type
== SYM_PTR
|| type
->type
== SYM_ARRAY
))
348 left
= get_units(expr
->left
);
349 right
= get_units(expr
->right
);
352 set_units(expr
->right
, left
);
354 set_units(expr
->left
, right
);
357 static void match_condition_set(struct expression
*expr
)
359 struct smatch_state
*left
, *right
;
361 if (expr
->type
!= EXPR_COMPARE
)
364 left
= get_units(expr
->left
);
365 right
= get_units(expr
->right
);
368 set_units(expr
->right
, left
);
370 set_units(expr
->left
, right
);
373 static void match_assign(struct expression
*expr
)
375 struct smatch_state
*state
= NULL
;
377 if (__in_fake_assign
)
382 state
= get_units(expr
->right
);
384 case SPECIAL_SHR_ASSIGN
:
385 case SPECIAL_SHL_ASSIGN
:
386 case SPECIAL_DIV_ASSIGN
:
387 case SPECIAL_MUL_ASSIGN
:
388 state
= binop_helper(expr
->left
, op_remove_assign(expr
->op
),
393 set_units(expr
->left
, state
);
395 // clear_units(expr->left);
398 static void set_implied_units(struct expression
*call
, struct expression
*arg
, char *key
, char *value
)
400 struct smatch_state
*state
;
404 state
= str_to_units(value
);
407 name
= get_variable_from_key(arg
, key
, &sym
);
410 set_state(my_id
, name
, sym
, state
);
415 static void set_param_units(const char *name
, struct symbol
*sym
, char *key
, char *value
)
417 struct smatch_state
*state
;
419 state
= str_to_units(value
);
422 set_state(my_id
, sym
->ident
->name
, sym
, state
);
425 static void set_param_units_from_table(struct expression
*expr
, const char *name
, struct symbol
*sym
, void *data
)
427 const char *value
= data
;
428 struct smatch_state
*state
;
430 state
= str_to_units(value
);
433 set_state(my_id
, name
, sym
, state
);
436 static void match_call_info(struct expression
*expr
)
438 struct expression
*arg
;
439 struct smatch_state
*state
;
443 if (expr
->fn
->type
!= EXPR_SYMBOL
)
445 fn_name
= expr_to_var(expr
->fn
);
449 FOR_EACH_PTR(expr
->args
, arg
) {
451 state
= get_units(arg
);
454 // sql_insert_cache(return_implies, "0x%llx, '%s', 0, %d, %d, %d, '%s', '%s'",
455 // get_base_file_id(), fn_name, is_static(expr->fn), UNITS, param, "$", state->name);
456 sql_insert_caller_info(expr
, UNITS
, param
, "$", state
->name
);
458 } END_FOR_EACH_PTR(arg
);
460 free_string(fn_name
);
463 static void process_states(void)
466 struct smatch_state
*state
, *start_state
;
469 FOR_EACH_PTR(cur_func_sym
->ctype
.base_type
->arguments
, arg
) {
471 state
= get_state(my_id
, arg
->ident
->name
, arg
);
472 if (!state
|| state
== &merged
|| state
== &undefined
)
474 start_state
= get_state_stree(get_start_states(), my_id
, arg
->ident
->name
, arg
);
475 if (state
== start_state
)
477 sql_insert_cache(return_implies
, "0x%llx, '%s', 0, %d, %d, %d, '%s', '%s'",
478 get_base_file_id(), get_function(), fn_static(), UNITS
, param
, "$", state
->name
);
479 } END_FOR_EACH_PTR(arg
);
482 char *get_unit_str(struct expression
*expr
)
484 struct smatch_state
*state
;
486 state
= get_units(expr
);
489 return (char *)state
->name
;
492 void register_units(int id
)
494 struct type_info
*info
;
499 for (i
= 0; i
< ARRAY_SIZE(func_table
); i
++) {
500 info
= &func_table
[i
];
501 add_function_param_key_hook(info
->name
,
502 set_param_units_from_table
,
503 info
->param
, info
->key
,
504 (void *)info
->value
);
507 add_merge_hook(my_id
, &merge_units
);
509 add_hook(&match_binop_set
, BINOP_HOOK
);
510 add_hook(&match_condition_set
, CONDITION_HOOK
);
511 add_hook(&match_assign
, ASSIGNMENT_HOOK
);
512 add_hook(&match_call_info
, FUNCTION_CALL_HOOK
);
513 all_return_states_hook(&process_states
);
515 select_return_implies_hook(UNITS
, &set_implied_units
);
516 select_caller_info_hook(&set_param_units
, UNITS
);
518 add_allocation_hook(&match_allocation
);