2 * UBSAN error reporting functions
4 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
5 * Author: Andrey Ryabinin <ryabinin.a.a@gmail.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
13 #include <linux/bitops.h>
14 #include <linux/bug.h>
15 #include <linux/ctype.h>
16 #include <linux/init.h>
17 #include <linux/kernel.h>
18 #include <linux/types.h>
19 #include <linux/sched.h>
20 #include <linux/uaccess.h>
24 const char *type_check_kinds
[] = {
27 "reference binding to",
28 "member access within",
30 "constructor call on",
35 #define REPORTED_BIT 31
37 #if (BITS_PER_LONG == 64) && defined(__BIG_ENDIAN)
38 #define COLUMN_MASK (~(1U << REPORTED_BIT))
39 #define LINE_MASK (~0U)
41 #define COLUMN_MASK (~0U)
42 #define LINE_MASK (~(1U << REPORTED_BIT))
45 #define VALUE_LENGTH 40
47 static bool was_reported(struct source_location
*location
)
49 return test_and_set_bit(REPORTED_BIT
, &location
->reported
);
52 static void print_source_location(const char *prefix
,
53 struct source_location
*loc
)
55 pr_err("%s %s:%d:%d\n", prefix
, loc
->file_name
,
56 loc
->line
& LINE_MASK
, loc
->column
& COLUMN_MASK
);
59 static bool suppress_report(struct source_location
*loc
)
61 return current
->in_ubsan
|| was_reported(loc
);
64 static bool type_is_int(struct type_descriptor
*type
)
66 return type
->type_kind
== type_kind_int
;
69 static bool type_is_signed(struct type_descriptor
*type
)
71 WARN_ON(!type_is_int(type
));
72 return type
->type_info
& 1;
75 static unsigned type_bit_width(struct type_descriptor
*type
)
77 return 1 << (type
->type_info
>> 1);
80 static bool is_inline_int(struct type_descriptor
*type
)
82 unsigned inline_bits
= sizeof(unsigned long)*8;
83 unsigned bits
= type_bit_width(type
);
85 WARN_ON(!type_is_int(type
));
87 return bits
<= inline_bits
;
90 static s_max
get_signed_val(struct type_descriptor
*type
, void *val
)
92 if (is_inline_int(type
)) {
93 unsigned extra_bits
= sizeof(s_max
)*8 - type_bit_width(type
);
94 unsigned long ulong_val
= (unsigned long)val
;
96 return ((s_max
)ulong_val
) << extra_bits
>> extra_bits
;
99 if (type_bit_width(type
) == 64)
102 return *(s_max
*)val
;
105 static bool val_is_negative(struct type_descriptor
*type
, void *val
)
107 return type_is_signed(type
) && get_signed_val(type
, val
) < 0;
110 static u_max
get_unsigned_val(struct type_descriptor
*type
, void *val
)
112 if (is_inline_int(type
))
113 return (unsigned long)val
;
115 if (type_bit_width(type
) == 64)
118 return *(u_max
*)val
;
121 static void val_to_string(char *str
, size_t size
, struct type_descriptor
*type
,
124 if (type_is_int(type
)) {
125 if (type_bit_width(type
) == 128) {
126 #if defined(CONFIG_ARCH_SUPPORTS_INT128) && defined(__SIZEOF_INT128__)
127 u_max val
= get_unsigned_val(type
, value
);
129 scnprintf(str
, size
, "0x%08x%08x%08x%08x",
137 } else if (type_is_signed(type
)) {
138 scnprintf(str
, size
, "%lld",
139 (s64
)get_signed_val(type
, value
));
141 scnprintf(str
, size
, "%llu",
142 (u64
)get_unsigned_val(type
, value
));
147 static DEFINE_SPINLOCK(report_lock
);
149 static void ubsan_prologue(struct source_location
*location
,
150 unsigned long *flags
)
153 spin_lock_irqsave(&report_lock
, *flags
);
155 pr_err("========================================"
156 "========================================\n");
157 print_source_location("UBSAN: Undefined behaviour in", location
);
160 static void ubsan_epilogue(unsigned long *flags
)
163 pr_err("========================================"
164 "========================================\n");
165 spin_unlock_irqrestore(&report_lock
, *flags
);
169 static void handle_overflow(struct overflow_data
*data
, void *lhs
,
173 struct type_descriptor
*type
= data
->type
;
175 char lhs_val_str
[VALUE_LENGTH
];
176 char rhs_val_str
[VALUE_LENGTH
];
178 if (suppress_report(&data
->location
))
181 ubsan_prologue(&data
->location
, &flags
);
183 val_to_string(lhs_val_str
, sizeof(lhs_val_str
), type
, lhs
);
184 val_to_string(rhs_val_str
, sizeof(rhs_val_str
), type
, rhs
);
185 pr_err("%s integer overflow:\n",
186 type_is_signed(type
) ? "signed" : "unsigned");
187 pr_err("%s %c %s cannot be represented in type %s\n",
193 ubsan_epilogue(&flags
);
196 void __ubsan_handle_add_overflow(struct overflow_data
*data
,
197 void *lhs
, void *rhs
)
200 handle_overflow(data
, lhs
, rhs
, '+');
202 EXPORT_SYMBOL(__ubsan_handle_add_overflow
);
204 void __ubsan_handle_sub_overflow(struct overflow_data
*data
,
205 void *lhs
, void *rhs
)
207 handle_overflow(data
, lhs
, rhs
, '-');
209 EXPORT_SYMBOL(__ubsan_handle_sub_overflow
);
211 void __ubsan_handle_mul_overflow(struct overflow_data
*data
,
212 void *lhs
, void *rhs
)
214 handle_overflow(data
, lhs
, rhs
, '*');
216 EXPORT_SYMBOL(__ubsan_handle_mul_overflow
);
218 void __ubsan_handle_negate_overflow(struct overflow_data
*data
,
222 char old_val_str
[VALUE_LENGTH
];
224 if (suppress_report(&data
->location
))
227 ubsan_prologue(&data
->location
, &flags
);
229 val_to_string(old_val_str
, sizeof(old_val_str
), data
->type
, old_val
);
231 pr_err("negation of %s cannot be represented in type %s:\n",
232 old_val_str
, data
->type
->type_name
);
234 ubsan_epilogue(&flags
);
236 EXPORT_SYMBOL(__ubsan_handle_negate_overflow
);
239 void __ubsan_handle_divrem_overflow(struct overflow_data
*data
,
240 void *lhs
, void *rhs
)
243 char rhs_val_str
[VALUE_LENGTH
];
245 if (suppress_report(&data
->location
))
248 ubsan_prologue(&data
->location
, &flags
);
250 val_to_string(rhs_val_str
, sizeof(rhs_val_str
), data
->type
, rhs
);
252 if (type_is_signed(data
->type
) && get_signed_val(data
->type
, rhs
) == -1)
253 pr_err("division of %s by -1 cannot be represented in type %s\n",
254 rhs_val_str
, data
->type
->type_name
);
256 pr_err("division by zero\n");
258 ubsan_epilogue(&flags
);
260 EXPORT_SYMBOL(__ubsan_handle_divrem_overflow
);
262 static void handle_null_ptr_deref(struct type_mismatch_data_common
*data
)
266 if (suppress_report(data
->location
))
269 ubsan_prologue(data
->location
, &flags
);
271 pr_err("%s null pointer of type %s\n",
272 type_check_kinds
[data
->type_check_kind
],
273 data
->type
->type_name
);
275 ubsan_epilogue(&flags
);
278 static void handle_misaligned_access(struct type_mismatch_data_common
*data
,
283 if (suppress_report(data
->location
))
286 ubsan_prologue(data
->location
, &flags
);
288 pr_err("%s misaligned address %p for type %s\n",
289 type_check_kinds
[data
->type_check_kind
],
290 (void *)ptr
, data
->type
->type_name
);
291 pr_err("which requires %ld byte alignment\n", data
->alignment
);
293 ubsan_epilogue(&flags
);
296 static void handle_object_size_mismatch(struct type_mismatch_data_common
*data
,
301 if (suppress_report(data
->location
))
304 ubsan_prologue(data
->location
, &flags
);
305 pr_err("%s address %p with insufficient space\n",
306 type_check_kinds
[data
->type_check_kind
],
308 pr_err("for an object of type %s\n", data
->type
->type_name
);
309 ubsan_epilogue(&flags
);
312 static void ubsan_type_mismatch_common(struct type_mismatch_data_common
*data
,
315 unsigned long flags
= user_access_save();
318 handle_null_ptr_deref(data
);
319 else if (data
->alignment
&& !IS_ALIGNED(ptr
, data
->alignment
))
320 handle_misaligned_access(data
, ptr
);
322 handle_object_size_mismatch(data
, ptr
);
324 user_access_restore(flags
);
327 void __ubsan_handle_type_mismatch(struct type_mismatch_data
*data
,
330 struct type_mismatch_data_common common_data
= {
331 .location
= &data
->location
,
333 .alignment
= data
->alignment
,
334 .type_check_kind
= data
->type_check_kind
337 ubsan_type_mismatch_common(&common_data
, (unsigned long)ptr
);
339 EXPORT_SYMBOL(__ubsan_handle_type_mismatch
);
341 void __ubsan_handle_type_mismatch_v1(struct type_mismatch_data_v1
*data
,
345 struct type_mismatch_data_common common_data
= {
346 .location
= &data
->location
,
348 .alignment
= 1UL << data
->log_alignment
,
349 .type_check_kind
= data
->type_check_kind
352 ubsan_type_mismatch_common(&common_data
, (unsigned long)ptr
);
354 EXPORT_SYMBOL(__ubsan_handle_type_mismatch_v1
);
356 void __ubsan_handle_out_of_bounds(struct out_of_bounds_data
*data
, void *index
)
359 char index_str
[VALUE_LENGTH
];
361 if (suppress_report(&data
->location
))
364 ubsan_prologue(&data
->location
, &flags
);
366 val_to_string(index_str
, sizeof(index_str
), data
->index_type
, index
);
367 pr_err("index %s is out of range for type %s\n", index_str
,
368 data
->array_type
->type_name
);
369 ubsan_epilogue(&flags
);
371 EXPORT_SYMBOL(__ubsan_handle_out_of_bounds
);
373 void __ubsan_handle_shift_out_of_bounds(struct shift_out_of_bounds_data
*data
,
374 void *lhs
, void *rhs
)
377 struct type_descriptor
*rhs_type
= data
->rhs_type
;
378 struct type_descriptor
*lhs_type
= data
->lhs_type
;
379 char rhs_str
[VALUE_LENGTH
];
380 char lhs_str
[VALUE_LENGTH
];
382 if (suppress_report(&data
->location
))
385 ubsan_prologue(&data
->location
, &flags
);
387 val_to_string(rhs_str
, sizeof(rhs_str
), rhs_type
, rhs
);
388 val_to_string(lhs_str
, sizeof(lhs_str
), lhs_type
, lhs
);
390 if (val_is_negative(rhs_type
, rhs
))
391 pr_err("shift exponent %s is negative\n", rhs_str
);
393 else if (get_unsigned_val(rhs_type
, rhs
) >=
394 type_bit_width(lhs_type
))
395 pr_err("shift exponent %s is too large for %u-bit type %s\n",
397 type_bit_width(lhs_type
),
398 lhs_type
->type_name
);
399 else if (val_is_negative(lhs_type
, lhs
))
400 pr_err("left shift of negative value %s\n",
403 pr_err("left shift of %s by %s places cannot be"
404 " represented in type %s\n",
406 lhs_type
->type_name
);
408 ubsan_epilogue(&flags
);
410 EXPORT_SYMBOL(__ubsan_handle_shift_out_of_bounds
);
413 void __ubsan_handle_builtin_unreachable(struct unreachable_data
*data
)
417 ubsan_prologue(&data
->location
, &flags
);
418 pr_err("calling __builtin_unreachable()\n");
419 ubsan_epilogue(&flags
);
420 panic("can't return from __builtin_unreachable()");
422 EXPORT_SYMBOL(__ubsan_handle_builtin_unreachable
);
424 void __ubsan_handle_load_invalid_value(struct invalid_value_data
*data
,
428 char val_str
[VALUE_LENGTH
];
430 if (suppress_report(&data
->location
))
433 ubsan_prologue(&data
->location
, &flags
);
435 val_to_string(val_str
, sizeof(val_str
), data
->type
, val
);
437 pr_err("load of value %s is not a valid value for type %s\n",
438 val_str
, data
->type
->type_name
);
440 ubsan_epilogue(&flags
);
442 EXPORT_SYMBOL(__ubsan_handle_load_invalid_value
);