From patchwork Thu Dec 9 22:15:37 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Peter Collingbourne X-Patchwork-Id: 12695537 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 4A51FC433F5 for ; Thu, 9 Dec 2021 22:18:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:Cc:To:From:Subject:Mime-Version: Message-Id:Date:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:In-Reply-To: References:List-Owner; bh=YUYwU17VafP436OYQfjP8+VJjiZ47UT0yh7tLOuxp0g=; b=oB6 v5k4GSMslfDPbyoP8KadHhOG1RI8wItqf+PD/5fss2kC21mn7vfwTG5w87EwUrmcL6qpBDEJtM4SJ KbwOvnjoUzOlPltGO2vAJFR2fs55jxba4VO9aKhqt5F93CfW3psiGYAQp47MQanSOxlQ9f3MCGGOS +ziiBkIskg9p2YB8hw1xgBMdvUBBSHiZ2fYD9RawZMiFzIIACFpaGTfEkkYHF/h8farKFoPXut4dq LTuvHyeXPIeTtSBhsX67k8YCJ+JisLOCWmfb6BjjuL3j5rjWje7m9s7VRnkUBJKngm9FGBOcZyOP3 x4r0LIepTs3M0J1OJFkCMc7lw8zpW0Q==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1mvRhp-000CDG-VA; Thu, 09 Dec 2021 22:16:02 +0000 Received: from mail-yb1-xb49.google.com ([2607:f8b0:4864:20::b49]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1mvRhh-000C9w-Kw for linux-arm-kernel@lists.infradead.org; Thu, 09 Dec 2021 22:15:55 +0000 Received: by mail-yb1-xb49.google.com with SMTP id l75-20020a25254e000000b005f763be2fecso13063304ybl.7 for ; Thu, 09 Dec 2021 14:15:52 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:message-id:mime-version:subject:from:to:cc; bh=Ro4VF1L6DuMXIqgc7SY/l1frDimxPn5h+2WPmS0TpF8=; b=ek9haevYSgYRzUgE+093boblArbeQQdLBwxTSMQ1Dhm5hXCxAhVTX6hQIqYlhvtqk/ 9vsu3mLFPk1uIzXI6F6qHXJ1O1OfPVWmdb1I+crZD+DFyF/l0ZazWFfZksSUONoO62GW okMmSRDWTRxwfgpCAZ3Ya2sd9r3Zr91yfDOxmEJrv9hV4aRdDMEkXAdSpiCadvOnZoAO rVKlx9VzXAwcWLBSwCRxREaTiC5cOR/Rxw8AgVt5GdCwULpGxNpfowPA8WLXvClWIebO b/XWQvnFKut0LkUGjeXNn6JgfZn5KE71S21clrePbUxGCxnUiB9KlpAbu0FdOkE9vaOh kXGA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:message-id:mime-version:subject:from:to:cc; bh=Ro4VF1L6DuMXIqgc7SY/l1frDimxPn5h+2WPmS0TpF8=; b=HF1v3O+qXAa1QTBFaBCvmRBgnOrP0sLRlaZ0GmC973LRUc7/TdT+J5RWclLkWbAynR XFHNAwlj1DzTR1qNnWDoV3xqcm1BNLFRl6Cykjzhl4EMOefNYT/OpHS+tk2mq7KlNkhx yLDSkCPWgj7SOnQwi2HNL2LJ9BfNw5Jvwr+/XMfn46BhV6cQ47ti/jxD8kbRNqkkhy5C IcpMAwLbSeJ631nBMovSXhAAwcjRhN1RfIHwohgvEPCy/GyZJYNmwLAGya5EBFdKBaZR pFG+QfZzMyyCNd4ZN+Mkz1rVO0ZOBAeCYvbuV7h7leOFXIbTAorUFg1cHZY6Rfo7tTFW TBFg== X-Gm-Message-State: AOAM5319hLQLUaHaJdAHSYQZklyeeQCRP7OvQK1IjD+y5BLramEfmfHu 0NZ2exLlIdxADha6xihBGeqqRMg= X-Google-Smtp-Source: ABdhPJw1mvtt1HeUFGRZvKr7GzxpHYrqPUlYehrcbUYyjxjLhARa+WO2zLydbdLicUoi4TEvJfE/DCw= X-Received: from pcc-desktop.svl.corp.google.com ([2620:15c:2ce:200:f233:e324:8aa0:f65c]) (user=pcc job=sendgmr) by 2002:a25:ac06:: with SMTP id w6mr10316772ybi.85.1639088151522; Thu, 09 Dec 2021 14:15:51 -0800 (PST) Date: Thu, 9 Dec 2021 14:15:37 -0800 Message-Id: <20211209221545.2333249-1-pcc@google.com> Mime-Version: 1.0 X-Mailer: git-send-email 2.34.1.173.g76aa8bc2d0-goog Subject: [PATCH v4 0/7] kernel: introduce uaccess logging From: Peter Collingbourne To: Catalin Marinas , Will Deacon , Ingo Molnar , Peter Zijlstra , Juri Lelli , Vincent Guittot , Dietmar Eggemann , Steven Rostedt , Ben Segall , Mel Gorman , Daniel Bristot de Oliveira , Thomas Gleixner , Andy Lutomirski , Kees Cook , Andrew Morton , Masahiro Yamada , Sami Tolvanen , YiFei Zhu , Mark Rutland , Frederic Weisbecker , Viresh Kumar , Andrey Konovalov , Peter Collingbourne , Gabriel Krisman Bertazi , Chris Hyser , Daniel Vetter , Chris Wilson , Arnd Bergmann , Dmitry Vyukov , Christian Brauner , "Eric W. Biederman" , Alexey Gladkov , Ran Xiaokai , David Hildenbrand , Xiaofeng Cao , Cyrill Gorcunov , Thomas Cedeno , Marco Elver , Alexander Potapenko Cc: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Evgenii Stepanov X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20211209_141553_735597_612C351C X-CRM114-Status: GOOD ( 30.85 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org 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 architecture-specific. - 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@google.com/ Peter Collingbourne (7): include: split out uaccess instrumentation into a separate header uaccess-buffer: add core code fs: use copy_from_user_nolog() to copy mount() data uaccess-buffer: add CONFIG_GENERIC_ENTRY support arm64: add support for uaccess logging Documentation: document uaccess logging selftests: test uaccess logging Documentation/admin-guide/index.rst | 1 + Documentation/admin-guide/uaccess-logging.rst | 151 +++++++++++++++++ arch/Kconfig | 14 ++ arch/arm64/Kconfig | 1 + arch/arm64/include/asm/thread_info.h | 7 +- arch/arm64/kernel/ptrace.c | 7 + arch/arm64/kernel/signal.c | 5 + fs/exec.c | 3 + fs/namespace.c | 8 +- include/linux/entry-common.h | 2 + include/linux/instrumented-uaccess.h | 53 ++++++ include/linux/instrumented.h | 34 ---- include/linux/sched.h | 5 + include/linux/thread_info.h | 4 + include/linux/uaccess-buffer-info.h | 46 ++++++ include/linux/uaccess-buffer.h | 152 ++++++++++++++++++ include/linux/uaccess.h | 2 +- include/uapi/linux/prctl.h | 3 + include/uapi/linux/uaccess-buffer.h | 27 ++++ kernel/Makefile | 1 + kernel/bpf/helpers.c | 7 +- kernel/entry/common.c | 14 +- kernel/fork.c | 4 + kernel/signal.c | 9 +- kernel/sys.c | 6 + kernel/uaccess-buffer.c | 145 +++++++++++++++++ lib/iov_iter.c | 2 +- lib/usercopy.c | 2 +- tools/testing/selftests/Makefile | 1 + .../testing/selftests/uaccess_buffer/Makefile | 4 + .../uaccess_buffer/uaccess_buffer_test.c | 126 +++++++++++++++ 31 files changed, 802 insertions(+), 44 deletions(-) create mode 100644 Documentation/admin-guide/uaccess-logging.rst create mode 100644 include/linux/instrumented-uaccess.h create mode 100644 include/linux/uaccess-buffer-info.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 create mode 100644 tools/testing/selftests/uaccess_buffer/Makefile create mode 100644 tools/testing/selftests/uaccess_buffer/uaccess_buffer_test.c