2 * Copyright (C) 2010 Dan Carpenter.
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 * This is kernel specific stuff for smatch_extra.
24 #include "smatch_slist.h"
25 #include "smatch_extra.h"
27 static int implied_err_cast_return(struct expression
*call
, void *unused
, struct range_list
**rl
)
29 struct expression
*arg
;
31 arg
= get_argument_from_call_expr(call
->args
, 0);
32 if (!get_implied_rl(arg
, rl
))
35 *rl
= cast_rl(get_type(call
), *rl
);
39 static void hack_ERR_PTR(struct symbol
*sym
)
42 struct smatch_state
*estate
;
43 struct range_list
*after
;
57 if (!sym
|| !sym
->ident
)
59 if (strcmp(sym
->ident
->name
, "ERR_PTR") != 0)
62 arg
= first_ptr_list((struct ptr_list
*)sym
->ctype
.base_type
->arguments
);
63 if (!arg
|| !arg
->ident
)
66 estate
= get_state(SMATCH_EXTRA
, arg
->ident
->name
, arg
);
68 after
= alloc_rl(low_error
, minus_one
);
70 after
= rl_intersection(estate_rl(estate
), alloc_rl(low_error
, zero
));
71 if (rl_equiv(estate_rl(estate
), after
))
74 set_state(SMATCH_EXTRA
, arg
->ident
->name
, arg
, alloc_estate_rl(after
));
77 static void match_param_valid_ptr(const char *fn
, struct expression
*call_expr
,
78 struct expression
*assign_expr
, void *_param
)
80 int param
= PTR_INT(_param
);
81 struct expression
*arg
;
82 struct smatch_state
*pre_state
;
83 struct smatch_state
*end_state
;
84 struct range_list
*rl
;
86 arg
= get_argument_from_call_expr(call_expr
->args
, param
);
87 pre_state
= get_state_expr(SMATCH_EXTRA
, arg
);
88 if (estate_rl(pre_state
)) {
89 rl
= estate_rl(pre_state
);
90 rl
= remove_range(rl
, ptr_null
, ptr_null
);
91 rl
= remove_range(rl
, ptr_err_min
, ptr_err_max
);
93 rl
= alloc_rl(valid_ptr_min_sval
, valid_ptr_max_sval
);
95 end_state
= alloc_estate_rl(rl
);
96 set_extra_expr_nomod(arg
, end_state
);
99 static void match_param_err_or_null(const char *fn
, struct expression
*call_expr
,
100 struct expression
*assign_expr
, void *_param
)
102 int param
= PTR_INT(_param
);
103 struct expression
*arg
;
104 struct range_list
*pre
, *rl
;
105 struct smatch_state
*pre_state
;
106 struct smatch_state
*end_state
;
108 arg
= get_argument_from_call_expr(call_expr
->args
, param
);
109 pre_state
= get_state_expr(SMATCH_EXTRA
, arg
);
111 pre
= estate_rl(pre_state
);
113 pre
= alloc_whole_rl(&ptr_ctype
);
114 call_results_to_rl(call_expr
, &ptr_ctype
, "0,(-4095)-(-1)", &rl
);
115 rl
= rl_intersection(pre
, rl
);
116 rl
= cast_rl(get_type(arg
), rl
);
117 end_state
= alloc_estate_rl(rl
);
118 set_extra_expr_nomod(arg
, end_state
);
121 static void match_not_err(const char *fn
, struct expression
*call_expr
,
122 struct expression
*assign_expr
, void *unused
)
124 struct expression
*arg
;
125 struct smatch_state
*pre_state
;
126 struct range_list
*rl
;
128 arg
= get_argument_from_call_expr(call_expr
->args
, 0);
129 pre_state
= get_state_expr(SMATCH_EXTRA
, arg
);
131 rl
= estate_rl(pre_state
);
132 rl
= remove_range(rl
, ptr_err_min
, ptr_err_max
);
134 rl
= alloc_rl(valid_ptr_min_sval
, valid_ptr_max_sval
);
136 rl
= cast_rl(get_type(arg
), rl
);
137 set_extra_expr_nomod(arg
, alloc_estate_rl(rl
));
140 static void match_err(const char *fn
, struct expression
*call_expr
,
141 struct expression
*assign_expr
, void *unused
)
143 struct expression
*arg
;
144 struct smatch_state
*pre_state
;
145 struct range_list
*rl
;
147 arg
= get_argument_from_call_expr(call_expr
->args
, 0);
148 pre_state
= get_state_expr(SMATCH_EXTRA
, arg
);
149 rl
= estate_rl(pre_state
);
151 rl
= alloc_rl(ptr_err_min
, ptr_err_max
);
152 rl
= rl_intersection(rl
, alloc_rl(ptr_err_min
, ptr_err_max
));
153 rl
= cast_rl(get_type(arg
), rl
);
154 set_extra_expr_nomod(arg
, alloc_estate_rl(rl
));
157 static void match_container_of_macro(const char *fn
, struct expression
*expr
, void *unused
)
159 set_extra_expr_mod(expr
->left
, alloc_estate_range(valid_ptr_min_sval
, valid_ptr_max_sval
));
162 static void match_container_of(struct expression
*expr
)
164 struct expression
*right
= expr
->right
;
168 * The problem here is that sometimes the container_of() macro is itself
169 * inside a macro and get_macro() only returns the name of the outside
174 * This actually an expression statement assignment but smatch_flow
175 * pre-mangles it for us so we only get the last chunk:
176 * sk = (typeof(sk))((char *)__mptr - offsetof(...))
179 macro
= get_macro_name(right
->pos
);
182 if (right
->type
!= EXPR_CAST
)
184 right
= strip_expr(right
);
185 if (right
->type
!= EXPR_BINOP
|| right
->op
!= '-' ||
186 right
->left
->type
!= EXPR_CAST
)
188 right
= strip_expr(right
->left
);
189 if (right
->type
!= EXPR_SYMBOL
)
191 if (!right
->symbol
->ident
||
192 strcmp(right
->symbol
->ident
->name
, "__mptr") != 0)
194 set_extra_expr_mod(expr
->left
, alloc_estate_range(valid_ptr_min_sval
, valid_ptr_max_sval
));
197 static int match_next_bit(struct expression
*call
, void *unused
, struct range_list
**rl
)
199 struct expression
*start_arg
;
200 struct expression
*size_arg
;
202 sval_t min
, max
, tmp
;
204 size_arg
= get_argument_from_call_expr(call
->args
, 1);
205 /* btw. there isn't a start_arg for find_first_bit() */
206 start_arg
= get_argument_from_call_expr(call
->args
, 2);
208 type
= get_type(call
);
209 min
= sval_type_val(type
, 0);
210 max
= sval_type_val(type
, sizeof(long long) * 8);
212 if (get_implied_max(size_arg
, &tmp
) && tmp
.uvalue
< max
.value
)
214 if (start_arg
&& get_implied_min(start_arg
, &tmp
) && !sval_is_negative(tmp
))
216 if (sval_cmp(min
, max
) > 0)
218 min
= sval_cast(type
, min
);
219 max
= sval_cast(type
, max
);
220 *rl
= alloc_rl(min
, max
);
224 static struct expression
*cast_to_ul(struct expression
*expr
)
228 type
= get_type(expr
);
231 if (type_positive_bits(type
) > type_positive_bits(&ulong_ctype
))
233 if (type_positive_bits(type
) == type_positive_bits(&ulong_ctype
))
236 return cast_expression(expr
, &ulong_ctype
);
239 static struct range_list
*do_size_op(struct range_list
*left
, int op
, struct range_list
*right
)
241 sval_t a_min
, b_min
, res_min
;
244 if (!sval_binop_overflows(rl_max(left
), op
, rl_max(right
)))
245 return rl_binop(left
, op
, right
);
248 if (sval_binop_overflows(rl_min(left
), op
, rl_min(right
)))
249 return alloc_rl(sval_type_max(&ulong_ctype
),
250 sval_type_max(&ulong_ctype
));
252 a_min
= rl_min(left
);
253 b_min
= rl_min(right
);
254 res_min
= sval_binop(a_min
, op
, b_min
);
256 return alloc_rl(res_min
, sval_type_max(&ulong_ctype
));
259 static bool match_size_op(struct expression
*call
, int op
, struct range_list
**rl
)
261 struct expression
*a
, *b
;
262 struct range_list
*a_rl
, *b_rl
;
264 a
= get_argument_from_call_expr(call
->args
, 0);
265 b
= get_argument_from_call_expr(call
->args
, 1);
269 get_absolute_rl(a
, &a_rl
);
270 get_absolute_rl(b
, &b_rl
);
272 *rl
= do_size_op(a_rl
, op
, b_rl
);
277 static int match_size_add(struct expression
*call
, void *unused
, struct range_list
**rl
)
279 return match_size_op(call
, '+', rl
);
282 static int match_size_mul(struct expression
*call
, void *unused
, struct range_list
**rl
)
284 return match_size_op(call
, '*', rl
);
287 static int match_ab_c_size(struct expression
*call
, void *unused
, struct range_list
**rl
)
289 struct expression
*a
, *b
, *c
;
290 struct range_list
*a_rl
, *b_rl
, *c_rl
, *ret
;
292 a
= get_argument_from_call_expr(call
->args
, 0);
293 b
= get_argument_from_call_expr(call
->args
, 1);
294 c
= get_argument_from_call_expr(call
->args
, 2);
300 get_absolute_rl(a
, &a_rl
);
301 get_absolute_rl(b
, &b_rl
);
302 get_absolute_rl(c
, &c_rl
);
304 ret
= do_size_op(a_rl
, '*', b_rl
);
305 ret
= do_size_op(ret
, '+', c_rl
);
312 static int match_array_size(struct expression
*call
, void *unused
, struct range_list
**rl
)
314 return match_size_mul(call
, NULL
, rl
);
317 static int match_ffs(struct expression
*call
, void *unused
, struct range_list
**rl
)
319 if (get_implied_rl(call
, rl
))
324 static int match_fls(struct expression
*call
, void *unused
, struct range_list
**rl
)
326 struct expression
*arg
;
327 struct range_list
*arg_rl
;
339 arg
= get_argument_from_call_expr(call
->args
, 0);
340 if (!get_implied_rl(arg
, &arg_rl
))
342 if (rl_to_sval(arg_rl
, &sval
)) {
345 for (i
= 63; i
>= 0; i
--) {
346 if (sval
.uvalue
& 1ULL << i
)
350 *rl
= alloc_rl(sval
, sval
);
353 zero
.type
= rl_type(arg_rl
);
354 if (!rl_has_sval(arg_rl
, zero
))
356 *rl
= alloc_rl(start
, end
);
360 static void find_module_init_exit(struct symbol_list
*sym_list
)
364 struct statement
*stmt
;
370 * This is more complicated because Sparse ignores the "alias"
371 * attribute. I search backwards because module_init() is normally at
372 * the end of the file.
375 FOR_EACH_PTR_REVERSE(sym_list
, sym
) {
376 if (sym
->type
!= SYM_NODE
)
378 if (!(sym
->ctype
.modifiers
& MOD_STATIC
))
380 fn
= get_base_type(sym
);
383 if (fn
->type
!= SYM_FN
)
387 if (!fn
->inline_stmt
)
389 if (strcmp(sym
->ident
->name
, "__inittest") == 0)
391 else if (strcmp(sym
->ident
->name
, "__exittest") == 0)
398 stmt
= first_ptr_list((struct ptr_list
*)fn
->inline_stmt
->stmts
);
399 if (!stmt
|| stmt
->type
!= STMT_RETURN
)
401 name
= expr_to_var(stmt
->ret_value
);
405 sql_insert_function_ptr(name
, "(struct module)->init");
407 sql_insert_function_ptr(name
, "(struct module)->exit");
411 } END_FOR_EACH_PTR_REVERSE(sym
);
414 static void match_end_file(struct symbol_list
*sym_list
)
418 /* find the last static symbol in the file */
419 FOR_EACH_PTR_REVERSE(sym_list
, sym
) {
420 if (!(sym
->ctype
.modifiers
& MOD_STATIC
))
424 find_module_init_exit(sym
->scope
->symbols
);
426 } END_FOR_EACH_PTR_REVERSE(sym
);
429 static struct expression
*get_val_expr(struct expression
*expr
)
431 struct symbol
*sym
, *val
;
433 if (expr
->type
!= EXPR_DEREF
)
436 if (expr
->type
!= EXPR_SYMBOL
)
438 if (strcmp(expr
->symbol_name
->name
, "__u") != 0)
440 sym
= get_base_type(expr
->symbol
);
441 val
= first_ptr_list((struct ptr_list
*)sym
->symbol_list
);
442 if (!val
|| strcmp(val
->ident
->name
, "__val") != 0)
444 return member_expression(expr
, '.', val
->ident
);
447 static void match__write_once_size(const char *fn
, struct expression
*call
,
450 struct expression
*dest
, *data
, *assign
;
451 struct range_list
*rl
;
453 dest
= get_argument_from_call_expr(call
->args
, 0);
454 if (dest
->type
!= EXPR_PREOP
|| dest
->op
!= '&')
456 dest
= strip_expr(dest
->unop
);
458 data
= get_argument_from_call_expr(call
->args
, 1);
459 data
= get_val_expr(data
);
462 get_absolute_rl(data
, &rl
);
463 assign
= assign_expression(dest
, '=', data
);
466 __split_expr(assign
);
470 static void match__read_once_size(const char *fn
, struct expression
*call
,
473 struct expression
*dest
, *data
, *assign
;
474 struct symbol
*type
, *val_sym
;
478 * __read_once_size_nocheck(&(x), __u.__c, sizeof(x));
479 * into a fake assignment:
484 data
= get_argument_from_call_expr(call
->args
, 0);
485 if (data
->type
!= EXPR_PREOP
|| data
->op
!= '&')
487 data
= strip_parens(data
->unop
);
489 dest
= get_argument_from_call_expr(call
->args
, 1);
490 if (dest
->type
!= EXPR_DEREF
|| dest
->op
!= '.')
492 if (!dest
->member
|| strcmp(dest
->member
->name
, "__c") != 0)
495 type
= get_type(dest
);
498 val_sym
= first_ptr_list((struct ptr_list
*)type
->symbol_list
);
499 dest
= member_expression(dest
, '.', val_sym
->ident
);
501 assign
= assign_expression(dest
, '=', data
);
503 __split_expr(assign
);
507 static void match_closure_call(const char *name
, struct expression
*call
,
510 struct expression
*cl
, *fn
, *fake_call
;
511 struct expression_list
*args
= NULL
;
513 cl
= get_argument_from_call_expr(call
->args
, 0);
514 fn
= get_argument_from_call_expr(call
->args
, 1);
518 add_ptr_list(&args
, cl
);
519 fake_call
= call_expression(fn
, args
);
520 __split_expr(fake_call
);
523 static void match_put_device(const char *name
, struct expression
*expr
,
526 static int refcount_id
;
527 struct expression
*data
, *fn
, *fake_call
;
528 struct expression_list
*args
= NULL
;
529 struct smatch_state
*state
;
534 refcount_id
= id_from_name("check_refcount_info");
536 if (expr
->type
!= EXPR_CALL
)
539 data
= get_argument_from_call_expr(expr
->args
, 0);
541 ref
= get_name_sym_from_param_key(expr
, 0, "$->kobj.kref.refcount.refs.counter", &sym
);
544 state
= get_state(refcount_id
, ref
, sym
);
545 if (state
&& strcmp(state
->name
, "inc") == 0)
548 release
= get_name_sym_from_param_key(expr
, 0, "$->release", NULL
);
549 fn
= get_assigned_expr_name_sym(release
, sym
);
552 if (fn
->type
== EXPR_PREOP
&& fn
->op
== '&')
553 fn
= strip_expr(fn
->unop
);
555 add_ptr_list(&args
, data
);
556 fake_call
= call_expression(fn
, args
);
557 __split_expr(fake_call
);
560 static void fix_msecs_to_jiffies(struct expression
*expr
)
562 struct expression
*arg
;
566 if (is_fake_var_assign(expr
) ||
568 expr
->right
->type
!= EXPR_CALL
)
570 if (!get_function() || strcmp(get_function(), "msecs_to_jiffies") != 0)
572 if (!__cur_stmt
|| __cur_stmt
->type
!= STMT_RETURN
)
575 arg
= get_argument_from_call_expr(expr
->right
->args
, 0);
576 if (!get_implied_value(arg
, &sval
))
579 if (!macro_to_ul("HZ", &HZ
))
582 ret
.type
= &ulong_ctype
;
583 ret
.value
= (sval
.value
+ (1000 / HZ
) - 1) / (1000 / HZ
);
585 set_extra_expr_mod(expr
->left
, alloc_estate_sval(ret
));
588 static void match_kernel_param(struct symbol
*sym
)
590 struct expression
*var
;
593 /* This was designed to parse the module_param_named() macro */
597 sym
->initializer
->type
!= EXPR_INITIALIZER
)
600 type
= get_real_base_type(sym
);
601 if (!type
|| type
->type
!= SYM_STRUCT
|| !type
->ident
)
603 if (strcmp(type
->ident
->name
, "kernel_param") != 0)
606 var
= last_ptr_list((struct ptr_list
*)sym
->initializer
->expr_list
);
607 if (!var
|| var
->type
!= EXPR_INITIALIZER
)
609 var
= first_ptr_list((struct ptr_list
*)var
->expr_list
);
610 if (!var
|| var
->type
!= EXPR_PREOP
|| var
->op
!= '&')
612 var
= strip_expr(var
->unop
);
614 type
= get_type(var
);
615 update_mtag_data(var
, alloc_estate_whole(type
));
618 bool is_ignored_kernel_data(const char *name
)
622 if (option_project
!= PROJ_KERNEL
)
626 * On the file I was looking at lockdep was 25% of the DB.
628 if (strstr(name
, ".dep_map."))
630 if (strstr(name
, "->dep_map."))
632 if (strstr(name
, ".lockdep_map."))
634 if (strstr(name
, "->lockdep_map."))
636 if (strstr(name
, "lock.dep_map."))
639 if (strstr(name
, ".rwsem."))
641 if (strstr(name
, "->rwsem."))
644 if (strstr(name
, "->mutex."))
646 if (strstr(name
, "->lockdep_mutex."))
649 if (strstr(name
, ".completion.wait."))
652 if (strstr(name
, "kobj.kset-"))
654 if (strstr(name
, "power.suspend_timer."))
656 if (strstr(name
, "power.work."))
658 if (strstr(name
, ".lock.rlock."))
660 if (strstr(name
, "lockdep_mutex."))
663 if (strstr(name
, ">klist_devices."))
666 if (strstr(name
, "->m_log->"))
669 if (strstr(name
, ".wait_lock."))
671 if (strstr(name
, "regmap->lock_arg"))
673 if (strstr(name
, "kworker->task"))
675 if (strstr(name
, "->algo_data->"))
677 if (strstr(name
, "->bio->bi_private"))
679 if (strstr(name
, "regmap->lock_arg"))
681 if (strstr(name
, "->regmap->bus_context"))
683 if (strstr(name
, "parent->parent"))
686 /* ignore mutex internals */
687 if ((p
= strstr(name
, ".rlock.")) ||
688 (p
= strstr(name
, ">rlock."))) {
690 if (strncmp(p
, "raw_lock", 8) == 0 ||
691 strcmp(p
, "owner") == 0 ||
692 strcmp(p
, "owner_cpu") == 0 ||
693 strcmp(p
, "magic") == 0 ||
694 strcmp(p
, "dep_map") == 0)
701 int get_gfp_param(struct expression
*expr
)
704 struct symbol
*arg
, *arg_type
;
707 if (expr
->type
!= EXPR_CALL
)
709 type
= get_type(expr
->fn
);
712 if (type
->type
== SYM_PTR
)
713 type
= get_real_base_type(type
);
714 if (type
->type
!= SYM_FN
)
718 FOR_EACH_PTR(type
->arguments
, arg
) {
719 arg_type
= get_base_type(arg
);
720 if (arg_type
&& arg_type
->ident
&&
721 strcmp(arg_type
->ident
->name
, "gfp_t") == 0)
724 } END_FOR_EACH_PTR(arg
);
729 static void match_function_def(struct symbol
*sym
)
733 macro
= get_macro_name(sym
->pos
);
736 if (strcmp(macro
, "TRACE_EVENT") == 0)
737 set_function_skipped();
740 static bool delete_pci_error_returns(struct expression
*expr
)
745 if (!get_value(expr
, &sval
))
747 if (sval
.value
< 0x80 || sval
.value
> 0x90)
750 macro
= get_macro_name(expr
->pos
);
754 if (strncmp(macro
, "PCIBIOS_", 8) != 0)
757 if (strcmp(macro
, "PCIBIOS_FUNC_NOT_SUPPORTED") == 0 ||
758 strcmp(macro
, "PCIBIOS_BAD_VENDOR_ID") == 0 ||
759 strcmp(macro
, "PCIBIOS_DEVICE_NOT_FOUND") == 0 ||
760 strcmp(macro
, "PCIBIOS_BAD_REGISTER_NUMBER") == 0 ||
761 strcmp(macro
, "PCIBIOS_SET_FAILED") == 0 ||
762 strcmp(macro
, "PCIBIOS_BUFFER_TOO_SMALL") == 0)
768 static bool match_with_intel_runtime(struct statement
*stmt
)
772 macro
= get_macro_name(stmt
->pos
);
775 if (strncmp(macro
, "with_intel_runtime", 18) == 0 ||
776 strncmp(macro
, "with_intel_display", 18) == 0)
781 void check_kernel(int id
)
783 if (option_project
!= PROJ_KERNEL
)
786 add_implied_return_hook("ERR_PTR", &implied_err_cast_return
, NULL
);
787 add_implied_return_hook("ERR_CAST", &implied_err_cast_return
, NULL
);
788 add_implied_return_hook("PTR_ERR", &implied_err_cast_return
, NULL
);
789 add_hook(hack_ERR_PTR
, AFTER_DEF_HOOK
);
790 return_implies_state("IS_ERR_OR_NULL", 0, 0, &match_param_valid_ptr
, (void *)0);
791 return_implies_state("IS_ERR_OR_NULL", 1, 1, &match_param_err_or_null
, (void *)0);
792 return_implies_state("IS_ERR", 0, 0, &match_not_err
, NULL
);
793 return_implies_state("IS_ERR", 1, 1, &match_err
, NULL
);
794 return_implies_state("tomoyo_memory_ok", 1, 1, &match_param_valid_ptr
, (void *)0);
796 add_macro_assign_hook_extra("container_of", &match_container_of_macro
, NULL
);
797 add_hook(match_container_of
, ASSIGNMENT_HOOK
);
799 add_implied_return_hook("find_next_bit", &match_next_bit
, NULL
);
800 add_implied_return_hook("find_next_zero_bit", &match_next_bit
, NULL
);
801 add_implied_return_hook("find_first_bit", &match_next_bit
, NULL
);
802 add_implied_return_hook("find_first_zero_bit", &match_next_bit
, NULL
);
804 add_implied_return_hook("size_add", &match_size_add
, NULL
);
805 add_implied_return_hook("size_mul", &match_size_mul
, NULL
);
806 add_implied_return_hook("__ab_c_size", &match_ab_c_size
, NULL
);
807 add_implied_return_hook("array_size", &match_array_size
, NULL
);
809 add_implied_return_hook("__ffs", &match_ffs
, NULL
);
810 add_implied_return_hook("fls", &match_fls
, NULL
);
811 add_implied_return_hook("__fls", &match_fls
, NULL
);
812 add_implied_return_hook("fls64", &match_fls
, NULL
);
814 add_function_hook("__ftrace_bad_type", &__match_nullify_path_hook
, NULL
);
815 add_function_hook("__write_once_size", &match__write_once_size
, NULL
);
817 add_function_hook("__read_once_size", &match__read_once_size
, NULL
);
818 add_function_hook("__read_once_size_nocheck", &match__read_once_size
, NULL
);
820 add_function_hook("closure_call", &match_closure_call
, NULL
);
821 add_function_hook("put_device", &match_put_device
, NULL
);
823 add_once_through_hook(&match_with_intel_runtime
);
825 add_hook(fix_msecs_to_jiffies
, ASSIGNMENT_HOOK_AFTER
);
826 add_hook(&match_kernel_param
, BASE_HOOK
);
827 add_hook(&match_function_def
, FUNC_DEF_HOOK
);
830 add_hook(match_end_file
, END_FILE_HOOK
);
832 add_delete_return_hook(&delete_pci_error_returns
);