CVS log for src/sys/sys/bus_proto.h

Up to [cvs.NetBSD.org] / src / sys / sys

Request diff between arbitrary revisions

Keyword substitution: kv
Default branch: MAIN

Whitespace

Sync with HEAD.

Obey __HAVE_BUS_SPACE_8

Sync w/ HEAD.

Trailing whitespace

Mostly merge changes from HEAD upto 20200411

Add support for Kernel Memory Sanitizer (kMSan). It detects uninitialized
memory used by the kernel at run time, and just like kASan and kCSan, it
is an excellent feature. It has already detected 38 uninitialized variables
in the kernel during my testing, which I have since discreetly fixed.

We use two shadows:
 - "shad", to track uninitialized memory with a bit granularity (1:1).
   Each bit set to 1 in the shad corresponds to one uninitialized bit of
   real kernel memory.
 - "orig", to track the origin of the memory with a 4-byte granularity
   (1:1). Each uint32_t cell in the orig indicates the origin of the
   associated uint32_t of real kernel memory.

The memory consumption of these shadows is consequent, so at least 4GB of
RAM is recommended to run kMSan.

The compiler inserts calls to specific __msan_* functions on each memory
access, to manage both the shad and the orig and detect uninitialized
memory accesses that change the execution flow (like an "if" on an
uninitialized variable).

We mark as uninit several types of memory buffers (stack, pools, kmem,
malloc, uvm_km), and check each buffer passed to copyout, copyoutstr,
bwrite, if_transmit_lock and DMA operations, to detect uninitialized memory
that leaves the system. This allows us to detect kernel info leaks in a way
that is more efficient and also more user-friendly than KLEAK.

Contrary to kASan, kMSan requires comprehensive coverage, ie we cannot
tolerate having one non-instrumented function, because this could cause
false positives. kMSan cannot instrument ASM functions, so I converted
most of them to __asm__ inlines, which kMSan is able to instrument. Those
that remain receive special treatment.

Contrary to kASan again, kMSan uses a TLS, so we must context-switch this
TLS during interrupts. We use different contexts depending on the interrupt
level.

The orig tracks precisely the origin of a buffer. We use a special encoding
for the orig values, and pack together in each uint32_t cell of the orig:
 - a code designating the type of memory (Stack, Pool, etc), and
 - a compressed pointer, which points either (1) to a string containing
   the name of the variable associated with the cell, or (2) to an area
   in the kernel .text section which we resolve to a symbol name + offset.

This encoding allows us not to consume extra memory for associating
information with each cell, and produces a precise output, that can tell
for example the name of an uninitialized variable on the stack, the
function in which it was pushed on the stack, and the function where we
accessed this uninitialized variable.

kMSan is available with LLVM, but not with GCC.

The code is organized in a way that is similar to kASan and kCSan, so it
means that other architectures than amd64 can be supported.

Add Kernel Concurrency Sanitizer (kCSan) support. This sanitizer allows us
to detect race conditions at runtime. It is a variation of TSan that is
easy to implement and more suited to kernel internals, albeit theoretically
less precise than TSan's happens-before.

We do basically two things:

 - On every KCSAN_NACCESSES (=2000) memory accesses, we create a cell
   describing the access, and delay the calling CPU (10ms).

 - On all memory accesses, we verify if the memory we're reading/writing
   is referenced in a cell already.

The combination of the two means that, if for example cpu0 does a read that
is selected and cpu1 does a write at the same address, kCSan will fire,
because cpu1's write collides with cpu0's read cell.

The coverage of the instrumentation is the same as that of kASan. Also, the
code is organized in a way similar to kASan, so it is easy to add support
for more architectures than amd64. kCSan is compatible with KCOV.

Reviewed by Kamil.

Fix KASAN on aarch64: the bus_space_* functions are macros, so we can't
redefine them. Introduce __HAVE_KASAN_INSTR_BUS, which indicates whether
to instrument the bus functions. Defined on amd64 only.

Add KASAN instrumentation on the bus_space functions that handle buffers.

sync with head.

for a reference, the tree before this commit was tagged
as yamt-pagecache-tag8.

this commit was splitted into small chunks to avoid
a limitation of cvs.  ("Protocol error: too many arguments")

resync with head

Sync with HEAD

add BUS_DMA_PREFETCHABLE flag for bus_dmamem_map(), analog to
BUS_SPACE_MAP_PREFETCHABLE

Add missing prototypes for bus_*_is_equal functions.

Sync with HEAD.

sync with head

Add some missing prototypes for streaming routines.

Correct some bus_space_*_8 prototypes that used uint32_t instead of
uint64_t.

Replace size_t with bus_size_t where that's what bus_space(9) calls for.

sync with head.

Correct bus_space_physload(9) arguments to take "int freelist".

A possible use case of bus_space_physload(9) would be some high-performance
device with huge local memory, like InfiniBand HCA.  We can register
its local memory using bus_space_physload(..., VM_FREELIST_INFINIBAND0),
then later map it to userspace via cdev_mmap(9) -> bus_dmamem_mmap(9).

(bus_dma(9) needs changes too, of course.)

After much consideration, rename bus_space_physload_direct(9) back to
bus_space_physload_device(9).

The latter registers a segment as "device pages".  "Device pages" are
managed, but not used for general purpose memory.  Most typically XIP
pages.

sync with head

Sync with HEAD.

Cosmetic: delete whitespace at end of line.

sync with head

Parameter name in prototype, begone ye scurvy seadog!

Sync with HEAD.

sync with head.

sync with head.

Remove clause 3 and 4 from TNF licenses

sync with HEAD

sync with head.

Sync with head.

sync with head.

Sync with HEAD.

file bus_proto.h was added on branch matt-armv6 on 2007-11-06 23:34:43 +0000

file bus_proto.h was added on branch yamt-lazymbuf on 2007-10-27 11:36:27 +0000

file bus_proto.h was added on branch vmlocking on 2007-10-09 13:45:06 +0000

file bus_proto.h was added on branch yamt-x86pmap on 2007-10-06 15:28:38 +0000

file bus_proto.h was added on branch jmcneill-pm on 2007-10-02 18:29:26 +0000

x86 changes for pcc and LKMs.

- Replace most inline assembly with proper functions. As a side effect
  this reduces the size of amd64 GENERIC by about 120kB, and i386 by a
  smaller amount. Nearly all of the inlines did something slow, or something
  that does not need to be fast.
- Make curcpu() and curlwp functions proper, unless __GNUC__ && _KERNEL.
  In that case make them inlines. Makes curlwp LKM and preemption safe.
- Make bus_space and bus_dma more LKM friendly.
- Share a few more files between the ports.
- Other minor changes.