Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 1 | /* |
| 2 | * UBSAN error reporting functions |
| 3 | * |
| 4 | * Copyright (c) 2014 Samsung Electronics Co., Ltd. |
| 5 | * Author: Andrey Ryabinin <ryabinin.a.a@gmail.com> |
| 6 | * |
| 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. |
| 10 | * |
| 11 | */ |
| 12 | |
| 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 | |
| 21 | #include "ubsan.h" |
| 22 | |
| 23 | const char *type_check_kinds[] = { |
| 24 | "load of", |
| 25 | "store to", |
| 26 | "reference binding to", |
| 27 | "member access within", |
| 28 | "member call on", |
| 29 | "constructor call on", |
| 30 | "downcast of", |
| 31 | "downcast of" |
| 32 | }; |
| 33 | |
| 34 | #define REPORTED_BIT 31 |
| 35 | |
| 36 | #if (BITS_PER_LONG == 64) && defined(__BIG_ENDIAN) |
| 37 | #define COLUMN_MASK (~(1U << REPORTED_BIT)) |
| 38 | #define LINE_MASK (~0U) |
| 39 | #else |
| 40 | #define COLUMN_MASK (~0U) |
| 41 | #define LINE_MASK (~(1U << REPORTED_BIT)) |
| 42 | #endif |
| 43 | |
| 44 | #define VALUE_LENGTH 40 |
| 45 | |
| 46 | static bool was_reported(struct source_location *location) |
| 47 | { |
| 48 | return test_and_set_bit(REPORTED_BIT, &location->reported); |
| 49 | } |
| 50 | |
| 51 | static void print_source_location(const char *prefix, |
| 52 | struct source_location *loc) |
| 53 | { |
| 54 | pr_err("%s %s:%d:%d\n", prefix, loc->file_name, |
| 55 | loc->line & LINE_MASK, loc->column & COLUMN_MASK); |
| 56 | } |
| 57 | |
| 58 | static bool suppress_report(struct source_location *loc) |
| 59 | { |
| 60 | return current->in_ubsan || was_reported(loc); |
| 61 | } |
| 62 | |
| 63 | static bool type_is_int(struct type_descriptor *type) |
| 64 | { |
| 65 | return type->type_kind == type_kind_int; |
| 66 | } |
| 67 | |
| 68 | static bool type_is_signed(struct type_descriptor *type) |
| 69 | { |
| 70 | WARN_ON(!type_is_int(type)); |
| 71 | return type->type_info & 1; |
| 72 | } |
| 73 | |
| 74 | static unsigned type_bit_width(struct type_descriptor *type) |
| 75 | { |
| 76 | return 1 << (type->type_info >> 1); |
| 77 | } |
| 78 | |
| 79 | static bool is_inline_int(struct type_descriptor *type) |
| 80 | { |
| 81 | unsigned inline_bits = sizeof(unsigned long)*8; |
| 82 | unsigned bits = type_bit_width(type); |
| 83 | |
| 84 | WARN_ON(!type_is_int(type)); |
| 85 | |
| 86 | return bits <= inline_bits; |
| 87 | } |
| 88 | |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 89 | static s_max get_signed_val(struct type_descriptor *type, void *val) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 90 | { |
| 91 | if (is_inline_int(type)) { |
| 92 | unsigned extra_bits = sizeof(s_max)*8 - type_bit_width(type); |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 93 | unsigned long ulong_val = (unsigned long)val; |
| 94 | |
| 95 | return ((s_max)ulong_val) << extra_bits >> extra_bits; |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 96 | } |
| 97 | |
| 98 | if (type_bit_width(type) == 64) |
| 99 | return *(s64 *)val; |
| 100 | |
| 101 | return *(s_max *)val; |
| 102 | } |
| 103 | |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 104 | static bool val_is_negative(struct type_descriptor *type, void *val) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 105 | { |
| 106 | return type_is_signed(type) && get_signed_val(type, val) < 0; |
| 107 | } |
| 108 | |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 109 | static u_max get_unsigned_val(struct type_descriptor *type, void *val) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 110 | { |
| 111 | if (is_inline_int(type)) |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 112 | return (unsigned long)val; |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 113 | |
| 114 | if (type_bit_width(type) == 64) |
| 115 | return *(u64 *)val; |
| 116 | |
| 117 | return *(u_max *)val; |
| 118 | } |
| 119 | |
| 120 | static void val_to_string(char *str, size_t size, struct type_descriptor *type, |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 121 | void *value) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 122 | { |
| 123 | if (type_is_int(type)) { |
| 124 | if (type_bit_width(type) == 128) { |
| 125 | #if defined(CONFIG_ARCH_SUPPORTS_INT128) && defined(__SIZEOF_INT128__) |
| 126 | u_max val = get_unsigned_val(type, value); |
| 127 | |
| 128 | scnprintf(str, size, "0x%08x%08x%08x%08x", |
| 129 | (u32)(val >> 96), |
| 130 | (u32)(val >> 64), |
| 131 | (u32)(val >> 32), |
| 132 | (u32)(val)); |
| 133 | #else |
| 134 | WARN_ON(1); |
| 135 | #endif |
| 136 | } else if (type_is_signed(type)) { |
| 137 | scnprintf(str, size, "%lld", |
| 138 | (s64)get_signed_val(type, value)); |
| 139 | } else { |
| 140 | scnprintf(str, size, "%llu", |
| 141 | (u64)get_unsigned_val(type, value)); |
| 142 | } |
| 143 | } |
| 144 | } |
| 145 | |
| 146 | static bool location_is_valid(struct source_location *loc) |
| 147 | { |
| 148 | return loc->file_name != NULL; |
| 149 | } |
| 150 | |
| 151 | static DEFINE_SPINLOCK(report_lock); |
| 152 | |
| 153 | static void ubsan_prologue(struct source_location *location, |
| 154 | unsigned long *flags) |
| 155 | { |
| 156 | current->in_ubsan++; |
| 157 | spin_lock_irqsave(&report_lock, *flags); |
| 158 | |
| 159 | pr_err("========================================" |
| 160 | "========================================\n"); |
| 161 | print_source_location("UBSAN: Undefined behaviour in", location); |
| 162 | } |
| 163 | |
| 164 | static void ubsan_epilogue(unsigned long *flags) |
| 165 | { |
| 166 | dump_stack(); |
| 167 | pr_err("========================================" |
| 168 | "========================================\n"); |
| 169 | spin_unlock_irqrestore(&report_lock, *flags); |
| 170 | current->in_ubsan--; |
| 171 | } |
| 172 | |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 173 | static void handle_overflow(struct overflow_data *data, void *lhs, |
| 174 | void *rhs, char op) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 175 | { |
| 176 | |
| 177 | struct type_descriptor *type = data->type; |
| 178 | unsigned long flags; |
| 179 | char lhs_val_str[VALUE_LENGTH]; |
| 180 | char rhs_val_str[VALUE_LENGTH]; |
| 181 | |
| 182 | if (suppress_report(&data->location)) |
| 183 | return; |
| 184 | |
| 185 | ubsan_prologue(&data->location, &flags); |
| 186 | |
| 187 | val_to_string(lhs_val_str, sizeof(lhs_val_str), type, lhs); |
| 188 | val_to_string(rhs_val_str, sizeof(rhs_val_str), type, rhs); |
| 189 | pr_err("%s integer overflow:\n", |
| 190 | type_is_signed(type) ? "signed" : "unsigned"); |
| 191 | pr_err("%s %c %s cannot be represented in type %s\n", |
| 192 | lhs_val_str, |
| 193 | op, |
| 194 | rhs_val_str, |
| 195 | type->type_name); |
| 196 | |
| 197 | ubsan_epilogue(&flags); |
| 198 | } |
| 199 | |
| 200 | void __ubsan_handle_add_overflow(struct overflow_data *data, |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 201 | void *lhs, void *rhs) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 202 | { |
| 203 | |
| 204 | handle_overflow(data, lhs, rhs, '+'); |
| 205 | } |
| 206 | EXPORT_SYMBOL(__ubsan_handle_add_overflow); |
| 207 | |
| 208 | void __ubsan_handle_sub_overflow(struct overflow_data *data, |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 209 | void *lhs, void *rhs) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 210 | { |
| 211 | handle_overflow(data, lhs, rhs, '-'); |
| 212 | } |
| 213 | EXPORT_SYMBOL(__ubsan_handle_sub_overflow); |
| 214 | |
| 215 | void __ubsan_handle_mul_overflow(struct overflow_data *data, |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 216 | void *lhs, void *rhs) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 217 | { |
| 218 | handle_overflow(data, lhs, rhs, '*'); |
| 219 | } |
| 220 | EXPORT_SYMBOL(__ubsan_handle_mul_overflow); |
| 221 | |
| 222 | void __ubsan_handle_negate_overflow(struct overflow_data *data, |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 223 | void *old_val) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 224 | { |
| 225 | unsigned long flags; |
| 226 | char old_val_str[VALUE_LENGTH]; |
| 227 | |
| 228 | if (suppress_report(&data->location)) |
| 229 | return; |
| 230 | |
| 231 | ubsan_prologue(&data->location, &flags); |
| 232 | |
| 233 | val_to_string(old_val_str, sizeof(old_val_str), data->type, old_val); |
| 234 | |
| 235 | pr_err("negation of %s cannot be represented in type %s:\n", |
| 236 | old_val_str, data->type->type_name); |
| 237 | |
| 238 | ubsan_epilogue(&flags); |
| 239 | } |
| 240 | EXPORT_SYMBOL(__ubsan_handle_negate_overflow); |
| 241 | |
| 242 | |
| 243 | void __ubsan_handle_divrem_overflow(struct overflow_data *data, |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 244 | void *lhs, void *rhs) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 245 | { |
| 246 | unsigned long flags; |
| 247 | char rhs_val_str[VALUE_LENGTH]; |
| 248 | |
| 249 | if (suppress_report(&data->location)) |
| 250 | return; |
| 251 | |
| 252 | ubsan_prologue(&data->location, &flags); |
| 253 | |
| 254 | val_to_string(rhs_val_str, sizeof(rhs_val_str), data->type, rhs); |
| 255 | |
| 256 | if (type_is_signed(data->type) && get_signed_val(data->type, rhs) == -1) |
| 257 | pr_err("division of %s by -1 cannot be represented in type %s\n", |
| 258 | rhs_val_str, data->type->type_name); |
| 259 | else |
| 260 | pr_err("division by zero\n"); |
| 261 | |
| 262 | ubsan_epilogue(&flags); |
| 263 | } |
| 264 | EXPORT_SYMBOL(__ubsan_handle_divrem_overflow); |
| 265 | |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 266 | static void handle_null_ptr_deref(struct type_mismatch_data_common *data) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 267 | { |
| 268 | unsigned long flags; |
| 269 | |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 270 | if (suppress_report(data->location)) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 271 | return; |
| 272 | |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 273 | ubsan_prologue(data->location, &flags); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 274 | |
| 275 | pr_err("%s null pointer of type %s\n", |
| 276 | type_check_kinds[data->type_check_kind], |
| 277 | data->type->type_name); |
| 278 | |
| 279 | ubsan_epilogue(&flags); |
| 280 | } |
| 281 | |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 282 | static void handle_misaligned_access(struct type_mismatch_data_common *data, |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 283 | unsigned long ptr) |
| 284 | { |
| 285 | unsigned long flags; |
| 286 | |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 287 | if (suppress_report(data->location)) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 288 | return; |
| 289 | |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 290 | ubsan_prologue(data->location, &flags); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 291 | |
| 292 | pr_err("%s misaligned address %p for type %s\n", |
| 293 | type_check_kinds[data->type_check_kind], |
| 294 | (void *)ptr, data->type->type_name); |
| 295 | pr_err("which requires %ld byte alignment\n", data->alignment); |
| 296 | |
| 297 | ubsan_epilogue(&flags); |
| 298 | } |
| 299 | |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 300 | static void handle_object_size_mismatch(struct type_mismatch_data_common *data, |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 301 | unsigned long ptr) |
| 302 | { |
| 303 | unsigned long flags; |
| 304 | |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 305 | if (suppress_report(data->location)) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 306 | return; |
| 307 | |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 308 | ubsan_prologue(data->location, &flags); |
Nicolas Iooss | 901d805 | 2016-08-02 14:03:10 -0700 | [diff] [blame] | 309 | pr_err("%s address %p with insufficient space\n", |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 310 | type_check_kinds[data->type_check_kind], |
| 311 | (void *) ptr); |
| 312 | pr_err("for an object of type %s\n", data->type->type_name); |
| 313 | ubsan_epilogue(&flags); |
| 314 | } |
| 315 | |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 316 | static void ubsan_type_mismatch_common(struct type_mismatch_data_common *data, |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 317 | unsigned long ptr) |
| 318 | { |
| 319 | |
| 320 | if (!ptr) |
| 321 | handle_null_ptr_deref(data); |
| 322 | else if (data->alignment && !IS_ALIGNED(ptr, data->alignment)) |
Andrew Morton | 3f81301 | 2018-02-06 15:40:38 -0800 | [diff] [blame] | 323 | handle_misaligned_access(data, ptr); |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 324 | else |
| 325 | handle_object_size_mismatch(data, ptr); |
| 326 | } |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 327 | |
| 328 | void __ubsan_handle_type_mismatch(struct type_mismatch_data *data, |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 329 | void *ptr) |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 330 | { |
| 331 | struct type_mismatch_data_common common_data = { |
| 332 | .location = &data->location, |
| 333 | .type = data->type, |
| 334 | .alignment = data->alignment, |
| 335 | .type_check_kind = data->type_check_kind |
| 336 | }; |
| 337 | |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 338 | ubsan_type_mismatch_common(&common_data, (unsigned long)ptr); |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 339 | } |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 340 | EXPORT_SYMBOL(__ubsan_handle_type_mismatch); |
| 341 | |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 342 | void __ubsan_handle_type_mismatch_v1(struct type_mismatch_data_v1 *data, |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 343 | void *ptr) |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 344 | { |
| 345 | |
| 346 | struct type_mismatch_data_common common_data = { |
| 347 | .location = &data->location, |
| 348 | .type = data->type, |
| 349 | .alignment = 1UL << data->log_alignment, |
| 350 | .type_check_kind = data->type_check_kind |
| 351 | }; |
| 352 | |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 353 | ubsan_type_mismatch_common(&common_data, (unsigned long)ptr); |
Andrey Ryabinin | 3c83fe5 | 2018-02-06 15:40:42 -0800 | [diff] [blame] | 354 | } |
| 355 | EXPORT_SYMBOL(__ubsan_handle_type_mismatch_v1); |
| 356 | |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 357 | void __ubsan_handle_nonnull_return(struct nonnull_return_data *data) |
| 358 | { |
| 359 | unsigned long flags; |
| 360 | |
| 361 | if (suppress_report(&data->location)) |
| 362 | return; |
| 363 | |
| 364 | ubsan_prologue(&data->location, &flags); |
| 365 | |
| 366 | pr_err("null pointer returned from function declared to never return null\n"); |
| 367 | |
| 368 | if (location_is_valid(&data->attr_location)) |
| 369 | print_source_location("returns_nonnull attribute specified in", |
| 370 | &data->attr_location); |
| 371 | |
| 372 | ubsan_epilogue(&flags); |
| 373 | } |
| 374 | EXPORT_SYMBOL(__ubsan_handle_nonnull_return); |
| 375 | |
| 376 | void __ubsan_handle_vla_bound_not_positive(struct vla_bound_data *data, |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 377 | void *bound) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 378 | { |
| 379 | unsigned long flags; |
| 380 | char bound_str[VALUE_LENGTH]; |
| 381 | |
| 382 | if (suppress_report(&data->location)) |
| 383 | return; |
| 384 | |
| 385 | ubsan_prologue(&data->location, &flags); |
| 386 | |
| 387 | val_to_string(bound_str, sizeof(bound_str), data->type, bound); |
| 388 | pr_err("variable length array bound value %s <= 0\n", bound_str); |
| 389 | |
| 390 | ubsan_epilogue(&flags); |
| 391 | } |
| 392 | EXPORT_SYMBOL(__ubsan_handle_vla_bound_not_positive); |
| 393 | |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 394 | void __ubsan_handle_out_of_bounds(struct out_of_bounds_data *data, void *index) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 395 | { |
| 396 | unsigned long flags; |
| 397 | char index_str[VALUE_LENGTH]; |
| 398 | |
| 399 | if (suppress_report(&data->location)) |
| 400 | return; |
| 401 | |
| 402 | ubsan_prologue(&data->location, &flags); |
| 403 | |
| 404 | val_to_string(index_str, sizeof(index_str), data->index_type, index); |
| 405 | pr_err("index %s is out of range for type %s\n", index_str, |
| 406 | data->array_type->type_name); |
| 407 | ubsan_epilogue(&flags); |
| 408 | } |
| 409 | EXPORT_SYMBOL(__ubsan_handle_out_of_bounds); |
| 410 | |
| 411 | void __ubsan_handle_shift_out_of_bounds(struct shift_out_of_bounds_data *data, |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 412 | void *lhs, void *rhs) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 413 | { |
| 414 | unsigned long flags; |
| 415 | struct type_descriptor *rhs_type = data->rhs_type; |
| 416 | struct type_descriptor *lhs_type = data->lhs_type; |
| 417 | char rhs_str[VALUE_LENGTH]; |
| 418 | char lhs_str[VALUE_LENGTH]; |
| 419 | |
| 420 | if (suppress_report(&data->location)) |
| 421 | return; |
| 422 | |
| 423 | ubsan_prologue(&data->location, &flags); |
| 424 | |
| 425 | val_to_string(rhs_str, sizeof(rhs_str), rhs_type, rhs); |
| 426 | val_to_string(lhs_str, sizeof(lhs_str), lhs_type, lhs); |
| 427 | |
| 428 | if (val_is_negative(rhs_type, rhs)) |
| 429 | pr_err("shift exponent %s is negative\n", rhs_str); |
| 430 | |
| 431 | else if (get_unsigned_val(rhs_type, rhs) >= |
| 432 | type_bit_width(lhs_type)) |
| 433 | pr_err("shift exponent %s is too large for %u-bit type %s\n", |
| 434 | rhs_str, |
| 435 | type_bit_width(lhs_type), |
| 436 | lhs_type->type_name); |
| 437 | else if (val_is_negative(lhs_type, lhs)) |
| 438 | pr_err("left shift of negative value %s\n", |
| 439 | lhs_str); |
| 440 | else |
| 441 | pr_err("left shift of %s by %s places cannot be" |
| 442 | " represented in type %s\n", |
| 443 | lhs_str, rhs_str, |
| 444 | lhs_type->type_name); |
| 445 | |
| 446 | ubsan_epilogue(&flags); |
| 447 | } |
| 448 | EXPORT_SYMBOL(__ubsan_handle_shift_out_of_bounds); |
| 449 | |
| 450 | |
Arnd Bergmann | e133c33 | 2018-11-16 15:08:35 -0800 | [diff] [blame] | 451 | void __ubsan_handle_builtin_unreachable(struct unreachable_data *data) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 452 | { |
| 453 | unsigned long flags; |
| 454 | |
| 455 | ubsan_prologue(&data->location, &flags); |
| 456 | pr_err("calling __builtin_unreachable()\n"); |
| 457 | ubsan_epilogue(&flags); |
| 458 | panic("can't return from __builtin_unreachable()"); |
| 459 | } |
| 460 | EXPORT_SYMBOL(__ubsan_handle_builtin_unreachable); |
| 461 | |
| 462 | void __ubsan_handle_load_invalid_value(struct invalid_value_data *data, |
Andrey Ryabinin | b34d655 | 2019-05-06 13:45:26 +0300 | [diff] [blame] | 463 | void *val) |
Andrey Ryabinin | c6d3085 | 2016-01-20 15:00:55 -0800 | [diff] [blame] | 464 | { |
| 465 | unsigned long flags; |
| 466 | char val_str[VALUE_LENGTH]; |
| 467 | |
| 468 | if (suppress_report(&data->location)) |
| 469 | return; |
| 470 | |
| 471 | ubsan_prologue(&data->location, &flags); |
| 472 | |
| 473 | val_to_string(val_str, sizeof(val_str), data->type, val); |
| 474 | |
| 475 | pr_err("load of value %s is not a valid value for type %s\n", |
| 476 | val_str, data->type->type_name); |
| 477 | |
| 478 | ubsan_epilogue(&flags); |
| 479 | } |
| 480 | EXPORT_SYMBOL(__ubsan_handle_load_invalid_value); |