From patchwork Wed Dec 8 04:48:02 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Peter Collingbourne X-Patchwork-Id: 12695276 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 67AB5C433EF for ; Wed, 8 Dec 2021 04:49:54 +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=tMcjIslY63SjKX1JqElTMbYMCaA8sTrXz8m2P7wMMIY=; b=z5t 7TFSMrAZ0B6GpvVReNrNVFfetl+Eir0APXzM+vtnvsBoVxSIPaD928D+1PYznPJQOc7An6tjkwWHe 2cJrVPdIxl45C9CT5BV035MDgVuKs5Ssb8Q6YT/YIo31AtjtJszWSwE+EeXlZwdcPN3JTqsjLdvOR 8J6Wet2reGxzdZeU1inSzfQU5WWbDZCpTfbuS6OgorPKRTQAhfAwK1I7Nq33U8J2JxgXIFbGXnF8r dcyRx4VPPzoQRydpCCZsjDPQQ0ZglfOesbWbZ4Bjtb/SBKtAM3lGxD/y5MsuMjcYCpVKdRfvb1Uwa kO/AFE3izuVaxg0Qv/wpBfc19+4JHyw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1muosR-00BENJ-0H; Wed, 08 Dec 2021 04:48:23 +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 1muosM-00BELx-72 for linux-arm-kernel@lists.infradead.org; Wed, 08 Dec 2021 04:48:20 +0000 Received: by mail-yb1-xb49.google.com with SMTP id t1-20020a5b03c1000000b005f6ee3e97easo2426460ybp.16 for ; Tue, 07 Dec 2021 20:48:16 -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=qq/SsPDV/eM2ZHMz4pu1ftprIPb9q26nLcJqukreREg=; b=Otx7NKnybZDVLygPGQ6qtLX/7BniqvfrZWEninvu8oM860KfRu0vr7Z0t/4xp/7Ddu qUrxqpy8jTCUuJlN5xquFfSZ1nmtisihtsVSJnDWzCdJ7VK1OBK74rZy9F8+QSSzrA21 gU63YKItExxJ+Er23hvx7qQfZ9UDsxXA0I+mxtlvF7UYtFwQhWiVH5I272o7ps4oSX3h Sq/hb89LfLlL/OUvOI3ysJsM/vC2t3vP1bg4G7ybT6+HVS1MnXyCFyicFUyCOszhZko6 5UXWwY6+TDQtGV8owJ/hux6grwkBK08ymOnWYoKyf9S+oOl4nreDiBGtE8y24nflR0qe AeSA== 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=qq/SsPDV/eM2ZHMz4pu1ftprIPb9q26nLcJqukreREg=; b=7tDB0sSdy/j6X7yBRH4nl4HcuiOtKJSlSDs5TY/XH6kfSSnwhO+UEmR4706EFk7UsM 9bbuS0szhuda7WauwaOwQJXTEopQx2cHRTrIjEpzr11k5bpv/cUqiKKwndA0c+8y71EW 9+npX7Lm3k6ZIJPAa9ATlnqggAQ1KcKFgjBOQrJ0BWzJTgcK+4r9AOHkrU6k4ujv8ojs 5nSmMaJZjf6qY1E31xN4u7a2YRJiQkj/ASQ/+JxGTN6EQ31LpcqgkXeA8i0cRX4dVgDJ 2sBIH7eGFM3D6LkvBUP86lBZXk7KEr13iB2Dxn+vGdUnKgy7hvh+nW4I7+BxIzO2kQJs NbSw== X-Gm-Message-State: AOAM53007bnEEjXlMN7Smw2bxRD9B8awwyQL5Rg8rEc9seEU5jy85Az4 JSL5jYLkYIynLtK0BMD81zCTpIk= X-Google-Smtp-Source: ABdhPJwymtGTsHk4dKZ1S8NpF/pLAwI9tg0pIgvXEyfzjV+Lj5wztqdVxpnh/MWxylbznv9TyUuwvzE= X-Received: from pcc-desktop.svl.corp.google.com ([2620:15c:2ce:200:be2d:924d:844b:d2fa]) (user=pcc job=sendgmr) by 2002:a25:aca6:: with SMTP id x38mr10034899ybi.515.1638938896305; Tue, 07 Dec 2021 20:48:16 -0800 (PST) Date: Tue, 7 Dec 2021 20:48:02 -0800 Message-Id: <20211208044808.872554-1-pcc@google.com> Mime-Version: 1.0 X-Mailer: git-send-email 2.34.1.173.g76aa8bc2d0-goog Subject: [PATCH v3 0/6] 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-20211207_204818_308679_1D1D2F91 X-CRM114-Status: GOOD ( 31.77 ) 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 (6): 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 Documentation/admin-guide/index.rst | 1 + Documentation/admin-guide/uaccess-logging.rst | 151 ++++++++++++++++++ arch/Kconfig | 6 + arch/arm64/Kconfig | 1 + arch/arm64/include/asm/thread_info.h | 7 +- arch/arm64/kernel/ptrace.c | 7 + arch/arm64/kernel/signal.c | 5 + arch/arm64/kernel/syscall.c | 1 + 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 | 112 +++++++++++++ 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 | 10 ++ kernel/fork.c | 4 + kernel/signal.c | 4 +- kernel/sys.c | 6 + kernel/uaccess-buffer.c | 129 +++++++++++++++ lib/iov_iter.c | 2 +- lib/usercopy.c | 2 +- 29 files changed, 602 insertions(+), 41 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