[PATCH v2 0/5] kernel: introduce uaccess logging

From: Peter Collingbourne
Date: Tue Nov 23 2021 - 00:17:15 EST

This patch series introduces a kernel feature known as uaccess
logging, which allows userspace programs to be made aware of the
address and size of uaccesses performed by the kernel during
the servicing of a syscall. More details on the motivation
for and interface to this feature are available in the file
Documentation/admin-guide/uaccess-logging.rst added by the final
patch in the series.

Because we don't have a common kernel entry/exit code path that is used
on all architectures, uaccess logging is only implemented for arm64
and architectures that use CONFIG_GENERIC_ENTRY, i.e. x86 and s390.

The proposed interface is the result of numerous iterations and
prototyping and is based on a proposal by Dmitry Vyukov. The interface
preserves the correspondence between uaccess log identity and syscall
identity while tolerating incoming asynchronous signals in the interval
between setting up the logging and the actual syscall. We considered
a number of alternative designs but rejected them for various reasons:

- The design from v1 of this patch [1] proposed notifying the kernel
of the address and size of the uaccess buffer via a prctl that
would also automatically mask and unmask asynchronous signals as
needed, but this would require multiple syscalls per "real" syscall,
harming performance.

- We considered extending the syscall calling convention to
designate currently-unused registers to be used to pass the
location of the uaccess buffer, but this was rejected for being

- One idea that we considered involved using the stack pointer address
as a unique identifier for the syscall, but this currently would
need to be arch-specific as we currently do not appear to have an
arch-generic way of retrieving the stack pointer; the userspace
side would also need some arch-specific code for this to work. It's
also possible that a longjmp() past the signal handler would make
the stack pointer address not unique enough for this purpose.

We also evaluated implementing this on top of the existing tracepoint
facility, but concluded that it is not suitable for this purpose:

- Tracepoints have a per-task granularity at best, whereas we really want
to trace per-syscall. This is so that we can exclude syscalls that
should not be traced, such as syscalls that make up part of the
sanitizer implementation (to avoid infinite recursion when e.g. printing
an error report).

- Tracing would need to be synchronous in order to produce useful
stack traces. For example this could be achieved using the new SIGTRAP
on perf events mechanism. However, this would require logging each
access to the stack (in the form of a sigcontext) and this is more
likely to overflow the stack due to being much larger than a uaccess
buffer entry as well as being unbounded, in contrast to the bounded
buffer size passed to prctl(). An approach based on signal handlers is
also likely to fall foul of the asynchronous signal issues mentioned
previously, together with needing sigreturn to be handled specially
(because it copies a sigcontext from userspace) otherwise we could
never return from the signal handler. Furthermore, arguments to the
trace events are not available to SIGTRAP. (This on its own wouldn't
be insurmountable though -- we could add the arguments as fields
to siginfo.)

- The API in https://www.kernel.org/doc/Documentation/trace/ftrace.txt
-- e.g. trace_pipe_raw gives access to the internal ring buffer, but
I don't think it's usable because it's per-CPU and not per-task.

- Tracepoints can be used by eBPF programs, but eBPF programs may
only be loaded as root, among other potential headaches.

[1] https://lore.kernel.org/all/20210922061809.736124-1-pcc@xxxxxxxxxx/

Peter Collingbourne (5):
fs: use raw_copy_from_user() to copy mount() data
uaccess-buffer: add core code
uaccess-buffer: add CONFIG_GENERIC_ENTRY support
arm64: add support for uaccess logging
Documentation: document uaccess logging

Documentation/admin-guide/index.rst | 1 +
Documentation/admin-guide/uaccess-logging.rst | 149 ++++++++++++++++++
arch/Kconfig | 6 +
arch/arm64/Kconfig | 1 +
arch/arm64/kernel/signal.c | 5 +
arch/arm64/kernel/syscall.c | 3 +
fs/exec.c | 2 +
fs/namespace.c | 7 +-
include/linux/instrumented.h | 5 +-
include/linux/sched.h | 4 +
include/linux/uaccess-buffer-log-hooks.h | 59 +++++++
include/linux/uaccess-buffer.h | 79 ++++++++++
include/uapi/linux/prctl.h | 3 +
include/uapi/linux/uaccess-buffer.h | 25 +++
kernel/Makefile | 1 +
kernel/bpf/helpers.c | 6 +-
kernel/entry/common.c | 7 +
kernel/fork.c | 3 +
kernel/signal.c | 4 +-
kernel/sys.c | 6 +
kernel/uaccess-buffer.c | 125 +++++++++++++++
21 files changed, 497 insertions(+), 4 deletions(-)
create mode 100644 Documentation/admin-guide/uaccess-logging.rst
create mode 100644 include/linux/uaccess-buffer-log-hooks.h
create mode 100644 include/linux/uaccess-buffer.h
create mode 100644 include/uapi/linux/uaccess-buffer.h
create mode 100644 kernel/uaccess-buffer.c