Linux Audio

Check our new training course

Loading...
v6.13.7
  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * UBSAN error reporting functions
  4 *
  5 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
  6 * Author: Andrey Ryabinin <ryabinin.a.a@gmail.com>
 
 
 
 
 
  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>
 16#include <linux/uaccess.h>
 17#include <linux/ubsan.h>
 18#include <kunit/test-bug.h>
 19
 20#include "ubsan.h"
 21
 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 */
 28const 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
 47#if defined(CONFIG_UBSAN_DIV_ZERO) || defined(CONFIG_UBSAN_SIGNED_WRAP)
 48	/*
 49	 * SanitizerKind::IntegerDivideByZero and
 50	 * SanitizerKind::SignedIntegerOverflow emit
 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
 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
 95	default:
 96		return "UBSAN: unrecognized failure code";
 97	}
 98}
 99
100#else
101static const char * const type_check_kinds[] = {
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
124static bool was_reported(struct source_location *location)
125{
126	return test_and_set_bit(REPORTED_BIT, &location->reported);
127}
128
 
 
 
 
 
 
 
129static bool suppress_report(struct source_location *loc)
130{
131	return current->in_ubsan || was_reported(loc);
132}
133
134static bool type_is_int(struct type_descriptor *type)
135{
136	return type->type_kind == type_kind_int;
137}
138
139static bool type_is_signed(struct type_descriptor *type)
140{
141	WARN_ON(!type_is_int(type));
142	return  type->type_info & 1;
143}
144
145static unsigned type_bit_width(struct type_descriptor *type)
146{
147	return 1 << (type->type_info >> 1);
148}
149
150static 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
160static s_max get_signed_val(struct type_descriptor *type, void *val)
161{
162	if (is_inline_int(type)) {
163		unsigned extra_bits = sizeof(s_max)*8 - type_bit_width(type);
164		unsigned long ulong_val = (unsigned long)val;
165
166		return ((s_max)ulong_val) << extra_bits >> extra_bits;
167	}
168
169	if (type_bit_width(type) == 64)
170		return *(s64 *)val;
171
172	return *(s_max *)val;
173}
174
175static bool val_is_negative(struct type_descriptor *type, void *val)
176{
177	return type_is_signed(type) && get_signed_val(type, val) < 0;
178}
179
180static u_max get_unsigned_val(struct type_descriptor *type, void *val)
181{
182	if (is_inline_int(type))
183		return (unsigned long)val;
184
185	if (type_bit_width(type) == 64)
186		return *(u64 *)val;
187
188	return *(u_max *)val;
189}
190
191static void val_to_string(char *str, size_t size, struct type_descriptor *type,
192			void *value)
193{
194	if (type_is_int(type)) {
195		if (type_bit_width(type) == 128) {
196#if defined(CONFIG_ARCH_SUPPORTS_INT128)
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
217static void ubsan_prologue(struct source_location *loc, const char *reason)
218{
219	current->in_ubsan++;
 
220
221	pr_warn(CUT_HERE);
222
223	pr_err("UBSAN: %s in %s:%d:%d\n", reason, loc->file_name,
224		loc->line & LINE_MASK, loc->column & COLUMN_MASK);
 
 
 
225
226	kunit_fail_current_test("%s in %s", reason, loc->file_name);
 
 
227}
228
229static void ubsan_epilogue(void)
230{
231	dump_stack();
232	pr_warn("---[ end trace ]---\n");
233
 
234	current->in_ubsan--;
235
236	check_panic_on_warn("UBSAN");
237}
238
239static 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
265void __ubsan_handle_add_overflow(void *data,
266				void *lhs, void *rhs)
 
267{
268
269	handle_overflow(data, lhs, rhs, '+');
270}
271EXPORT_SYMBOL(__ubsan_handle_add_overflow);
272
273void __ubsan_handle_sub_overflow(void *data,
274				void *lhs, void *rhs)
 
275{
276	handle_overflow(data, lhs, rhs, '-');
277}
278EXPORT_SYMBOL(__ubsan_handle_sub_overflow);
279
280void __ubsan_handle_mul_overflow(void *data,
281				void *lhs, void *rhs)
 
282{
283	handle_overflow(data, lhs, rhs, '*');
284}
285EXPORT_SYMBOL(__ubsan_handle_mul_overflow);
286
287void __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}
304EXPORT_SYMBOL(__ubsan_handle_negate_overflow);
305
306
307void __ubsan_handle_divrem_overflow(void *_data, void *lhs, void *rhs)
 
 
308{
309	struct overflow_data *data = _data;
310	char rhs_val_str[VALUE_LENGTH];
311
312	if (suppress_report(&data->location))
313		return;
314
315	ubsan_prologue(&data->location, "division-overflow");
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
325	ubsan_epilogue();
326}
327EXPORT_SYMBOL(__ubsan_handle_divrem_overflow);
328
329static void handle_null_ptr_deref(struct type_mismatch_data_common *data)
330{
331	if (suppress_report(data->location))
 
 
332		return;
333
334	ubsan_prologue(data->location, "null-ptr-deref");
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
340	ubsan_epilogue();
341}
342
343static void handle_misaligned_access(struct type_mismatch_data_common *data,
344				unsigned long ptr)
345{
346	if (suppress_report(data->location))
 
 
347		return;
348
349	ubsan_prologue(data->location, "misaligned-access");
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
356	ubsan_epilogue();
357}
358
359static void handle_object_size_mismatch(struct type_mismatch_data_common *data,
360					unsigned long ptr)
361{
362	if (suppress_report(data->location))
 
 
363		return;
364
365	ubsan_prologue(data->location, "object-size-mismatch");
366	pr_err("%s address %p with insufficient space\n",
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);
370	ubsan_epilogue();
371}
372
373static void ubsan_type_mismatch_common(struct type_mismatch_data_common *data,
374				unsigned long ptr)
375{
376	unsigned long flags = user_access_save();
377
378	if (!ptr)
379		handle_null_ptr_deref(data);
380	else if (data->alignment && !IS_ALIGNED(ptr, data->alignment))
381		handle_misaligned_access(data, ptr);
382	else
383		handle_object_size_mismatch(data, ptr);
384
385	user_access_restore(flags);
386}
 
387
388void __ubsan_handle_type_mismatch(struct type_mismatch_data *data,
389				void *ptr)
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
398	ubsan_type_mismatch_common(&common_data, (unsigned long)ptr);
 
 
 
 
 
 
 
 
399}
400EXPORT_SYMBOL(__ubsan_handle_type_mismatch);
401
402void __ubsan_handle_type_mismatch_v1(void *_data, void *ptr)
 
403{
404	struct type_mismatch_data_v1 *data = _data;
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
412	ubsan_type_mismatch_common(&common_data, (unsigned long)ptr);
 
 
 
413}
414EXPORT_SYMBOL(__ubsan_handle_type_mismatch_v1);
415
416void __ubsan_handle_out_of_bounds(void *_data, void *index)
 
417{
418	struct out_of_bounds_data *data = _data;
419	char index_str[VALUE_LENGTH];
420
421	if (suppress_report(&data->location))
422		return;
423
424	ubsan_prologue(&data->location, "array-index-out-of-bounds");
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);
429	ubsan_epilogue();
430}
431EXPORT_SYMBOL(__ubsan_handle_out_of_bounds);
432
433void __ubsan_handle_shift_out_of_bounds(void *_data, void *lhs, void *rhs)
 
434{
435	struct shift_out_of_bounds_data *data = _data;
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];
440	unsigned long ua_flags = user_access_save();
441
442	if (suppress_report(&data->location))
443		goto out;
444
445	ubsan_prologue(&data->location, "shift-out-of-bounds");
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
468	ubsan_epilogue();
469out:
470	user_access_restore(ua_flags);
471}
472EXPORT_SYMBOL(__ubsan_handle_shift_out_of_bounds);
473
474
475void __ubsan_handle_builtin_unreachable(void *_data)
 
476{
477	struct unreachable_data *data = _data;
478	ubsan_prologue(&data->location, "unreachable");
 
479	pr_err("calling __builtin_unreachable()\n");
480	ubsan_epilogue();
481	panic("can't return from __builtin_unreachable()");
482}
483EXPORT_SYMBOL(__ubsan_handle_builtin_unreachable);
484
485void __ubsan_handle_load_invalid_value(void *_data, void *val)
 
486{
487	struct invalid_value_data *data = _data;
488	char val_str[VALUE_LENGTH];
489	unsigned long ua_flags = user_access_save();
490
491	if (suppress_report(&data->location))
492		goto out;
493
494	ubsan_prologue(&data->location, "invalid-load");
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
501	ubsan_epilogue();
502out:
503	user_access_restore(ua_flags);
504}
505EXPORT_SYMBOL(__ubsan_handle_load_invalid_value);
506
507void __ubsan_handle_alignment_assumption(void *_data, unsigned long ptr,
508					 unsigned long align,
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}
533EXPORT_SYMBOL(__ubsan_handle_alignment_assumption);
534
535#endif /* !CONFIG_UBSAN_TRAP */
v4.6
 
  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
 23const 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
 46static bool was_reported(struct source_location *location)
 47{
 48	return test_and_set_bit(REPORTED_BIT, &location->reported);
 49}
 50
 51static 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
 58static bool suppress_report(struct source_location *loc)
 59{
 60	return current->in_ubsan || was_reported(loc);
 61}
 62
 63static bool type_is_int(struct type_descriptor *type)
 64{
 65	return type->type_kind == type_kind_int;
 66}
 67
 68static bool type_is_signed(struct type_descriptor *type)
 69{
 70	WARN_ON(!type_is_int(type));
 71	return  type->type_info & 1;
 72}
 73
 74static unsigned type_bit_width(struct type_descriptor *type)
 75{
 76	return 1 << (type->type_info >> 1);
 77}
 78
 79static 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
 89static s_max get_signed_val(struct type_descriptor *type, unsigned long val)
 90{
 91	if (is_inline_int(type)) {
 92		unsigned extra_bits = sizeof(s_max)*8 - type_bit_width(type);
 93		return ((s_max)val) << extra_bits >> extra_bits;
 
 
 94	}
 95
 96	if (type_bit_width(type) == 64)
 97		return *(s64 *)val;
 98
 99	return *(s_max *)val;
100}
101
102static bool val_is_negative(struct type_descriptor *type, unsigned long val)
103{
104	return type_is_signed(type) && get_signed_val(type, val) < 0;
105}
106
107static u_max get_unsigned_val(struct type_descriptor *type, unsigned long val)
108{
109	if (is_inline_int(type))
110		return val;
111
112	if (type_bit_width(type) == 64)
113		return *(u64 *)val;
114
115	return *(u_max *)val;
116}
117
118static void val_to_string(char *str, size_t size, struct type_descriptor *type,
119	unsigned long value)
120{
121	if (type_is_int(type)) {
122		if (type_bit_width(type) == 128) {
123#if defined(CONFIG_ARCH_SUPPORTS_INT128) && defined(__SIZEOF_INT128__)
124			u_max val = get_unsigned_val(type, value);
125
126			scnprintf(str, size, "0x%08x%08x%08x%08x",
127				(u32)(val >> 96),
128				(u32)(val >> 64),
129				(u32)(val >> 32),
130				(u32)(val));
131#else
132			WARN_ON(1);
133#endif
134		} else if (type_is_signed(type)) {
135			scnprintf(str, size, "%lld",
136				(s64)get_signed_val(type, value));
137		} else {
138			scnprintf(str, size, "%llu",
139				(u64)get_unsigned_val(type, value));
140		}
141	}
142}
143
144static bool location_is_valid(struct source_location *loc)
145{
146	return loc->file_name != NULL;
147}
148
149static DEFINE_SPINLOCK(report_lock);
150
151static void ubsan_prologue(struct source_location *location,
152			unsigned long *flags)
153{
154	current->in_ubsan++;
155	spin_lock_irqsave(&report_lock, *flags);
156
157	pr_err("========================================"
158		"========================================\n");
159	print_source_location("UBSAN: Undefined behaviour in", location);
160}
161
162static void ubsan_epilogue(unsigned long *flags)
163{
164	dump_stack();
165	pr_err("========================================"
166		"========================================\n");
167	spin_unlock_irqrestore(&report_lock, *flags);
168	current->in_ubsan--;
 
 
169}
170
171static void handle_overflow(struct overflow_data *data, unsigned long lhs,
172			unsigned long rhs, char op)
173{
174
175	struct type_descriptor *type = data->type;
176	unsigned long flags;
177	char lhs_val_str[VALUE_LENGTH];
178	char rhs_val_str[VALUE_LENGTH];
179
180	if (suppress_report(&data->location))
181		return;
182
183	ubsan_prologue(&data->location, &flags);
 
 
184
185	val_to_string(lhs_val_str, sizeof(lhs_val_str), type, lhs);
186	val_to_string(rhs_val_str, sizeof(rhs_val_str), type, rhs);
187	pr_err("%s integer overflow:\n",
188		type_is_signed(type) ? "signed" : "unsigned");
189	pr_err("%s %c %s cannot be represented in type %s\n",
190		lhs_val_str,
191		op,
192		rhs_val_str,
193		type->type_name);
194
195	ubsan_epilogue(&flags);
196}
197
198void __ubsan_handle_add_overflow(struct overflow_data *data,
199				unsigned long lhs,
200				unsigned long rhs)
201{
202
203	handle_overflow(data, lhs, rhs, '+');
204}
205EXPORT_SYMBOL(__ubsan_handle_add_overflow);
206
207void __ubsan_handle_sub_overflow(struct overflow_data *data,
208				unsigned long lhs,
209				unsigned long rhs)
210{
211	handle_overflow(data, lhs, rhs, '-');
212}
213EXPORT_SYMBOL(__ubsan_handle_sub_overflow);
214
215void __ubsan_handle_mul_overflow(struct overflow_data *data,
216				unsigned long lhs,
217				unsigned long rhs)
218{
219	handle_overflow(data, lhs, rhs, '*');
220}
221EXPORT_SYMBOL(__ubsan_handle_mul_overflow);
222
223void __ubsan_handle_negate_overflow(struct overflow_data *data,
224				unsigned long old_val)
225{
226	unsigned long flags;
227	char old_val_str[VALUE_LENGTH];
228
229	if (suppress_report(&data->location))
230		return;
231
232	ubsan_prologue(&data->location, &flags);
233
234	val_to_string(old_val_str, sizeof(old_val_str), data->type, old_val);
235
236	pr_err("negation of %s cannot be represented in type %s:\n",
237		old_val_str, data->type->type_name);
238
239	ubsan_epilogue(&flags);
240}
241EXPORT_SYMBOL(__ubsan_handle_negate_overflow);
242
243
244void __ubsan_handle_divrem_overflow(struct overflow_data *data,
245				unsigned long lhs,
246				unsigned long rhs)
247{
248	unsigned long flags;
249	char rhs_val_str[VALUE_LENGTH];
250
251	if (suppress_report(&data->location))
252		return;
253
254	ubsan_prologue(&data->location, &flags);
255
256	val_to_string(rhs_val_str, sizeof(rhs_val_str), data->type, rhs);
257
258	if (type_is_signed(data->type) && get_signed_val(data->type, rhs) == -1)
259		pr_err("division of %s by -1 cannot be represented in type %s\n",
260			rhs_val_str, data->type->type_name);
261	else
262		pr_err("division by zero\n");
263
264	ubsan_epilogue(&flags);
265}
266EXPORT_SYMBOL(__ubsan_handle_divrem_overflow);
267
268static void handle_null_ptr_deref(struct type_mismatch_data *data)
269{
270	unsigned long flags;
271
272	if (suppress_report(&data->location))
273		return;
274
275	ubsan_prologue(&data->location, &flags);
276
277	pr_err("%s null pointer of type %s\n",
278		type_check_kinds[data->type_check_kind],
279		data->type->type_name);
280
281	ubsan_epilogue(&flags);
282}
283
284static void handle_missaligned_access(struct type_mismatch_data *data,
285				unsigned long ptr)
286{
287	unsigned long flags;
288
289	if (suppress_report(&data->location))
290		return;
291
292	ubsan_prologue(&data->location, &flags);
293
294	pr_err("%s misaligned address %p for type %s\n",
295		type_check_kinds[data->type_check_kind],
296		(void *)ptr, data->type->type_name);
297	pr_err("which requires %ld byte alignment\n", data->alignment);
298
299	ubsan_epilogue(&flags);
300}
301
302static void handle_object_size_mismatch(struct type_mismatch_data *data,
303					unsigned long ptr)
304{
305	unsigned long flags;
306
307	if (suppress_report(&data->location))
308		return;
309
310	ubsan_prologue(&data->location, &flags);
311	pr_err("%s address %pk with insufficient space\n",
312		type_check_kinds[data->type_check_kind],
313		(void *) ptr);
314	pr_err("for an object of type %s\n", data->type->type_name);
315	ubsan_epilogue(&flags);
316}
317
318void __ubsan_handle_type_mismatch(struct type_mismatch_data *data,
319				unsigned long ptr)
320{
 
321
322	if (!ptr)
323		handle_null_ptr_deref(data);
324	else if (data->alignment && !IS_ALIGNED(ptr, data->alignment))
325		handle_missaligned_access(data, ptr);
326	else
327		handle_object_size_mismatch(data, ptr);
 
 
328}
329EXPORT_SYMBOL(__ubsan_handle_type_mismatch);
330
331void __ubsan_handle_nonnull_return(struct nonnull_return_data *data)
 
332{
333	unsigned long flags;
334
335	if (suppress_report(&data->location))
336		return;
 
 
337
338	ubsan_prologue(&data->location, &flags);
339
340	pr_err("null pointer returned from function declared to never return null\n");
341
342	if (location_is_valid(&data->attr_location))
343		print_source_location("returns_nonnull attribute specified in",
344				&data->attr_location);
345
346	ubsan_epilogue(&flags);
347}
348EXPORT_SYMBOL(__ubsan_handle_nonnull_return);
349
350void __ubsan_handle_vla_bound_not_positive(struct vla_bound_data *data,
351					unsigned long bound)
352{
353	unsigned long flags;
354	char bound_str[VALUE_LENGTH];
355
356	if (suppress_report(&data->location))
357		return;
358
359	ubsan_prologue(&data->location, &flags);
360
361	val_to_string(bound_str, sizeof(bound_str), data->type, bound);
362	pr_err("variable length array bound value %s <= 0\n", bound_str);
363
364	ubsan_epilogue(&flags);
365}
366EXPORT_SYMBOL(__ubsan_handle_vla_bound_not_positive);
367
368void __ubsan_handle_out_of_bounds(struct out_of_bounds_data *data,
369				unsigned long index)
370{
371	unsigned long flags;
372	char index_str[VALUE_LENGTH];
373
374	if (suppress_report(&data->location))
375		return;
376
377	ubsan_prologue(&data->location, &flags);
378
379	val_to_string(index_str, sizeof(index_str), data->index_type, index);
380	pr_err("index %s is out of range for type %s\n", index_str,
381		data->array_type->type_name);
382	ubsan_epilogue(&flags);
383}
384EXPORT_SYMBOL(__ubsan_handle_out_of_bounds);
385
386void __ubsan_handle_shift_out_of_bounds(struct shift_out_of_bounds_data *data,
387					unsigned long lhs, unsigned long rhs)
388{
389	unsigned long flags;
390	struct type_descriptor *rhs_type = data->rhs_type;
391	struct type_descriptor *lhs_type = data->lhs_type;
392	char rhs_str[VALUE_LENGTH];
393	char lhs_str[VALUE_LENGTH];
 
394
395	if (suppress_report(&data->location))
396		return;
397
398	ubsan_prologue(&data->location, &flags);
399
400	val_to_string(rhs_str, sizeof(rhs_str), rhs_type, rhs);
401	val_to_string(lhs_str, sizeof(lhs_str), lhs_type, lhs);
402
403	if (val_is_negative(rhs_type, rhs))
404		pr_err("shift exponent %s is negative\n", rhs_str);
405
406	else if (get_unsigned_val(rhs_type, rhs) >=
407		type_bit_width(lhs_type))
408		pr_err("shift exponent %s is too large for %u-bit type %s\n",
409			rhs_str,
410			type_bit_width(lhs_type),
411			lhs_type->type_name);
412	else if (val_is_negative(lhs_type, lhs))
413		pr_err("left shift of negative value %s\n",
414			lhs_str);
415	else
416		pr_err("left shift of %s by %s places cannot be"
417			" represented in type %s\n",
418			lhs_str, rhs_str,
419			lhs_type->type_name);
420
421	ubsan_epilogue(&flags);
 
 
422}
423EXPORT_SYMBOL(__ubsan_handle_shift_out_of_bounds);
424
425
426void __noreturn
427__ubsan_handle_builtin_unreachable(struct unreachable_data *data)
428{
429	unsigned long flags;
430
431	ubsan_prologue(&data->location, &flags);
432	pr_err("calling __builtin_unreachable()\n");
433	ubsan_epilogue(&flags);
434	panic("can't return from __builtin_unreachable()");
435}
436EXPORT_SYMBOL(__ubsan_handle_builtin_unreachable);
437
438void __ubsan_handle_load_invalid_value(struct invalid_value_data *data,
439				unsigned long val)
440{
441	unsigned long flags;
442	char val_str[VALUE_LENGTH];
 
443
444	if (suppress_report(&data->location))
445		return;
446
447	ubsan_prologue(&data->location, &flags);
448
449	val_to_string(val_str, sizeof(val_str), data->type, val);
450
451	pr_err("load of value %s is not a valid value for type %s\n",
452		val_str, data->type->type_name);
453
454	ubsan_epilogue(&flags);
 
 
455}
456EXPORT_SYMBOL(__ubsan_handle_load_invalid_value);