svn commit: r354894 - in head/sys: kern sys
Andrew Turner
andrew at FreeBSD.org
Wed Nov 20 14:37:49 UTC 2019
Author: andrew
Date: Wed Nov 20 14:37:48 2019
New Revision: 354894
URL: https://svnweb.freebsd.org/changeset/base/354894
Log:
Import the NetBSD Kernel Concurrency Sanitizer (KCSAN) runtime.
KCSAN is a tool to find concurrent memory access that may race each other.
After a determined number of memory accesses a cell is created, this
describes the current access. It will then delay for a short period
to allow other CPUs a chance to race. If another CPU performs a memory
access to an overlapping region during this delay the race is reported.
This is a straight import of the NetBSD code, it will be adapted to
FreeBSD in a future commit.
Sponsored by: DARPA, AFRL
Added:
head/sys/kern/subr_csan.c (contents, props changed)
head/sys/sys/csan.h (contents, props changed)
Added: head/sys/kern/subr_csan.c
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ head/sys/kern/subr_csan.c Wed Nov 20 14:37:48 2019 (r354894)
@@ -0,0 +1,754 @@
+/* $NetBSD: subr_csan.c,v 1.5 2019/11/15 08:11:37 maxv Exp $ */
+
+/*
+ * Copyright (c) 2019 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Maxime Villard.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__KERNEL_RCSID(0, "$NetBSD: subr_csan.c,v 1.5 2019/11/15 08:11:37 maxv Exp $");
+
+#include <sys/param.h>
+#include <sys/device.h>
+#include <sys/kernel.h>
+#include <sys/param.h>
+#include <sys/conf.h>
+#include <sys/systm.h>
+#include <sys/types.h>
+#include <sys/csan.h>
+#include <sys/cpu.h>
+
+#ifdef KCSAN_PANIC
+#define REPORT panic
+#else
+#define REPORT printf
+#endif
+
+typedef struct {
+ uintptr_t addr;
+ uint32_t size;
+ bool write:1;
+ bool atomic:1;
+ uintptr_t pc;
+} csan_cell_t;
+
+typedef struct {
+ bool inited;
+ uint32_t cnt;
+ csan_cell_t cell;
+} csan_cpu_t;
+
+static csan_cpu_t kcsan_cpus[MAXCPUS];
+static bool kcsan_enabled __read_mostly;
+
+#define __RET_ADDR (uintptr_t)__builtin_return_address(0)
+
+#define KCSAN_NACCESSES 1024
+#define KCSAN_DELAY 10 /* 10 microseconds */
+
+/* -------------------------------------------------------------------------- */
+
+/* The MD code. */
+#include <machine/csan.h>
+
+/* -------------------------------------------------------------------------- */
+
+void
+kcsan_init(void)
+{
+ kcsan_enabled = true;
+}
+
+void
+kcsan_cpu_init(struct cpu_info *ci)
+{
+ kcsan_cpus[cpu_index(ci)].inited = true;
+}
+
+/* -------------------------------------------------------------------------- */
+
+static inline void
+kcsan_report(csan_cell_t *new, cpuid_t newcpu, csan_cell_t *old, cpuid_t oldcpu)
+{
+ const char *newsym, *oldsym;
+
+ if (ksyms_getname(NULL, &newsym, (vaddr_t)new->pc, KSYMS_PROC) != 0) {
+ newsym = "Unknown";
+ }
+ if (ksyms_getname(NULL, &oldsym, (vaddr_t)old->pc, KSYMS_PROC) != 0) {
+ oldsym = "Unknown";
+ }
+ REPORT("CSan: Racy Access "
+ "[Cpu%lu %s%s Addr=%p Size=%u PC=%p<%s>] "
+ "[Cpu%lu %s%s Addr=%p Size=%u PC=%p<%s>]\n",
+ newcpu,
+ (new->atomic ? "Atomic " : ""), (new->write ? "Write" : "Read"),
+ (void *)new->addr, new->size, (void *)new->pc, newsym,
+ oldcpu,
+ (old->atomic ? "Atomic " : ""), (old->write ? "Write" : "Read"),
+ (void *)old->addr, old->size, (void *)old->pc, oldsym);
+ kcsan_md_unwind();
+}
+
+static inline bool
+kcsan_access_is_atomic(csan_cell_t *new, csan_cell_t *old)
+{
+ if (new->write && !new->atomic)
+ return false;
+ if (old->write && !old->atomic)
+ return false;
+ return true;
+}
+
+static inline void
+kcsan_access(uintptr_t addr, size_t size, bool write, bool atomic, uintptr_t pc)
+{
+ csan_cell_t old, new;
+ csan_cpu_t *cpu;
+ uint64_t intr;
+ size_t i;
+
+ if (__predict_false(!kcsan_enabled))
+ return;
+ if (__predict_false(kcsan_md_unsupported((vaddr_t)addr)))
+ return;
+
+ new.addr = addr;
+ new.size = size;
+ new.write = write;
+ new.atomic = atomic;
+ new.pc = pc;
+
+ for (i = 0; i < ncpu; i++) {
+ __builtin_memcpy(&old, &kcsan_cpus[i].cell, sizeof(old));
+
+ if (old.addr + old.size <= new.addr)
+ continue;
+ if (new.addr + new.size <= old.addr)
+ continue;
+ if (__predict_true(!old.write && !new.write))
+ continue;
+ if (__predict_true(kcsan_access_is_atomic(&new, &old)))
+ continue;
+
+ kcsan_report(&new, cpu_number(), &old, i);
+ break;
+ }
+
+ if (__predict_false(!kcsan_md_is_avail()))
+ return;
+
+ kcsan_md_disable_intrs(&intr);
+
+ cpu = &kcsan_cpus[cpu_number()];
+ if (__predict_false(!cpu->inited))
+ goto out;
+ cpu->cnt = (cpu->cnt + 1) % KCSAN_NACCESSES;
+ if (__predict_true(cpu->cnt != 0))
+ goto out;
+
+ __builtin_memcpy(&cpu->cell, &new, sizeof(new));
+ kcsan_md_delay(KCSAN_DELAY);
+ __builtin_memset(&cpu->cell, 0, sizeof(new));
+
+out:
+ kcsan_md_enable_intrs(&intr);
+}
+
+#define CSAN_READ(size) \
+ void __tsan_read##size(uintptr_t); \
+ void __tsan_read##size(uintptr_t addr) \
+ { \
+ kcsan_access(addr, size, false, false, __RET_ADDR); \
+ }
+
+CSAN_READ(1)
+CSAN_READ(2)
+CSAN_READ(4)
+CSAN_READ(8)
+CSAN_READ(16)
+
+#define CSAN_WRITE(size) \
+ void __tsan_write##size(uintptr_t); \
+ void __tsan_write##size(uintptr_t addr) \
+ { \
+ kcsan_access(addr, size, true, false, __RET_ADDR); \
+ }
+
+CSAN_WRITE(1)
+CSAN_WRITE(2)
+CSAN_WRITE(4)
+CSAN_WRITE(8)
+CSAN_WRITE(16)
+
+void __tsan_read_range(uintptr_t, size_t);
+void __tsan_write_range(uintptr_t, size_t);
+
+void
+__tsan_read_range(uintptr_t addr, size_t size)
+{
+ kcsan_access(addr, size, false, false, __RET_ADDR);
+}
+
+void
+__tsan_write_range(uintptr_t addr, size_t size)
+{
+ kcsan_access(addr, size, true, false, __RET_ADDR);
+}
+
+void __tsan_init(void);
+void __tsan_func_entry(void *);
+void __tsan_func_exit(void);
+
+void
+__tsan_init(void)
+{
+}
+
+void
+__tsan_func_entry(void *call_pc)
+{
+}
+
+void
+__tsan_func_exit(void)
+{
+}
+
+/* -------------------------------------------------------------------------- */
+
+void *
+kcsan_memcpy(void *dst, const void *src, size_t len)
+{
+ kcsan_access((uintptr_t)src, len, false, false, __RET_ADDR);
+ kcsan_access((uintptr_t)dst, len, true, false, __RET_ADDR);
+ return __builtin_memcpy(dst, src, len);
+}
+
+int
+kcsan_memcmp(const void *b1, const void *b2, size_t len)
+{
+ kcsan_access((uintptr_t)b1, len, false, false, __RET_ADDR);
+ kcsan_access((uintptr_t)b2, len, false, false, __RET_ADDR);
+ return __builtin_memcmp(b1, b2, len);
+}
+
+void *
+kcsan_memset(void *b, int c, size_t len)
+{
+ kcsan_access((uintptr_t)b, len, true, false, __RET_ADDR);
+ return __builtin_memset(b, c, len);
+}
+
+void *
+kcsan_memmove(void *dst, const void *src, size_t len)
+{
+ kcsan_access((uintptr_t)src, len, false, false, __RET_ADDR);
+ kcsan_access((uintptr_t)dst, len, true, false, __RET_ADDR);
+ return __builtin_memmove(dst, src, len);
+}
+
+char *
+kcsan_strcpy(char *dst, const char *src)
+{
+ char *save = dst;
+
+ while (1) {
+ kcsan_access((uintptr_t)src, 1, false, false, __RET_ADDR);
+ kcsan_access((uintptr_t)dst, 1, true, false, __RET_ADDR);
+ *dst = *src;
+ if (*src == '\0')
+ break;
+ src++, dst++;
+ }
+
+ return save;
+}
+
+int
+kcsan_strcmp(const char *s1, const char *s2)
+{
+ while (1) {
+ kcsan_access((uintptr_t)s1, 1, false, false, __RET_ADDR);
+ kcsan_access((uintptr_t)s2, 1, false, false, __RET_ADDR);
+ if (*s1 != *s2)
+ break;
+ if (*s1 == '\0')
+ return 0;
+ s1++, s2++;
+ }
+
+ return (*(const unsigned char *)s1 - *(const unsigned char *)s2);
+}
+
+size_t
+kcsan_strlen(const char *str)
+{
+ const char *s;
+
+ s = str;
+ while (1) {
+ kcsan_access((uintptr_t)s, 1, false, false, __RET_ADDR);
+ if (*s == '\0')
+ break;
+ s++;
+ }
+
+ return (s - str);
+}
+
+#undef kcopy
+#undef copystr
+#undef copyinstr
+#undef copyoutstr
+#undef copyin
+#undef copyout
+
+int kcsan_kcopy(const void *, void *, size_t);
+int kcsan_copystr(const void *, void *, size_t, size_t *);
+int kcsan_copyinstr(const void *, void *, size_t, size_t *);
+int kcsan_copyoutstr(const void *, void *, size_t, size_t *);
+int kcsan_copyin(const void *, void *, size_t);
+int kcsan_copyout(const void *, void *, size_t);
+int kcopy(const void *, void *, size_t);
+int copystr(const void *, void *, size_t, size_t *);
+int copyinstr(const void *, void *, size_t, size_t *);
+int copyoutstr(const void *, void *, size_t, size_t *);
+int copyin(const void *, void *, size_t);
+int copyout(const void *, void *, size_t);
+
+int
+kcsan_kcopy(const void *src, void *dst, size_t len)
+{
+ kcsan_access((uintptr_t)src, len, false, false, __RET_ADDR);
+ kcsan_access((uintptr_t)dst, len, true, false, __RET_ADDR);
+ return kcopy(src, dst, len);
+}
+
+int
+kcsan_copystr(const void *kfaddr, void *kdaddr, size_t len, size_t *done)
+{
+ kcsan_access((uintptr_t)kdaddr, len, true, false, __RET_ADDR);
+ return copystr(kfaddr, kdaddr, len, done);
+}
+
+int
+kcsan_copyin(const void *uaddr, void *kaddr, size_t len)
+{
+ kcsan_access((uintptr_t)kaddr, len, true, false, __RET_ADDR);
+ return copyin(uaddr, kaddr, len);
+}
+
+int
+kcsan_copyout(const void *kaddr, void *uaddr, size_t len)
+{
+ kcsan_access((uintptr_t)kaddr, len, false, false, __RET_ADDR);
+ return copyout(kaddr, uaddr, len);
+}
+
+int
+kcsan_copyinstr(const void *uaddr, void *kaddr, size_t len, size_t *done)
+{
+ kcsan_access((uintptr_t)kaddr, len, true, false, __RET_ADDR);
+ return copyinstr(uaddr, kaddr, len, done);
+}
+
+int
+kcsan_copyoutstr(const void *kaddr, void *uaddr, size_t len, size_t *done)
+{
+ kcsan_access((uintptr_t)kaddr, len, false, false, __RET_ADDR);
+ return copyoutstr(kaddr, uaddr, len, done);
+}
+
+/* -------------------------------------------------------------------------- */
+
+#undef atomic_add_32
+#undef atomic_add_int
+#undef atomic_add_long
+#undef atomic_add_ptr
+#undef atomic_add_64
+#undef atomic_add_32_nv
+#undef atomic_add_int_nv
+#undef atomic_add_long_nv
+#undef atomic_add_ptr_nv
+#undef atomic_add_64_nv
+#undef atomic_and_32
+#undef atomic_and_uint
+#undef atomic_and_ulong
+#undef atomic_and_64
+#undef atomic_and_32_nv
+#undef atomic_and_uint_nv
+#undef atomic_and_ulong_nv
+#undef atomic_and_64_nv
+#undef atomic_or_32
+#undef atomic_or_uint
+#undef atomic_or_ulong
+#undef atomic_or_64
+#undef atomic_or_32_nv
+#undef atomic_or_uint_nv
+#undef atomic_or_ulong_nv
+#undef atomic_or_64_nv
+#undef atomic_cas_32
+#undef atomic_cas_uint
+#undef atomic_cas_ulong
+#undef atomic_cas_ptr
+#undef atomic_cas_64
+#undef atomic_cas_32_ni
+#undef atomic_cas_uint_ni
+#undef atomic_cas_ulong_ni
+#undef atomic_cas_ptr_ni
+#undef atomic_cas_64_ni
+#undef atomic_swap_32
+#undef atomic_swap_uint
+#undef atomic_swap_ulong
+#undef atomic_swap_ptr
+#undef atomic_swap_64
+#undef atomic_dec_32
+#undef atomic_dec_uint
+#undef atomic_dec_ulong
+#undef atomic_dec_ptr
+#undef atomic_dec_64
+#undef atomic_dec_32_nv
+#undef atomic_dec_uint_nv
+#undef atomic_dec_ulong_nv
+#undef atomic_dec_ptr_nv
+#undef atomic_dec_64_nv
+#undef atomic_inc_32
+#undef atomic_inc_uint
+#undef atomic_inc_ulong
+#undef atomic_inc_ptr
+#undef atomic_inc_64
+#undef atomic_inc_32_nv
+#undef atomic_inc_uint_nv
+#undef atomic_inc_ulong_nv
+#undef atomic_inc_ptr_nv
+#undef atomic_inc_64_nv
+
+#define CSAN_ATOMIC_FUNC_ADD(name, tret, targ1, targ2) \
+ void atomic_add_##name(volatile targ1 *, targ2); \
+ void kcsan_atomic_add_##name(volatile targ1 *, targ2); \
+ void kcsan_atomic_add_##name(volatile targ1 *ptr, targ2 val) \
+ { \
+ kcsan_access((uintptr_t)ptr, sizeof(tret), true, true, \
+ __RET_ADDR); \
+ atomic_add_##name(ptr, val); \
+ } \
+ tret atomic_add_##name##_nv(volatile targ1 *, targ2); \
+ tret kcsan_atomic_add_##name##_nv(volatile targ1 *, targ2); \
+ tret kcsan_atomic_add_##name##_nv(volatile targ1 *ptr, targ2 val) \
+ { \
+ kcsan_access((uintptr_t)ptr, sizeof(tret), true, true, \
+ __RET_ADDR); \
+ return atomic_add_##name##_nv(ptr, val); \
+ }
+
+#define CSAN_ATOMIC_FUNC_AND(name, tret, targ1, targ2) \
+ void atomic_and_##name(volatile targ1 *, targ2); \
+ void kcsan_atomic_and_##name(volatile targ1 *, targ2); \
+ void kcsan_atomic_and_##name(volatile targ1 *ptr, targ2 val) \
+ { \
+ kcsan_access((uintptr_t)ptr, sizeof(tret), true, true, \
+ __RET_ADDR); \
+ atomic_and_##name(ptr, val); \
+ } \
+ tret atomic_and_##name##_nv(volatile targ1 *, targ2); \
+ tret kcsan_atomic_and_##name##_nv(volatile targ1 *, targ2); \
+ tret kcsan_atomic_and_##name##_nv(volatile targ1 *ptr, targ2 val) \
+ { \
+ kcsan_access((uintptr_t)ptr, sizeof(tret), true, true, \
+ __RET_ADDR); \
+ return atomic_and_##name##_nv(ptr, val); \
+ }
+
+#define CSAN_ATOMIC_FUNC_OR(name, tret, targ1, targ2) \
+ void atomic_or_##name(volatile targ1 *, targ2); \
+ void kcsan_atomic_or_##name(volatile targ1 *, targ2); \
+ void kcsan_atomic_or_##name(volatile targ1 *ptr, targ2 val) \
+ { \
+ kcsan_access((uintptr_t)ptr, sizeof(tret), true, true, \
+ __RET_ADDR); \
+ atomic_or_##name(ptr, val); \
+ } \
+ tret atomic_or_##name##_nv(volatile targ1 *, targ2); \
+ tret kcsan_atomic_or_##name##_nv(volatile targ1 *, targ2); \
+ tret kcsan_atomic_or_##name##_nv(volatile targ1 *ptr, targ2 val) \
+ { \
+ kcsan_access((uintptr_t)ptr, sizeof(tret), true, true, \
+ __RET_ADDR); \
+ return atomic_or_##name##_nv(ptr, val); \
+ }
+
+#define CSAN_ATOMIC_FUNC_CAS(name, tret, targ1, targ2) \
+ tret atomic_cas_##name(volatile targ1 *, targ2, targ2); \
+ tret kcsan_atomic_cas_##name(volatile targ1 *, targ2, targ2); \
+ tret kcsan_atomic_cas_##name(volatile targ1 *ptr, targ2 exp, targ2 new) \
+ { \
+ kcsan_access((uintptr_t)ptr, sizeof(tret), true, true, \
+ __RET_ADDR); \
+ return atomic_cas_##name(ptr, exp, new); \
+ } \
+ tret atomic_cas_##name##_ni(volatile targ1 *, targ2, targ2); \
+ tret kcsan_atomic_cas_##name##_ni(volatile targ1 *, targ2, targ2); \
+ tret kcsan_atomic_cas_##name##_ni(volatile targ1 *ptr, targ2 exp, targ2 new) \
+ { \
+ kcsan_access((uintptr_t)ptr, sizeof(tret), true, true, \
+ __RET_ADDR); \
+ return atomic_cas_##name##_ni(ptr, exp, new); \
+ }
+
+#define CSAN_ATOMIC_FUNC_SWAP(name, tret, targ1, targ2) \
+ tret atomic_swap_##name(volatile targ1 *, targ2); \
+ tret kcsan_atomic_swap_##name(volatile targ1 *, targ2); \
+ tret kcsan_atomic_swap_##name(volatile targ1 *ptr, targ2 val) \
+ { \
+ kcsan_access((uintptr_t)ptr, sizeof(tret), true, true, \
+ __RET_ADDR); \
+ return atomic_swap_##name(ptr, val); \
+ }
+
+#define CSAN_ATOMIC_FUNC_DEC(name, tret, targ1) \
+ void atomic_dec_##name(volatile targ1 *); \
+ void kcsan_atomic_dec_##name(volatile targ1 *); \
+ void kcsan_atomic_dec_##name(volatile targ1 *ptr) \
+ { \
+ kcsan_access((uintptr_t)ptr, sizeof(tret), true, true, \
+ __RET_ADDR); \
+ atomic_dec_##name(ptr); \
+ } \
+ tret atomic_dec_##name##_nv(volatile targ1 *); \
+ tret kcsan_atomic_dec_##name##_nv(volatile targ1 *); \
+ tret kcsan_atomic_dec_##name##_nv(volatile targ1 *ptr) \
+ { \
+ kcsan_access((uintptr_t)ptr, sizeof(tret), true, true, \
+ __RET_ADDR); \
+ return atomic_dec_##name##_nv(ptr); \
+ }
+
+#define CSAN_ATOMIC_FUNC_INC(name, tret, targ1) \
+ void atomic_inc_##name(volatile targ1 *); \
+ void kcsan_atomic_inc_##name(volatile targ1 *); \
+ void kcsan_atomic_inc_##name(volatile targ1 *ptr) \
+ { \
+ kcsan_access((uintptr_t)ptr, sizeof(tret), true, true, \
+ __RET_ADDR); \
+ atomic_inc_##name(ptr); \
+ } \
+ tret atomic_inc_##name##_nv(volatile targ1 *); \
+ tret kcsan_atomic_inc_##name##_nv(volatile targ1 *); \
+ tret kcsan_atomic_inc_##name##_nv(volatile targ1 *ptr) \
+ { \
+ kcsan_access((uintptr_t)ptr, sizeof(tret), true, true, \
+ __RET_ADDR); \
+ return atomic_inc_##name##_nv(ptr); \
+ }
+
+CSAN_ATOMIC_FUNC_ADD(32, uint32_t, uint32_t, int32_t);
+CSAN_ATOMIC_FUNC_ADD(64, uint64_t, uint64_t, int64_t);
+CSAN_ATOMIC_FUNC_ADD(int, unsigned int, unsigned int, int);
+CSAN_ATOMIC_FUNC_ADD(long, unsigned long, unsigned long, long);
+CSAN_ATOMIC_FUNC_ADD(ptr, void *, void, ssize_t);
+
+CSAN_ATOMIC_FUNC_AND(32, uint32_t, uint32_t, uint32_t);
+CSAN_ATOMIC_FUNC_AND(64, uint64_t, uint64_t, uint64_t);
+CSAN_ATOMIC_FUNC_AND(uint, unsigned int, unsigned int, unsigned int);
+CSAN_ATOMIC_FUNC_AND(ulong, unsigned long, unsigned long, unsigned long);
+
+CSAN_ATOMIC_FUNC_OR(32, uint32_t, uint32_t, uint32_t);
+CSAN_ATOMIC_FUNC_OR(64, uint64_t, uint64_t, uint64_t);
+CSAN_ATOMIC_FUNC_OR(uint, unsigned int, unsigned int, unsigned int);
+CSAN_ATOMIC_FUNC_OR(ulong, unsigned long, unsigned long, unsigned long);
+
+CSAN_ATOMIC_FUNC_CAS(32, uint32_t, uint32_t, uint32_t);
+CSAN_ATOMIC_FUNC_CAS(64, uint64_t, uint64_t, uint64_t);
+CSAN_ATOMIC_FUNC_CAS(uint, unsigned int, unsigned int, unsigned int);
+CSAN_ATOMIC_FUNC_CAS(ulong, unsigned long, unsigned long, unsigned long);
+CSAN_ATOMIC_FUNC_CAS(ptr, void *, void, void *);
+
+CSAN_ATOMIC_FUNC_SWAP(32, uint32_t, uint32_t, uint32_t);
+CSAN_ATOMIC_FUNC_SWAP(64, uint64_t, uint64_t, uint64_t);
+CSAN_ATOMIC_FUNC_SWAP(uint, unsigned int, unsigned int, unsigned int);
+CSAN_ATOMIC_FUNC_SWAP(ulong, unsigned long, unsigned long, unsigned long);
+CSAN_ATOMIC_FUNC_SWAP(ptr, void *, void, void *);
+
+CSAN_ATOMIC_FUNC_DEC(32, uint32_t, uint32_t)
+CSAN_ATOMIC_FUNC_DEC(64, uint64_t, uint64_t)
+CSAN_ATOMIC_FUNC_DEC(uint, unsigned int, unsigned int);
+CSAN_ATOMIC_FUNC_DEC(ulong, unsigned long, unsigned long);
+CSAN_ATOMIC_FUNC_DEC(ptr, void *, void);
+
+CSAN_ATOMIC_FUNC_INC(32, uint32_t, uint32_t)
+CSAN_ATOMIC_FUNC_INC(64, uint64_t, uint64_t)
+CSAN_ATOMIC_FUNC_INC(uint, unsigned int, unsigned int);
+CSAN_ATOMIC_FUNC_INC(ulong, unsigned long, unsigned long);
+CSAN_ATOMIC_FUNC_INC(ptr, void *, void);
+
+/* -------------------------------------------------------------------------- */
+
+#include <sys/bus.h>
+
+#undef bus_space_read_multi_1
+#undef bus_space_read_multi_2
+#undef bus_space_read_multi_4
+#undef bus_space_read_multi_8
+#undef bus_space_read_multi_stream_1
+#undef bus_space_read_multi_stream_2
+#undef bus_space_read_multi_stream_4
+#undef bus_space_read_multi_stream_8
+#undef bus_space_read_region_1
+#undef bus_space_read_region_2
+#undef bus_space_read_region_4
+#undef bus_space_read_region_8
+#undef bus_space_read_region_stream_1
+#undef bus_space_read_region_stream_2
+#undef bus_space_read_region_stream_4
+#undef bus_space_read_region_stream_8
+#undef bus_space_write_multi_1
+#undef bus_space_write_multi_2
+#undef bus_space_write_multi_4
+#undef bus_space_write_multi_8
+#undef bus_space_write_multi_stream_1
+#undef bus_space_write_multi_stream_2
+#undef bus_space_write_multi_stream_4
+#undef bus_space_write_multi_stream_8
+#undef bus_space_write_region_1
+#undef bus_space_write_region_2
+#undef bus_space_write_region_4
+#undef bus_space_write_region_8
+#undef bus_space_write_region_stream_1
+#undef bus_space_write_region_stream_2
+#undef bus_space_write_region_stream_4
+#undef bus_space_write_region_stream_8
+
+#define CSAN_BUS_READ_FUNC(bytes, bits) \
+ void bus_space_read_multi_##bytes(bus_space_tag_t, bus_space_handle_t, \
+ bus_size_t, uint##bits##_t *, bus_size_t); \
+ void kcsan_bus_space_read_multi_##bytes(bus_space_tag_t, \
+ bus_space_handle_t, bus_size_t, uint##bits##_t *, bus_size_t); \
+ void kcsan_bus_space_read_multi_##bytes(bus_space_tag_t tag, \
+ bus_space_handle_t hnd, bus_size_t size, uint##bits##_t *buf, \
+ bus_size_t count) \
+ { \
+ kcsan_access((uintptr_t)buf, sizeof(uint##bits##_t) * count, \
+ false, false, __RET_ADDR); \
+ bus_space_read_multi_##bytes(tag, hnd, size, buf, count); \
+ } \
+ void bus_space_read_multi_stream_##bytes(bus_space_tag_t, \
+ bus_space_handle_t, bus_size_t, uint##bits##_t *, bus_size_t); \
+ void kcsan_bus_space_read_multi_stream_##bytes(bus_space_tag_t, \
+ bus_space_handle_t, bus_size_t, uint##bits##_t *, bus_size_t); \
+ void kcsan_bus_space_read_multi_stream_##bytes(bus_space_tag_t tag, \
+ bus_space_handle_t hnd, bus_size_t size, uint##bits##_t *buf, \
+ bus_size_t count) \
+ { \
+ kcsan_access((uintptr_t)buf, sizeof(uint##bits##_t) * count, \
+ false, false, __RET_ADDR); \
+ bus_space_read_multi_stream_##bytes(tag, hnd, size, buf, count);\
+ } \
+ void bus_space_read_region_##bytes(bus_space_tag_t, bus_space_handle_t, \
+ bus_size_t, uint##bits##_t *, bus_size_t); \
+ void kcsan_bus_space_read_region_##bytes(bus_space_tag_t, \
+ bus_space_handle_t, bus_size_t, uint##bits##_t *, bus_size_t); \
+ void kcsan_bus_space_read_region_##bytes(bus_space_tag_t tag, \
+ bus_space_handle_t hnd, bus_size_t size, uint##bits##_t *buf, \
+ bus_size_t count) \
+ { \
+ kcsan_access((uintptr_t)buf, sizeof(uint##bits##_t) * count, \
+ false, false, __RET_ADDR); \
+ bus_space_read_region_##bytes(tag, hnd, size, buf, count); \
+ } \
+ void bus_space_read_region_stream_##bytes(bus_space_tag_t, \
+ bus_space_handle_t, bus_size_t, uint##bits##_t *, bus_size_t); \
+ void kcsan_bus_space_read_region_stream_##bytes(bus_space_tag_t, \
+ bus_space_handle_t, bus_size_t, uint##bits##_t *, bus_size_t); \
+ void kcsan_bus_space_read_region_stream_##bytes(bus_space_tag_t tag, \
+ bus_space_handle_t hnd, bus_size_t size, uint##bits##_t *buf, \
+ bus_size_t count) \
+ { \
+ kcsan_access((uintptr_t)buf, sizeof(uint##bits##_t) * count, \
+ false, false, __RET_ADDR); \
+ bus_space_read_region_stream_##bytes(tag, hnd, size, buf, count);\
+ }
+
+#define CSAN_BUS_WRITE_FUNC(bytes, bits) \
+ void bus_space_write_multi_##bytes(bus_space_tag_t, bus_space_handle_t, \
+ bus_size_t, const uint##bits##_t *, bus_size_t); \
+ void kcsan_bus_space_write_multi_##bytes(bus_space_tag_t, \
+ bus_space_handle_t, bus_size_t, const uint##bits##_t *, bus_size_t);\
+ void kcsan_bus_space_write_multi_##bytes(bus_space_tag_t tag, \
+ bus_space_handle_t hnd, bus_size_t size, const uint##bits##_t *buf, \
+ bus_size_t count) \
+ { \
+ kcsan_access((uintptr_t)buf, sizeof(uint##bits##_t) * count, \
+ true, false, __RET_ADDR); \
+ bus_space_write_multi_##bytes(tag, hnd, size, buf, count); \
+ } \
+ void bus_space_write_multi_stream_##bytes(bus_space_tag_t, \
+ bus_space_handle_t, bus_size_t, const uint##bits##_t *, bus_size_t);\
+ void kcsan_bus_space_write_multi_stream_##bytes(bus_space_tag_t, \
+ bus_space_handle_t, bus_size_t, const uint##bits##_t *, bus_size_t);\
+ void kcsan_bus_space_write_multi_stream_##bytes(bus_space_tag_t tag, \
+ bus_space_handle_t hnd, bus_size_t size, const uint##bits##_t *buf, \
+ bus_size_t count) \
+ { \
+ kcsan_access((uintptr_t)buf, sizeof(uint##bits##_t) * count, \
+ true, false, __RET_ADDR); \
+ bus_space_write_multi_stream_##bytes(tag, hnd, size, buf, count);\
+ } \
+ void bus_space_write_region_##bytes(bus_space_tag_t, bus_space_handle_t,\
+ bus_size_t, const uint##bits##_t *, bus_size_t); \
+ void kcsan_bus_space_write_region_##bytes(bus_space_tag_t, \
+ bus_space_handle_t, bus_size_t, const uint##bits##_t *, bus_size_t);\
+ void kcsan_bus_space_write_region_##bytes(bus_space_tag_t tag, \
+ bus_space_handle_t hnd, bus_size_t size, const uint##bits##_t *buf, \
+ bus_size_t count) \
+ { \
+ kcsan_access((uintptr_t)buf, sizeof(uint##bits##_t) * count, \
+ true, false, __RET_ADDR); \
+ bus_space_write_region_##bytes(tag, hnd, size, buf, count); \
+ } \
+ void bus_space_write_region_stream_##bytes(bus_space_tag_t, \
+ bus_space_handle_t, bus_size_t, const uint##bits##_t *, bus_size_t);\
+ void kcsan_bus_space_write_region_stream_##bytes(bus_space_tag_t, \
+ bus_space_handle_t, bus_size_t, const uint##bits##_t *, bus_size_t);\
+ void kcsan_bus_space_write_region_stream_##bytes(bus_space_tag_t tag, \
+ bus_space_handle_t hnd, bus_size_t size, const uint##bits##_t *buf, \
+ bus_size_t count) \
+ { \
+ kcsan_access((uintptr_t)buf, sizeof(uint##bits##_t) * count, \
+ true, false, __RET_ADDR); \
+ bus_space_write_region_stream_##bytes(tag, hnd, size, buf, count);\
+ }
+
+CSAN_BUS_READ_FUNC(1, 8)
+CSAN_BUS_READ_FUNC(2, 16)
+CSAN_BUS_READ_FUNC(4, 32)
+CSAN_BUS_READ_FUNC(8, 64)
+
+CSAN_BUS_WRITE_FUNC(1, 8)
+CSAN_BUS_WRITE_FUNC(2, 16)
+CSAN_BUS_WRITE_FUNC(4, 32)
+CSAN_BUS_WRITE_FUNC(8, 64)
Added: head/sys/sys/csan.h
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ head/sys/sys/csan.h Wed Nov 20 14:37:48 2019 (r354894)
@@ -0,0 +1,49 @@
+/* $NetBSD: csan.h,v 1.1 2019/11/05 20:19:18 maxv Exp $ */
+
+/*
+ * Copyright (c) 2019 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Maxime Villard.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _SYS_CSAN_H_
+#define _SYS_CSAN_H_
+
+#ifdef _KERNEL_OPT
+#include "opt_kcsan.h"
+#endif
+
+#include <sys/types.h>
+
+#ifdef KCSAN
+void kcsan_init(void);
+void kcsan_cpu_init(struct cpu_info *);
+#else
+#define kcsan_init() __nothing
+#define kcsan_cpu_init(ci) __nothing
+#endif
+
+#endif /* !_SYS_CSAN_H_ */
More information about the svn-src-head
mailing list