Thomas Gleixner | d2912cb | 2019-06-04 10:11:33 +0200 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-only |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 2 | /* |
| 3 | * UBSAN error reporting functions |
| 4 | * |
| 5 | * Copyright (c) 2014 Samsung Electronics Co., Ltd. |
| 6 | * Author: Andrey Ryabinin <ryabinin.a.a@gmail.com> |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 7 | */ |
| 8 | |
| 9 | #include <linux/bitops.h> |
| 10 | #include <linux/bug.h> |
| 11 | #include <linux/ctype.h> |
| 12 | #include <linux/init.h> |
| 13 | #include <linux/kernel.h> |
| 14 | #include <linux/types.h> |
| 15 | #include <linux/sched.h> |
Peter Zijlstra | d08965a | 2019-04-03 09:40:16 +0200 | [diff] [blame] | 16 | #include <linux/uaccess.h> |
Kees Cook | 25b8400 | 2023-02-02 22:07:49 +0000 | [diff] [blame] | 17 | #include <linux/ubsan.h> |
Uriel Guajardo | 1195505 | 2021-04-02 14:21:31 -0700 | [diff] [blame] | 18 | #include <kunit/test-bug.h> |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 19 | |
| 20 | #include "ubsan.h" |
| 21 | |
Kees Cook | 25b8400 | 2023-02-02 22:07:49 +0000 | [diff] [blame] | 22 | #ifdef CONFIG_UBSAN_TRAP |
| 23 | /* |
| 24 | * Only include matches for UBSAN checks that are actually compiled in. |
| 25 | * The mappings of struct SanitizerKind (the -fsanitize=xxx args) to |
| 26 | * enum SanitizerHandler (the traps) in Clang is in clang/lib/CodeGen/. |
| 27 | */ |
| 28 | const char *report_ubsan_failure(struct pt_regs *regs, u32 check_type) |
| 29 | { |
| 30 | switch (check_type) { |
| 31 | #ifdef CONFIG_UBSAN_BOUNDS |
| 32 | /* |
| 33 | * SanitizerKind::ArrayBounds and SanitizerKind::LocalBounds |
| 34 | * emit SanitizerHandler::OutOfBounds. |
| 35 | */ |
| 36 | case ubsan_out_of_bounds: |
| 37 | return "UBSAN: array index out of bounds"; |
| 38 | #endif |
| 39 | #ifdef CONFIG_UBSAN_SHIFT |
| 40 | /* |
| 41 | * SanitizerKind::ShiftBase and SanitizerKind::ShiftExponent |
| 42 | * emit SanitizerHandler::ShiftOutOfBounds. |
| 43 | */ |
| 44 | case ubsan_shift_out_of_bounds: |
| 45 | return "UBSAN: shift out of bounds"; |
| 46 | #endif |
Kees Cook | f4626c1 | 2024-04-15 11:28:35 -0700 | [diff] [blame] | 47 | #if defined(CONFIG_UBSAN_DIV_ZERO) || defined(CONFIG_UBSAN_SIGNED_WRAP) |
Kees Cook | 25b8400 | 2023-02-02 22:07:49 +0000 | [diff] [blame] | 48 | /* |
Kees Cook | f4626c1 | 2024-04-15 11:28:35 -0700 | [diff] [blame] | 49 | * SanitizerKind::IntegerDivideByZero and |
| 50 | * SanitizerKind::SignedIntegerOverflow emit |
Kees Cook | 25b8400 | 2023-02-02 22:07:49 +0000 | [diff] [blame] | 51 | * SanitizerHandler::DivremOverflow. |
| 52 | */ |
| 53 | case ubsan_divrem_overflow: |
| 54 | return "UBSAN: divide/remainder overflow"; |
| 55 | #endif |
| 56 | #ifdef CONFIG_UBSAN_UNREACHABLE |
| 57 | /* |
| 58 | * SanitizerKind::Unreachable emits |
| 59 | * SanitizerHandler::BuiltinUnreachable. |
| 60 | */ |
| 61 | case ubsan_builtin_unreachable: |
| 62 | return "UBSAN: unreachable code"; |
| 63 | #endif |
| 64 | #if defined(CONFIG_UBSAN_BOOL) || defined(CONFIG_UBSAN_ENUM) |
| 65 | /* |
| 66 | * SanitizerKind::Bool and SanitizerKind::Enum emit |
| 67 | * SanitizerHandler::LoadInvalidValue. |
| 68 | */ |
| 69 | case ubsan_load_invalid_value: |
| 70 | return "UBSAN: loading invalid value"; |
| 71 | #endif |
| 72 | #ifdef CONFIG_UBSAN_ALIGNMENT |
| 73 | /* |
| 74 | * SanitizerKind::Alignment emits SanitizerHandler::TypeMismatch |
| 75 | * or SanitizerHandler::AlignmentAssumption. |
| 76 | */ |
| 77 | case ubsan_alignment_assumption: |
| 78 | return "UBSAN: alignment assumption"; |
| 79 | case ubsan_type_mismatch: |
| 80 | return "UBSAN: type mismatch"; |
| 81 | #endif |
Kees Cook | f4626c1 | 2024-04-15 11:28:35 -0700 | [diff] [blame] | 82 | #ifdef CONFIG_UBSAN_SIGNED_WRAP |
| 83 | /* |
| 84 | * SanitizerKind::SignedIntegerOverflow emits |
| 85 | * SanitizerHandler::AddOverflow, SanitizerHandler::SubOverflow, |
| 86 | * or SanitizerHandler::MulOverflow. |
| 87 | */ |
| 88 | case ubsan_add_overflow: |
| 89 | return "UBSAN: integer addition overflow"; |
| 90 | case ubsan_sub_overflow: |
| 91 | return "UBSAN: integer subtraction overflow"; |
| 92 | case ubsan_mul_overflow: |
| 93 | return "UBSAN: integer multiplication overflow"; |
| 94 | #endif |
Kees Cook | 25b8400 | 2023-02-02 22:07:49 +0000 | [diff] [blame] | 95 | default: |
| 96 | return "UBSAN: unrecognized failure code"; |
| 97 | } |
| 98 | } |
| 99 | |
| 100 | #else |
Zou Wei | d3c2279 | 2020-12-15 20:46:50 -0800 | [diff] [blame] | 101 | static const char * const type_check_kinds[] = { |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 102 | "load of", |
| 103 | "store to", |
| 104 | "reference binding to", |
| 105 | "member access within", |
| 106 | "member call on", |
| 107 | "constructor call on", |
| 108 | "downcast of", |
| 109 | "downcast of" |
| 110 | }; |
| 111 | |
| 112 | #define REPORTED_BIT 31 |
| 113 | |
| 114 | #if (BITS_PER_LONG == 64) && defined(__BIG_ENDIAN) |
| 115 | #define COLUMN_MASK (~(1U << REPORTED_BIT)) |
| 116 | #define LINE_MASK (~0U) |
| 117 | #else |
| 118 | #define COLUMN_MASK (~0U) |
| 119 | #define LINE_MASK (~(1U << REPORTED_BIT)) |
| 120 | #endif |
| 121 | |
| 122 | #define VALUE_LENGTH 40 |
| 123 | |
| 124 | static bool was_reported(struct source_location *location) |
| 125 | { |
| 126 | return test_and_set_bit(REPORTED_BIT, &location->reported); |
| 127 | } |
| 128 | |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 129 | static bool suppress_report(struct source_location *loc) |
| 130 | { |
| 131 | return current->in_ubsan || was_reported(loc); |
| 132 | } |
| 133 | |
| 134 | static bool type_is_int(struct type_descriptor *type) |
| 135 | { |
| 136 | return type->type_kind == type_kind_int; |
| 137 | } |
| 138 | |
| 139 | static bool type_is_signed(struct type_descriptor *type) |
| 140 | { |
| 141 | WARN_ON(!type_is_int(type)); |
| 142 | return type->type_info & 1; |
| 143 | } |
| 144 | |
| 145 | static unsigned type_bit_width(struct type_descriptor *type) |
| 146 | { |
| 147 | return 1 << (type->type_info >> 1); |
| 148 | } |
| 149 | |
| 150 | static bool is_inline_int(struct type_descriptor *type) |
| 151 | { |
| 152 | unsigned inline_bits = sizeof(unsigned long)*8; |
| 153 | unsigned bits = type_bit_width(type); |
| 154 | |
| 155 | WARN_ON(!type_is_int(type)); |
| 156 | |
| 157 | return bits <= inline_bits; |
| 158 | } |
| 159 | |
Andrey Ryabinin | f0996bc | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 160 | static s_max get_signed_val(struct type_descriptor *type, void *val) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 161 | { |
| 162 | if (is_inline_int(type)) { |
| 163 | unsigned extra_bits = sizeof(s_max)*8 - type_bit_width(type); |
Andrey Ryabinin | f0996bc | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 164 | unsigned long ulong_val = (unsigned long)val; |
| 165 | |
| 166 | return ((s_max)ulong_val) << extra_bits >> extra_bits; |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 167 | } |
| 168 | |
| 169 | if (type_bit_width(type) == 64) |
| 170 | return *(s64 *)val; |
| 171 | |
| 172 | return *(s_max *)val; |
| 173 | } |
| 174 | |
Andrey Ryabinin | f0996bc | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 175 | static bool val_is_negative(struct type_descriptor *type, void *val) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 176 | { |
| 177 | return type_is_signed(type) && get_signed_val(type, val) < 0; |
| 178 | } |
| 179 | |
Andrey Ryabinin | f0996bc | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 180 | static u_max get_unsigned_val(struct type_descriptor *type, void *val) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 181 | { |
| 182 | if (is_inline_int(type)) |
Andrey Ryabinin | f0996bc | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 183 | return (unsigned long)val; |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 184 | |
| 185 | if (type_bit_width(type) == 64) |
| 186 | return *(u64 *)val; |
| 187 | |
| 188 | return *(u_max *)val; |
| 189 | } |
| 190 | |
| 191 | static void val_to_string(char *str, size_t size, struct type_descriptor *type, |
Andrey Ryabinin | f0996bc | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 192 | void *value) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 193 | { |
| 194 | if (type_is_int(type)) { |
| 195 | if (type_bit_width(type) == 128) { |
Ard Biesheuvel | c12d336 | 2019-11-08 13:22:27 +0100 | [diff] [blame] | 196 | #if defined(CONFIG_ARCH_SUPPORTS_INT128) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 197 | u_max val = get_unsigned_val(type, value); |
| 198 | |
| 199 | scnprintf(str, size, "0x%08x%08x%08x%08x", |
| 200 | (u32)(val >> 96), |
| 201 | (u32)(val >> 64), |
| 202 | (u32)(val >> 32), |
| 203 | (u32)(val)); |
| 204 | #else |
| 205 | WARN_ON(1); |
| 206 | #endif |
| 207 | } else if (type_is_signed(type)) { |
| 208 | scnprintf(str, size, "%lld", |
| 209 | (s64)get_signed_val(type, value)); |
| 210 | } else { |
| 211 | scnprintf(str, size, "%llu", |
| 212 | (u64)get_unsigned_val(type, value)); |
| 213 | } |
| 214 | } |
| 215 | } |
| 216 | |
Kees Cook | ef06565 | 2020-04-06 20:12:45 -0700 | [diff] [blame] | 217 | static void ubsan_prologue(struct source_location *loc, const char *reason) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 218 | { |
| 219 | current->in_ubsan++; |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 220 | |
Borislav Petkov (AMD) | ffda655 | 2023-12-18 14:53:39 +0100 | [diff] [blame] | 221 | pr_warn(CUT_HERE); |
| 222 | |
Kees Cook | ef06565 | 2020-04-06 20:12:45 -0700 | [diff] [blame] | 223 | pr_err("UBSAN: %s in %s:%d:%d\n", reason, loc->file_name, |
| 224 | loc->line & LINE_MASK, loc->column & COLUMN_MASK); |
Uriel Guajardo | 1195505 | 2021-04-02 14:21:31 -0700 | [diff] [blame] | 225 | |
| 226 | kunit_fail_current_test("%s in %s", reason, loc->file_name); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 227 | } |
| 228 | |
Julien Grall | ce5c31d | 2019-12-04 16:52:53 -0800 | [diff] [blame] | 229 | static void ubsan_epilogue(void) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 230 | { |
| 231 | dump_stack(); |
Borislav Petkov (AMD) | ffda655 | 2023-12-18 14:53:39 +0100 | [diff] [blame] | 232 | pr_warn("---[ end trace ]---\n"); |
Julien Grall | ce5c31d | 2019-12-04 16:52:53 -0800 | [diff] [blame] | 233 | |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 234 | current->in_ubsan--; |
Kees Cook | 1d28c8d | 2020-04-06 20:12:38 -0700 | [diff] [blame] | 235 | |
Kees Cook | 79cc1ba | 2022-11-17 15:43:24 -0800 | [diff] [blame] | 236 | check_panic_on_warn("UBSAN"); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 237 | } |
| 238 | |
Kees Cook | 557f8c58 | 2024-01-18 15:06:05 -0800 | [diff] [blame] | 239 | static void handle_overflow(struct overflow_data *data, void *lhs, |
| 240 | void *rhs, char op) |
| 241 | { |
| 242 | |
| 243 | struct type_descriptor *type = data->type; |
| 244 | char lhs_val_str[VALUE_LENGTH]; |
| 245 | char rhs_val_str[VALUE_LENGTH]; |
| 246 | |
| 247 | if (suppress_report(&data->location)) |
| 248 | return; |
| 249 | |
| 250 | ubsan_prologue(&data->location, type_is_signed(type) ? |
| 251 | "signed-integer-overflow" : |
| 252 | "unsigned-integer-overflow"); |
| 253 | |
| 254 | val_to_string(lhs_val_str, sizeof(lhs_val_str), type, lhs); |
| 255 | val_to_string(rhs_val_str, sizeof(rhs_val_str), type, rhs); |
| 256 | pr_err("%s %c %s cannot be represented in type %s\n", |
| 257 | lhs_val_str, |
| 258 | op, |
| 259 | rhs_val_str, |
| 260 | type->type_name); |
| 261 | |
| 262 | ubsan_epilogue(); |
| 263 | } |
| 264 | |
| 265 | void __ubsan_handle_add_overflow(void *data, |
| 266 | void *lhs, void *rhs) |
| 267 | { |
| 268 | |
| 269 | handle_overflow(data, lhs, rhs, '+'); |
| 270 | } |
| 271 | EXPORT_SYMBOL(__ubsan_handle_add_overflow); |
| 272 | |
| 273 | void __ubsan_handle_sub_overflow(void *data, |
| 274 | void *lhs, void *rhs) |
| 275 | { |
| 276 | handle_overflow(data, lhs, rhs, '-'); |
| 277 | } |
| 278 | EXPORT_SYMBOL(__ubsan_handle_sub_overflow); |
| 279 | |
| 280 | void __ubsan_handle_mul_overflow(void *data, |
| 281 | void *lhs, void *rhs) |
| 282 | { |
| 283 | handle_overflow(data, lhs, rhs, '*'); |
| 284 | } |
| 285 | EXPORT_SYMBOL(__ubsan_handle_mul_overflow); |
| 286 | |
| 287 | void __ubsan_handle_negate_overflow(void *_data, void *old_val) |
| 288 | { |
| 289 | struct overflow_data *data = _data; |
| 290 | char old_val_str[VALUE_LENGTH]; |
| 291 | |
| 292 | if (suppress_report(&data->location)) |
| 293 | return; |
| 294 | |
| 295 | ubsan_prologue(&data->location, "negation-overflow"); |
| 296 | |
| 297 | val_to_string(old_val_str, sizeof(old_val_str), data->type, old_val); |
| 298 | |
| 299 | pr_err("negation of %s cannot be represented in type %s:\n", |
| 300 | old_val_str, data->type->type_name); |
| 301 | |
| 302 | ubsan_epilogue(); |
| 303 | } |
| 304 | EXPORT_SYMBOL(__ubsan_handle_negate_overflow); |
| 305 | |
| 306 | |
Arnd Bergmann | 469cbd0 | 2020-06-04 16:53:00 -0700 | [diff] [blame] | 307 | void __ubsan_handle_divrem_overflow(void *_data, void *lhs, void *rhs) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 308 | { |
Arnd Bergmann | 469cbd0 | 2020-06-04 16:53:00 -0700 | [diff] [blame] | 309 | struct overflow_data *data = _data; |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 310 | char rhs_val_str[VALUE_LENGTH]; |
| 311 | |
| 312 | if (suppress_report(&data->location)) |
| 313 | return; |
| 314 | |
Kees Cook | ef06565 | 2020-04-06 20:12:45 -0700 | [diff] [blame] | 315 | ubsan_prologue(&data->location, "division-overflow"); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 316 | |
| 317 | val_to_string(rhs_val_str, sizeof(rhs_val_str), data->type, rhs); |
| 318 | |
| 319 | if (type_is_signed(data->type) && get_signed_val(data->type, rhs) == -1) |
| 320 | pr_err("division of %s by -1 cannot be represented in type %s\n", |
| 321 | rhs_val_str, data->type->type_name); |
| 322 | else |
| 323 | pr_err("division by zero\n"); |
| 324 | |
Julien Grall | ce5c31d | 2019-12-04 16:52:53 -0800 | [diff] [blame] | 325 | ubsan_epilogue(); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 326 | } |
| 327 | EXPORT_SYMBOL(__ubsan_handle_divrem_overflow); |
| 328 | |
Andrey Ryabinin | 42440c1 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 329 | static void handle_null_ptr_deref(struct type_mismatch_data_common *data) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 330 | { |
Andrey Ryabinin | 42440c1 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 331 | if (suppress_report(data->location)) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 332 | return; |
| 333 | |
Kees Cook | ef06565 | 2020-04-06 20:12:45 -0700 | [diff] [blame] | 334 | ubsan_prologue(data->location, "null-ptr-deref"); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 335 | |
| 336 | pr_err("%s null pointer of type %s\n", |
| 337 | type_check_kinds[data->type_check_kind], |
| 338 | data->type->type_name); |
| 339 | |
Julien Grall | ce5c31d | 2019-12-04 16:52:53 -0800 | [diff] [blame] | 340 | ubsan_epilogue(); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 341 | } |
| 342 | |
Andrey Ryabinin | 42440c1 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 343 | static void handle_misaligned_access(struct type_mismatch_data_common *data, |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 344 | unsigned long ptr) |
| 345 | { |
Andrey Ryabinin | 42440c1 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 346 | if (suppress_report(data->location)) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 347 | return; |
| 348 | |
Kees Cook | ef06565 | 2020-04-06 20:12:45 -0700 | [diff] [blame] | 349 | ubsan_prologue(data->location, "misaligned-access"); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 350 | |
| 351 | pr_err("%s misaligned address %p for type %s\n", |
| 352 | type_check_kinds[data->type_check_kind], |
| 353 | (void *)ptr, data->type->type_name); |
| 354 | pr_err("which requires %ld byte alignment\n", data->alignment); |
| 355 | |
Julien Grall | ce5c31d | 2019-12-04 16:52:53 -0800 | [diff] [blame] | 356 | ubsan_epilogue(); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 357 | } |
| 358 | |
Andrey Ryabinin | 42440c1 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 359 | static void handle_object_size_mismatch(struct type_mismatch_data_common *data, |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 360 | unsigned long ptr) |
| 361 | { |
Andrey Ryabinin | 42440c1 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 362 | if (suppress_report(data->location)) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 363 | return; |
| 364 | |
Kees Cook | ef06565 | 2020-04-06 20:12:45 -0700 | [diff] [blame] | 365 | ubsan_prologue(data->location, "object-size-mismatch"); |
Nicolas Iooss | 901d805 | 2016-08-02 14:03:10 -0700 | [diff] [blame] | 366 | pr_err("%s address %p with insufficient space\n", |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 367 | type_check_kinds[data->type_check_kind], |
| 368 | (void *) ptr); |
| 369 | pr_err("for an object of type %s\n", data->type->type_name); |
Julien Grall | ce5c31d | 2019-12-04 16:52:53 -0800 | [diff] [blame] | 370 | ubsan_epilogue(); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 371 | } |
| 372 | |
Andrey Ryabinin | 42440c1 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 373 | static void ubsan_type_mismatch_common(struct type_mismatch_data_common *data, |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 374 | unsigned long ptr) |
| 375 | { |
Peter Zijlstra | d08965a | 2019-04-03 09:40:16 +0200 | [diff] [blame] | 376 | unsigned long flags = user_access_save(); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 377 | |
| 378 | if (!ptr) |
| 379 | handle_null_ptr_deref(data); |
| 380 | else if (data->alignment && !IS_ALIGNED(ptr, data->alignment)) |
Andrew Morton | b8fe112 | 2018-02-06 15:40:38 -0800 | [diff] [blame] | 381 | handle_misaligned_access(data, ptr); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 382 | else |
| 383 | handle_object_size_mismatch(data, ptr); |
Peter Zijlstra | d08965a | 2019-04-03 09:40:16 +0200 | [diff] [blame] | 384 | |
| 385 | user_access_restore(flags); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 386 | } |
Andrey Ryabinin | 42440c1 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 387 | |
| 388 | void __ubsan_handle_type_mismatch(struct type_mismatch_data *data, |
Andrey Ryabinin | f0996bc | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 389 | void *ptr) |
Andrey Ryabinin | 42440c1 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 390 | { |
| 391 | struct type_mismatch_data_common common_data = { |
| 392 | .location = &data->location, |
| 393 | .type = data->type, |
| 394 | .alignment = data->alignment, |
| 395 | .type_check_kind = data->type_check_kind |
| 396 | }; |
| 397 | |
Andrey Ryabinin | f0996bc | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 398 | ubsan_type_mismatch_common(&common_data, (unsigned long)ptr); |
Andrey Ryabinin | 42440c1 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 399 | } |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 400 | EXPORT_SYMBOL(__ubsan_handle_type_mismatch); |
| 401 | |
Arnd Bergmann | 469cbd0 | 2020-06-04 16:53:00 -0700 | [diff] [blame] | 402 | void __ubsan_handle_type_mismatch_v1(void *_data, void *ptr) |
Andrey Ryabinin | 42440c1 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 403 | { |
Arnd Bergmann | 469cbd0 | 2020-06-04 16:53:00 -0700 | [diff] [blame] | 404 | struct type_mismatch_data_v1 *data = _data; |
Andrey Ryabinin | 42440c1 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 405 | struct type_mismatch_data_common common_data = { |
| 406 | .location = &data->location, |
| 407 | .type = data->type, |
| 408 | .alignment = 1UL << data->log_alignment, |
| 409 | .type_check_kind = data->type_check_kind |
| 410 | }; |
| 411 | |
Andrey Ryabinin | f0996bc | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 412 | ubsan_type_mismatch_common(&common_data, (unsigned long)ptr); |
Andrey Ryabinin | 42440c1 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 413 | } |
| 414 | EXPORT_SYMBOL(__ubsan_handle_type_mismatch_v1); |
| 415 | |
Arnd Bergmann | 469cbd0 | 2020-06-04 16:53:00 -0700 | [diff] [blame] | 416 | void __ubsan_handle_out_of_bounds(void *_data, void *index) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 417 | { |
Arnd Bergmann | 469cbd0 | 2020-06-04 16:53:00 -0700 | [diff] [blame] | 418 | struct out_of_bounds_data *data = _data; |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 419 | char index_str[VALUE_LENGTH]; |
| 420 | |
| 421 | if (suppress_report(&data->location)) |
| 422 | return; |
| 423 | |
Kees Cook | ef06565 | 2020-04-06 20:12:45 -0700 | [diff] [blame] | 424 | ubsan_prologue(&data->location, "array-index-out-of-bounds"); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 425 | |
| 426 | val_to_string(index_str, sizeof(index_str), data->index_type, index); |
| 427 | pr_err("index %s is out of range for type %s\n", index_str, |
| 428 | data->array_type->type_name); |
Julien Grall | ce5c31d | 2019-12-04 16:52:53 -0800 | [diff] [blame] | 429 | ubsan_epilogue(); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 430 | } |
| 431 | EXPORT_SYMBOL(__ubsan_handle_out_of_bounds); |
| 432 | |
Arnd Bergmann | 469cbd0 | 2020-06-04 16:53:00 -0700 | [diff] [blame] | 433 | void __ubsan_handle_shift_out_of_bounds(void *_data, void *lhs, void *rhs) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 434 | { |
Arnd Bergmann | 469cbd0 | 2020-06-04 16:53:00 -0700 | [diff] [blame] | 435 | struct shift_out_of_bounds_data *data = _data; |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 436 | struct type_descriptor *rhs_type = data->rhs_type; |
| 437 | struct type_descriptor *lhs_type = data->lhs_type; |
| 438 | char rhs_str[VALUE_LENGTH]; |
| 439 | char lhs_str[VALUE_LENGTH]; |
Peter Zijlstra | 9a50dca | 2019-10-21 15:11:49 +0200 | [diff] [blame] | 440 | unsigned long ua_flags = user_access_save(); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 441 | |
| 442 | if (suppress_report(&data->location)) |
Peter Zijlstra | 9a50dca | 2019-10-21 15:11:49 +0200 | [diff] [blame] | 443 | goto out; |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 444 | |
Kees Cook | ef06565 | 2020-04-06 20:12:45 -0700 | [diff] [blame] | 445 | ubsan_prologue(&data->location, "shift-out-of-bounds"); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 446 | |
| 447 | val_to_string(rhs_str, sizeof(rhs_str), rhs_type, rhs); |
| 448 | val_to_string(lhs_str, sizeof(lhs_str), lhs_type, lhs); |
| 449 | |
| 450 | if (val_is_negative(rhs_type, rhs)) |
| 451 | pr_err("shift exponent %s is negative\n", rhs_str); |
| 452 | |
| 453 | else if (get_unsigned_val(rhs_type, rhs) >= |
| 454 | type_bit_width(lhs_type)) |
| 455 | pr_err("shift exponent %s is too large for %u-bit type %s\n", |
| 456 | rhs_str, |
| 457 | type_bit_width(lhs_type), |
| 458 | lhs_type->type_name); |
| 459 | else if (val_is_negative(lhs_type, lhs)) |
| 460 | pr_err("left shift of negative value %s\n", |
| 461 | lhs_str); |
| 462 | else |
| 463 | pr_err("left shift of %s by %s places cannot be" |
| 464 | " represented in type %s\n", |
| 465 | lhs_str, rhs_str, |
| 466 | lhs_type->type_name); |
| 467 | |
Julien Grall | ce5c31d | 2019-12-04 16:52:53 -0800 | [diff] [blame] | 468 | ubsan_epilogue(); |
Peter Zijlstra | 9a50dca | 2019-10-21 15:11:49 +0200 | [diff] [blame] | 469 | out: |
| 470 | user_access_restore(ua_flags); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 471 | } |
| 472 | EXPORT_SYMBOL(__ubsan_handle_shift_out_of_bounds); |
| 473 | |
| 474 | |
Arnd Bergmann | 469cbd0 | 2020-06-04 16:53:00 -0700 | [diff] [blame] | 475 | void __ubsan_handle_builtin_unreachable(void *_data) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 476 | { |
Arnd Bergmann | 469cbd0 | 2020-06-04 16:53:00 -0700 | [diff] [blame] | 477 | struct unreachable_data *data = _data; |
Kees Cook | ef06565 | 2020-04-06 20:12:45 -0700 | [diff] [blame] | 478 | ubsan_prologue(&data->location, "unreachable"); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 479 | pr_err("calling __builtin_unreachable()\n"); |
Julien Grall | ce5c31d | 2019-12-04 16:52:53 -0800 | [diff] [blame] | 480 | ubsan_epilogue(); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 481 | panic("can't return from __builtin_unreachable()"); |
| 482 | } |
| 483 | EXPORT_SYMBOL(__ubsan_handle_builtin_unreachable); |
| 484 | |
Arnd Bergmann | 469cbd0 | 2020-06-04 16:53:00 -0700 | [diff] [blame] | 485 | void __ubsan_handle_load_invalid_value(void *_data, void *val) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 486 | { |
Arnd Bergmann | 469cbd0 | 2020-06-04 16:53:00 -0700 | [diff] [blame] | 487 | struct invalid_value_data *data = _data; |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 488 | char val_str[VALUE_LENGTH]; |
Peter Zijlstra | f18b0d7 | 2023-01-12 20:43:56 +0100 | [diff] [blame] | 489 | unsigned long ua_flags = user_access_save(); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 490 | |
| 491 | if (suppress_report(&data->location)) |
Peter Zijlstra | f18b0d7 | 2023-01-12 20:43:56 +0100 | [diff] [blame] | 492 | goto out; |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 493 | |
Kees Cook | ef06565 | 2020-04-06 20:12:45 -0700 | [diff] [blame] | 494 | ubsan_prologue(&data->location, "invalid-load"); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 495 | |
| 496 | val_to_string(val_str, sizeof(val_str), data->type, val); |
| 497 | |
| 498 | pr_err("load of value %s is not a valid value for type %s\n", |
| 499 | val_str, data->type->type_name); |
| 500 | |
Julien Grall | ce5c31d | 2019-12-04 16:52:53 -0800 | [diff] [blame] | 501 | ubsan_epilogue(); |
Peter Zijlstra | f18b0d7 | 2023-01-12 20:43:56 +0100 | [diff] [blame] | 502 | out: |
| 503 | user_access_restore(ua_flags); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 504 | } |
| 505 | EXPORT_SYMBOL(__ubsan_handle_load_invalid_value); |
Nathan Chancellor | 28abcc9 | 2021-02-04 18:32:57 -0800 | [diff] [blame] | 506 | |
| 507 | void __ubsan_handle_alignment_assumption(void *_data, unsigned long ptr, |
| 508 | unsigned long align, |
Nathan Chancellor | 28abcc9 | 2021-02-04 18:32:57 -0800 | [diff] [blame] | 509 | unsigned long offset) |
| 510 | { |
| 511 | struct alignment_assumption_data *data = _data; |
| 512 | unsigned long real_ptr; |
| 513 | |
| 514 | if (suppress_report(&data->location)) |
| 515 | return; |
| 516 | |
| 517 | ubsan_prologue(&data->location, "alignment-assumption"); |
| 518 | |
| 519 | if (offset) |
| 520 | pr_err("assumption of %lu byte alignment (with offset of %lu byte) for pointer of type %s failed", |
| 521 | align, offset, data->type->type_name); |
| 522 | else |
| 523 | pr_err("assumption of %lu byte alignment for pointer of type %s failed", |
| 524 | align, data->type->type_name); |
| 525 | |
| 526 | real_ptr = ptr - offset; |
| 527 | pr_err("%saddress is %lu aligned, misalignment offset is %lu bytes", |
| 528 | offset ? "offset " : "", BIT(real_ptr ? __ffs(real_ptr) : 0), |
| 529 | real_ptr & (align - 1)); |
| 530 | |
| 531 | ubsan_epilogue(); |
| 532 | } |
| 533 | EXPORT_SYMBOL(__ubsan_handle_alignment_assumption); |
Kees Cook | 25b8400 | 2023-02-02 22:07:49 +0000 | [diff] [blame] | 534 | |
| 535 | #endif /* !CONFIG_UBSAN_TRAP */ |