From patchwork Thu Feb 16 00:41:16 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ackerley Tng X-Patchwork-Id: 57774 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:adf:eb09:0:0:0:0:0 with SMTP id s9csp20398wrn; Wed, 15 Feb 2023 16:43:52 -0800 (PST) X-Google-Smtp-Source: AK7set9u/JE6KcUyLzuIbOX6xQCR+cX5i/awiJnTsZJHhnTc3ywqQ0cBNY0Pnc13Wzqe3s4XcEIn X-Received: by 2002:a05:6a21:3984:b0:c6:b869:5df4 with SMTP id ad4-20020a056a21398400b000c6b8695df4mr484878pzc.3.1676508231875; Wed, 15 Feb 2023 16:43:51 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1676508231; cv=none; d=google.com; s=arc-20160816; b=K1/14eBW42Z7OsesgyYWJ2I5eqo+A7qfSVotzf+hAA2bpDExlWbRqbraDq0LjTMme4 mCrNcfGhiMF8VI9y4k4IFfbBjlHO5KuP4+jcgdtId2/pggyLAfZbgQUQ6PkEMDBdguBy TnN08moxHUX/c6GrseqcaAPdGoipxQTEGXfX7Ze8+zhnw9jmmdBfNMCG+JfK+C9S+hEW qWVX8XINaYc7Hy2/c3ir6SOR8fvQRtG5okonLZMFugF2WAantnhIWw9bWhjqq12VxaNj Y5bS7axJ1L+uf8fpbs8L1RvCwQZWDHG1lPWUsE8EH0ABHJ+MrLnTU/6KEascYg/3XhC1 /wkw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:dkim-signature; bh=xFJSOOgmL/+0yEbfXc6ryYjQyU1/3hcKBEe5blgULG8=; b=orNi7YhrGUBsSoZHHknNKYRYc947rFfGizW0yLNJJ7ZlousNNmcVOQEnAlaKxXqTWR WOeGZ+JvTbcNpIyHS3xC9U3Gl0rHq/CSprnMWVDU78vvrwdVU7IEuH0cRij2uTbafcQr Z4xPRNV/zK/xodCsFiQj28NL8p8SUpe0exc+6ksQ7T0y3EP9qC2BxvLdtPWNsUvY/kW1 GJGB1Pf87ZGO4H7OoKxHZebRBWzQ64HTgq+lGkrdGETybtuA9rAZeLJCmmGyeHxrkn18 TkpYE8e3tDB3SDuWXelJ8n6gygY4YPVy/MHogPvPG2BhqFyoR1NTmweUDz0Hfv0b7hfN x0vw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=cINlncli; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id r72-20020a632b4b000000b004faeb3bfabcsi6718pgr.690.2023.02.15.16.43.38; Wed, 15 Feb 2023 16:43:51 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=cINlncli; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229620AbjBPAlo (ORCPT + 99 others); Wed, 15 Feb 2023 19:41:44 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:39622 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229619AbjBPAlh (ORCPT ); Wed, 15 Feb 2023 19:41:37 -0500 Received: from mail-pg1-x549.google.com (mail-pg1-x549.google.com [IPv6:2607:f8b0:4864:20::549]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E496C4390A for ; Wed, 15 Feb 2023 16:41:34 -0800 (PST) Received: by mail-pg1-x549.google.com with SMTP id w23-20020a63fb57000000b004fba35704a3so150852pgj.13 for ; Wed, 15 Feb 2023 16:41:34 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=xFJSOOgmL/+0yEbfXc6ryYjQyU1/3hcKBEe5blgULG8=; b=cINlnclit+qIhReE+Kd7SxHPyCpYVP+gHpr/lFZIYMsvtqPRMGMguGhZ+AmtA8dFRc Djw+CXsM0iFzwsMurICuBsTP1scpM+tCEPKY9d7bDxdD5YrTS/xTPWBYVcL8YG0s8lEx aufd0oD+1ETay2cKPepbBkhK2DjZdGGh9+sIqO+Vcbz+DiP+awtJagXFXVVgNQbNgyf4 dLNAd50vYgR4BhTu4f/JtATvZK4wp3PfCPiwj0DiDlPx+B7yfpqr/PRhgYcbi/fNtz/R 06dsNug5WVXeH5PztldqJP7IVZaS+IwS51Y4HyfEGNLXO726iXRISqbDJTUc9PcT6yga oL2A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=xFJSOOgmL/+0yEbfXc6ryYjQyU1/3hcKBEe5blgULG8=; b=d4GMcwd905K7jgMlYCutKhoHjmZcPngDLYzRNfYJjpy4+AYsELnF8ijkf+jqD5b1MK gQbqYCXmZLFitu7IFpLFGmdAXEbJl5nSeIWDkDjMzFpKB7eekyS5cLBsgY4Pav6wMPbs Hmi3+UaRad9znV5j7J8vXqaEZQuuUXwd2JITmPkydDmSAmTuCQQii5HhrPINaq/xOBJt doyNnBMzDzmMzbwqi+kRRtF0rfAAHOzcjSOayyBZL8Br3LYtacUPfymfYyorQE4h7WZM rLzt9lgNcVeYW0i0NUTa4P0xdprU6huJQHX96lsEqAmMGgaeD9ODKXFXM/gpub/iq318 P0aw== X-Gm-Message-State: AO0yUKVbSYsDpAFztBnN7Fc1VGWBqc8YRBjXaU3QC0+gxQaNAuxTX+EH CAdmZfcpZrR7szTQTybe68/TVeLwXFMgkqMZPg== X-Received: from ackerleytng-cloudtop.c.googlers.com ([fda3:e722:ac3:cc00:7f:e700:c0a8:1f5f]) (user=ackerleytng job=sendgmr) by 2002:a63:33ce:0:b0:4e7:79c5:d682 with SMTP id z197-20020a6333ce000000b004e779c5d682mr625417pgz.9.1676508094293; Wed, 15 Feb 2023 16:41:34 -0800 (PST) Date: Thu, 16 Feb 2023 00:41:16 +0000 In-Reply-To: Mime-Version: 1.0 References: X-Mailer: git-send-email 2.39.1.637.g21b0678d19-goog Message-ID: <176081a4817e492965a864a8bc8bacb7d2c05078.1676507663.git.ackerleytng@google.com> Subject: [RFC PATCH 1/2] mm: restrictedmem: Allow userspace to specify mount_path for memfd_restricted From: Ackerley Tng To: kvm@vger.kernel.org, linux-api@vger.kernel.org, linux-arch@vger.kernel.org, linux-doc@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, qemu-devel@nongnu.org Cc: chao.p.peng@linux.intel.com, aarcange@redhat.com, ak@linux.intel.com, akpm@linux-foundation.org, arnd@arndb.de, bfields@fieldses.org, bp@alien8.de, corbet@lwn.net, dave.hansen@intel.com, david@redhat.com, ddutile@redhat.com, dhildenb@redhat.com, hpa@zytor.com, hughd@google.com, jlayton@kernel.org, jmattson@google.com, joro@8bytes.org, jun.nakajima@intel.com, kirill.shutemov@linux.intel.com, linmiaohe@huawei.com, luto@kernel.org, mail@maciej.szmigiero.name, mhocko@suse.com, michael.roth@amd.com, mingo@redhat.com, naoya.horiguchi@nec.com, pbonzini@redhat.com, qperret@google.com, rppt@kernel.org, seanjc@google.com, shuah@kernel.org, steven.price@arm.com, tabba@google.com, tglx@linutronix.de, vannapurve@google.com, vbabka@suse.cz, vkuznets@redhat.com, wanpengli@tencent.com, wei.w.wang@intel.com, x86@kernel.org, yu.c.zhang@linux.intel.com, Ackerley Tng X-Spam-Status: No, score=-9.6 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_NONE, SPF_HELO_NONE,SPF_PASS,USER_IN_DEF_DKIM_WL autolearn=unavailable autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1757946295645070330?= X-GMAIL-MSGID: =?utf-8?q?1757946295645070330?= By default, the backing shmem file for a restrictedmem fd is created on shmem's kernel space mount. With this patch, an optional tmpfs mount can be specified, which will be used as the mountpoint for backing the shmem file associated with a restrictedmem fd. This change is modeled after how sys_open() can create an unnamed temporary file in a given directory with O_TMPFILE. This will help restrictedmem fds inherit the properties of the provided tmpfs mounts, for example, hugepage allocation hints, NUMA binding hints, etc. Signed-off-by: Ackerley Tng --- include/linux/syscalls.h | 2 +- include/uapi/linux/restrictedmem.h | 8 ++++ mm/restrictedmem.c | 63 +++++++++++++++++++++++++++--- 3 files changed, 66 insertions(+), 7 deletions(-) create mode 100644 include/uapi/linux/restrictedmem.h diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h index f9e9e0c820c5..4b8efe9a8680 100644 --- a/include/linux/syscalls.h +++ b/include/linux/syscalls.h @@ -1056,7 +1056,7 @@ asmlinkage long sys_memfd_secret(unsigned int flags); asmlinkage long sys_set_mempolicy_home_node(unsigned long start, unsigned long len, unsigned long home_node, unsigned long flags); -asmlinkage long sys_memfd_restricted(unsigned int flags); +asmlinkage long sys_memfd_restricted(unsigned int flags, const char __user *mount_path); /* * Architecture-specific system calls diff --git a/include/uapi/linux/restrictedmem.h b/include/uapi/linux/restrictedmem.h new file mode 100644 index 000000000000..9f108dd1ac4c --- /dev/null +++ b/include/uapi/linux/restrictedmem.h @@ -0,0 +1,8 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +#ifndef _UAPI_LINUX_RESTRICTEDMEM_H +#define _UAPI_LINUX_RESTRICTEDMEM_H + +/* flags for memfd_restricted */ +#define RMFD_TMPFILE 0x0001U + +#endif /* _UAPI_LINUX_RESTRICTEDMEM_H */ diff --git a/mm/restrictedmem.c b/mm/restrictedmem.c index c5d869d8c2d8..97f3e2159e8b 100644 --- a/mm/restrictedmem.c +++ b/mm/restrictedmem.c @@ -1,11 +1,12 @@ // SPDX-License-Identifier: GPL-2.0 -#include "linux/sbitmap.h" +#include #include #include #include #include #include #include +#include #include struct restrictedmem { @@ -189,19 +190,20 @@ static struct file *restrictedmem_file_create(struct file *memfd) return file; } -SYSCALL_DEFINE1(memfd_restricted, unsigned int, flags) +static int restrictedmem_create(struct vfsmount *mount) { struct file *file, *restricted_file; int fd, err; - if (flags) - return -EINVAL; - fd = get_unused_fd_flags(0); if (fd < 0) return fd; - file = shmem_file_setup("memfd:restrictedmem", 0, VM_NORESERVE); + if (mount) + file = shmem_file_setup_with_mnt(mount, "memfd:restrictedmem", 0, VM_NORESERVE); + else + file = shmem_file_setup("memfd:restrictedmem", 0, VM_NORESERVE); + if (IS_ERR(file)) { err = PTR_ERR(file); goto err_fd; @@ -223,6 +225,55 @@ SYSCALL_DEFINE1(memfd_restricted, unsigned int, flags) return err; } +static bool is_shmem_mount(struct vfsmount *mnt) +{ + return mnt->mnt_sb->s_magic == TMPFS_MAGIC; +} + +static int restrictedmem_create_from_path(const char __user *mount_path) +{ + int ret; + struct path path; + + ret = user_path_at(AT_FDCWD, mount_path, + LOOKUP_FOLLOW | LOOKUP_MOUNTPOINT, + &path); + if (ret) + return ret; + + if (!is_shmem_mount(path.mnt)) { + ret = -EINVAL; + goto out; + } + + ret = mnt_want_write(path.mnt); + if (unlikely(ret)) + goto out; + + ret = restrictedmem_create(path.mnt); + + mnt_drop_write(path.mnt); +out: + path_put(&path); + + return ret; +} + +SYSCALL_DEFINE2(memfd_restricted, unsigned int, flags, const char __user *, mount_path) +{ + if (flags & ~RMFD_TMPFILE) + return -EINVAL; + + if (flags == RMFD_TMPFILE) { + if (!mount_path) + return -EINVAL; + + return restrictedmem_create_from_path(mount_path); + } else { + return restrictedmem_create(NULL); + } +} + int restrictedmem_bind(struct file *file, pgoff_t start, pgoff_t end, struct restrictedmem_notifier *notifier, bool exclusive) { From patchwork Thu Feb 16 00:41:17 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ackerley Tng X-Patchwork-Id: 57775 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:adf:eb09:0:0:0:0:0 with SMTP id s9csp20612wrn; Wed, 15 Feb 2023 16:44:26 -0800 (PST) X-Google-Smtp-Source: AK7set8sMG9WtgQam8ygIhThc1tbdeM67/znpfayCjizARGd4FgbizwrgkjxtIH9sKTtVgSdxX2k X-Received: by 2002:a17:903:230e:b0:196:6162:1a76 with SMTP id d14-20020a170903230e00b0019661621a76mr5168785plh.0.1676508266268; Wed, 15 Feb 2023 16:44:26 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1676508266; cv=none; d=google.com; s=arc-20160816; b=SlSQIHR9obemFPGGTSgyeNl9TFHiccVb3eRNf2zrDbAEGrFF8U1cJwLecMreYJNXKL mTX4FP26RGwf/E00jdzEGe1U+UF6VtwAJxQiEC+wEvvJB1gq188h40AkZlR0O8USg1CN X4xkAYLMUFR8EeNhvQ32EFzBPGFRiEZd3y3nZypCGvFVY1D1CdLA6km4DFsJD4RxvMFK /gDNvF+Q8jblvyDxfxbiIFidrH7OAysm1yJyiQWEp+81cKj8Vs+18ZC5W2XMmD/MJVVT VofdBcaSvC3hc4dsM5mj53Y7fALrZOH0CaOH3tQ8Ry4To6qK2++PXWmer1lJMkP1dNPj V8CA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:dkim-signature; bh=RwSw3tYb5bXq9fGeFYVzZ4Uji8t9bzNp02Nu0wqGVr8=; b=bhNALDFAAKpfED586Sc/TVb7csy7ui5qi6R2/sNcx0rqCTo7iqm9XaLxzKefg/Gso0 DUK1JoVQpPcfiJ1Pk2SJgV3M5ENapi2fv/AWffOC+IfrioDWxVOyYjB9YNgIW5zOgWgC bVIighNI2YUeYmXpRvfyzSln0vJGX7mZh7XhXOnJg8InI4s4ZvqCB5aPKkZJHVESSvLJ Mne6hS6iy2y5tSTlhQ9XjSBGcs+Yxrylsxe83yQOaNa2dSaUQX1DQjzvbZ+lBFG+T6iR jakhBcvivMekc+HQ2XloPbmjlOU4zoHYXHrf01YCx4ZwjKkeUnOQ+DFKc4VOSN56F296 gWJA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b="a6/aZwZM"; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id iz17-20020a170902ef9100b00192ff55301csi16685378plb.519.2023.02.15.16.44.13; Wed, 15 Feb 2023 16:44:26 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b="a6/aZwZM"; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229506AbjBPAlt (ORCPT + 99 others); Wed, 15 Feb 2023 19:41:49 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:39818 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229483AbjBPAlm (ORCPT ); Wed, 15 Feb 2023 19:41:42 -0500 Received: from mail-pg1-x549.google.com (mail-pg1-x549.google.com [IPv6:2607:f8b0:4864:20::549]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5BE99442F9 for ; Wed, 15 Feb 2023 16:41:38 -0800 (PST) Received: by mail-pg1-x549.google.com with SMTP id p4-20020a654904000000b004fb64e929f2so155791pgs.7 for ; Wed, 15 Feb 2023 16:41:38 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=RwSw3tYb5bXq9fGeFYVzZ4Uji8t9bzNp02Nu0wqGVr8=; b=a6/aZwZMKgM9Qwg+eZcRGVXefYnK2gekXci5+402C9kYjaRKvCntG9/9UB64dqHJj4 utKOg+syvAUy0EV4DBkBSn9lMSketoQ/IKXaOt1Z/yjVFG1HfWHMlNFXX4aNcRKANnmH eAPnL1XgdbYfIT8hZYQ8fObP+OEaQS1UkFxrNAsWasJb6HEbZXTNCOF/s33NcZRZ+OQk BqNQ/CyZLmfjBzr7r1oNqVmOkPA5/8tV65euXIZEud6Iazk/zMeKJDYccPllrwFkPAEO ukqjTuuwoXWvGYWEq+OSuWeuT3TY7Y2Z+KS2DU57mQtp8rwmzmbo5nddYHr9bU6Se8r/ J7Rw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=RwSw3tYb5bXq9fGeFYVzZ4Uji8t9bzNp02Nu0wqGVr8=; b=qdmiGKgowm4R3SgXEHR6H4J4jo0KonTdO9y+YQ9KDw8qkzUxVtHfcBYynrh9/tkc7f bECo1iMo3xBe4jDmsc+0LyyYOXZBb3onQQMFpTMGG61B9TCyiPG3CYgeUKGygwizrIwQ oeQOoBmp7oK55vdSH1RrQQoU3XAmuSidGrlyRP43tMV0DgI1CjgyF7nFtHo6KVpjbnYn OaC9khY7SUTHH4zr24uc+m/e+pBgSDltzrr8Cbzox0lnkavRmRgGhm0D0/piYKadoP31 6LSc0Pmb4eRJAIaUXH3A2t3R84LS3IYe42f0FTGLTAGU8Y2KM0Vqo3kaju9RoaZxHRva 232A== X-Gm-Message-State: AO0yUKXR0FP3Vn8fLCN4K/Dq+r2efM1UhpVjkn+ZCWMH1Rmb96H5wFXU 1dld/yF9L5MqaygQu68CAQkP1584r+N+F76WvA== X-Received: from ackerleytng-cloudtop.c.googlers.com ([fda3:e722:ac3:cc00:7f:e700:c0a8:1f5f]) (user=ackerleytng job=sendgmr) by 2002:a17:903:2594:b0:19a:b107:bd11 with SMTP id jb20-20020a170903259400b0019ab107bd11mr951631plb.29.1676508097502; Wed, 15 Feb 2023 16:41:37 -0800 (PST) Date: Thu, 16 Feb 2023 00:41:17 +0000 In-Reply-To: Mime-Version: 1.0 References: X-Mailer: git-send-email 2.39.1.637.g21b0678d19-goog Message-ID: <06098450437ba5ed2011090d95f6ccb817728710.1676507663.git.ackerleytng@google.com> Subject: [RFC PATCH 2/2] selftests: restrictedmem: Check hugepage-ness of shmem file backing restrictedmem fd From: Ackerley Tng To: kvm@vger.kernel.org, linux-api@vger.kernel.org, linux-arch@vger.kernel.org, linux-doc@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, qemu-devel@nongnu.org Cc: chao.p.peng@linux.intel.com, aarcange@redhat.com, ak@linux.intel.com, akpm@linux-foundation.org, arnd@arndb.de, bfields@fieldses.org, bp@alien8.de, corbet@lwn.net, dave.hansen@intel.com, david@redhat.com, ddutile@redhat.com, dhildenb@redhat.com, hpa@zytor.com, hughd@google.com, jlayton@kernel.org, jmattson@google.com, joro@8bytes.org, jun.nakajima@intel.com, kirill.shutemov@linux.intel.com, linmiaohe@huawei.com, luto@kernel.org, mail@maciej.szmigiero.name, mhocko@suse.com, michael.roth@amd.com, mingo@redhat.com, naoya.horiguchi@nec.com, pbonzini@redhat.com, qperret@google.com, rppt@kernel.org, seanjc@google.com, shuah@kernel.org, steven.price@arm.com, tabba@google.com, tglx@linutronix.de, vannapurve@google.com, vbabka@suse.cz, vkuznets@redhat.com, wanpengli@tencent.com, wei.w.wang@intel.com, x86@kernel.org, yu.c.zhang@linux.intel.com, Ackerley Tng X-Spam-Status: No, score=-9.6 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_NONE, SPF_HELO_NONE,SPF_PASS,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1757946331662038396?= X-GMAIL-MSGID: =?utf-8?q?1757946331662038396?= For memfd_restricted() calls without a userspace mount, the backing file should be the shmem mount in the kernel, and the size of backing pages should be as defined by system-wide shmem configuration. If a userspace mount is provided, the size of backing pages should be as defined in the mount. Signed-off-by: Ackerley Tng --- tools/testing/selftests/Makefile | 1 + .../selftests/restrictedmem/.gitignore | 3 + .../testing/selftests/restrictedmem/Makefile | 14 + .../testing/selftests/restrictedmem/common.c | 9 + .../testing/selftests/restrictedmem/common.h | 8 + .../restrictedmem_hugepage_test.c | 344 ++++++++++++++++++ 6 files changed, 379 insertions(+) create mode 100644 tools/testing/selftests/restrictedmem/.gitignore create mode 100644 tools/testing/selftests/restrictedmem/Makefile create mode 100644 tools/testing/selftests/restrictedmem/common.c create mode 100644 tools/testing/selftests/restrictedmem/common.h create mode 100644 tools/testing/selftests/restrictedmem/restrictedmem_hugepage_test.c diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile index f07aef7c592c..44078eeefb79 100644 --- a/tools/testing/selftests/Makefile +++ b/tools/testing/selftests/Makefile @@ -60,6 +60,7 @@ TARGETS += pstore TARGETS += ptrace TARGETS += openat2 TARGETS += resctrl +TARGETS += restrictedmem TARGETS += rlimits TARGETS += rseq TARGETS += rtc diff --git a/tools/testing/selftests/restrictedmem/.gitignore b/tools/testing/selftests/restrictedmem/.gitignore new file mode 100644 index 000000000000..2581bcc8ff29 --- /dev/null +++ b/tools/testing/selftests/restrictedmem/.gitignore @@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0-only + +restrictedmem_hugepage_test diff --git a/tools/testing/selftests/restrictedmem/Makefile b/tools/testing/selftests/restrictedmem/Makefile new file mode 100644 index 000000000000..da9665718c8a --- /dev/null +++ b/tools/testing/selftests/restrictedmem/Makefile @@ -0,0 +1,14 @@ +# SPDX-License-Identifier: GPL-2.0 + +CFLAGS = $(KHDR_INCLUDES) + +TEST_GEN_PROGS += restrictedmem_hugepage_test + +include ../lib.mk + +EXTRA_CLEAN = $(OUTPUT)/common.o + +$(OUTPUT)/common.o: common.c + $(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c -ffreestanding $< -o $@ + +$(TEST_GEN_PROGS): $(OUTPUT)/common.o diff --git a/tools/testing/selftests/restrictedmem/common.c b/tools/testing/selftests/restrictedmem/common.c new file mode 100644 index 000000000000..79b2ac98cc89 --- /dev/null +++ b/tools/testing/selftests/restrictedmem/common.c @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: GPL-2.0-only + +#include +#include + +int memfd_restricted(unsigned int flags, char *mount_path) +{ + return syscall(__NR_memfd_restricted, flags, mount_path); +} diff --git a/tools/testing/selftests/restrictedmem/common.h b/tools/testing/selftests/restrictedmem/common.h new file mode 100644 index 000000000000..5d59edc4f23f --- /dev/null +++ b/tools/testing/selftests/restrictedmem/common.h @@ -0,0 +1,8 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ + +#ifndef SELFTESTS_RESTRICTEDMEM_COMMON_H +#define SELFTESTS_RESTRICTEDMEM_COMMON_H + +int memfd_restricted(unsigned int flags, char *mount_path); + +#endif // SELFTESTS_RESTRICTEDMEM_COMMON_H diff --git a/tools/testing/selftests/restrictedmem/restrictedmem_hugepage_test.c b/tools/testing/selftests/restrictedmem/restrictedmem_hugepage_test.c new file mode 100644 index 000000000000..0d9cf2ced754 --- /dev/null +++ b/tools/testing/selftests/restrictedmem/restrictedmem_hugepage_test.c @@ -0,0 +1,344 @@ +// SPDX-License-Identifier: GPL-2.0-only + +#include "linux/limits.h" +#include +#include +#include +#include +#include +#include +#include + +#include "linux/restrictedmem.h" + +#include "common.h" +#include "../kselftest_harness.h" + +static int get_hpage_pmd_size(void) +{ + FILE *fp; + char buf[100]; + char *ret; + int size; + + fp = fopen("/sys/kernel/mm/transparent_hugepage/hpage_pmd_size", "r"); + if (!fp) + return -1; + + ret = fgets(buf, 100, fp); + if (ret != buf) { + size = -1; + goto out; + } + + if (sscanf(buf, "%d\n", &size) != 1) + size = -1; + +out: + fclose(fp); + + return size; +} + +static bool is_valid_shmem_thp_policy(char *policy) +{ + if (strcmp(policy, "always") == 0) + return true; + if (strcmp(policy, "within_size") == 0) + return true; + if (strcmp(policy, "advise") == 0) + return true; + if (strcmp(policy, "never") == 0) + return true; + if (strcmp(policy, "deny") == 0) + return true; + if (strcmp(policy, "force") == 0) + return true; + + return false; +} + +static int get_shmem_thp_policy(char *policy) +{ + FILE *fp; + char buf[100]; + char *left = NULL; + char *right = NULL; + int ret = -1; + + fp = fopen("/sys/kernel/mm/transparent_hugepage/shmem_enabled", "r"); + if (!fp) + return -1; + + if (fgets(buf, 100, fp) != buf) + goto out; + + /* + * Expect shmem_enabled to be of format like "always within_size advise + * [never] deny force" + */ + left = memchr(buf, '[', 100); + if (!left) + goto out; + + right = memchr(buf, ']', 100); + if (!right) + goto out; + + memcpy(policy, left + 1, right - left - 1); + + ret = !is_valid_shmem_thp_policy(policy); + +out: + fclose(fp); + return ret; +} + +static int set_shmem_thp_policy(char *policy) +{ + FILE *fp; + size_t len = strlen(policy); + int ret = -1; + + if (!is_valid_shmem_thp_policy(policy)) + return ret; + + fp = fopen("/sys/kernel/mm/transparent_hugepage/shmem_enabled", "w"); + if (!fp) + return ret; + + if (fwrite(policy, 1, len, fp) != len) + goto out; + + if (fwrite("\n", 1, 1, fp) != 1) + goto out; + + ret = 0; + +out: + fclose(fp); + return ret; +} + +FIXTURE(reset_shmem_enabled) +{ + /* + * Expect shmem_enabled to be one of always, within_size, advise, never, + * deny, force + */ + char shmem_enabled[12]; +}; + +FIXTURE_SETUP(reset_shmem_enabled) +{ + memset(self->shmem_enabled, 0, 12); + ASSERT_EQ(0, get_shmem_thp_policy(self->shmem_enabled)); +} + +FIXTURE_TEARDOWN(reset_shmem_enabled) +{ + ASSERT_EQ(0, set_shmem_thp_policy(self->shmem_enabled)); +} + +TEST_F(reset_shmem_enabled, restrictedmem_fstat_shmem_enabled_never) +{ + int mfd = -1; + struct stat stat; + char *orig_shmem_enabled; + + ASSERT_EQ(0, set_shmem_thp_policy("never")); + + mfd = memfd_restricted(0, NULL); + ASSERT_NE(-1, mfd); + + ASSERT_EQ(0, fstat(mfd, &stat)); + + /* + * st_blksize is set based on the superblock's s_blocksize_bits. For + * shmem, this is set to PAGE_SHIFT + */ + ASSERT_EQ(stat.st_blksize, getpagesize()); + + close(mfd); +} + +TEST_F(reset_shmem_enabled, restrictedmem_fstat_shmem_enabled_always) +{ + int mfd = -1; + struct stat stat; + char *orig_shmem_enabled; + + ASSERT_EQ(0, set_shmem_thp_policy("always")); + + mfd = memfd_restricted(0, NULL); + ASSERT_NE(-1, mfd); + + ASSERT_EQ(0, fstat(mfd, &stat)); + + ASSERT_EQ(stat.st_blksize, get_hpage_pmd_size()); + + close(mfd); +} + +TEST(restrictedmem_tmpfile_no_mount_path) +{ + int mfd = memfd_restricted(RMFD_TMPFILE, NULL); + + ASSERT_EQ(-1, mfd); + ASSERT_EQ(EINVAL, errno); +} + +TEST(restrictedmem_tmpfile_nonexistent_mount_path) +{ + int mfd = memfd_restricted(RMFD_TMPFILE, + "/nonexistent/nonexistent/nonexistent"); + + ASSERT_EQ(-1, mfd); + ASSERT_EQ(ENOENT, errno); +} + +TEST(restrictedmem_tmpfile_not_tmpfs_mount) +{ + int mfd = memfd_restricted(RMFD_TMPFILE, "/proc"); + + ASSERT_EQ(-1, mfd); + ASSERT_EQ(EINVAL, errno); +} + +static bool directory_exists(const char *path) +{ + struct stat sb; + + return stat(path, &sb) == 0 && S_ISDIR(sb.st_mode); +} + +FIXTURE(tmpfs_hugepage_mount_path) +{ + char *mount_path; +}; + +FIXTURE_SETUP(tmpfs_hugepage_mount_path) +{ + int ret = -1; + + /* /tmp is an FHS-mandated world-writable directory */ + self->mount_path = "/tmp/restrictedmem-selftest-mnt"; + + if (!directory_exists(self->mount_path)) { + ret = mkdir(self->mount_path, 0777); + ASSERT_EQ(0, ret); + } +} + +FIXTURE_TEARDOWN(tmpfs_hugepage_mount_path) +{ + int ret = -1; + + if (!directory_exists(self->mount_path)) + return; + + ret = umount2(self->mount_path, MNT_FORCE); + EXPECT_EQ(0, ret); + if (ret == -1 && errno == EINVAL) + fprintf(stderr, "%s was not mounted\n", self->mount_path); + + ret = rmdir(self->mount_path); + ASSERT_EQ(0, ret); +} + +TEST_F(tmpfs_hugepage_mount_path, restrictedmem_fstat_tmpfs_huge_always) +{ + int ret = -1; + int mfd = -1; + struct stat stat; + + ret = mount("name", self->mount_path, "tmpfs", 0, "huge=always"); + ASSERT_EQ(0, ret); + + mfd = memfd_restricted(RMFD_TMPFILE, self->mount_path); + ASSERT_NE(-1, mfd); + + ret = fstat(mfd, &stat); + ASSERT_EQ(0, ret); + ASSERT_EQ(stat.st_blksize, get_hpage_pmd_size()); + + close(mfd); +} + +TEST_F(tmpfs_hugepage_mount_path, restrictedmem_fstat_tmpfs_huge_never) +{ + int ret = -1; + int mfd = -1; + struct stat stat; + + ret = mount("name", self->mount_path, "tmpfs", 0, "huge=never"); + ASSERT_EQ(0, ret); + + mfd = memfd_restricted(RMFD_TMPFILE, self->mount_path); + ASSERT_NE(-1, mfd); + + ret = fstat(mfd, &stat); + ASSERT_EQ(0, ret); + ASSERT_EQ(stat.st_blksize, getpagesize()); + + close(mfd); +} + +TEST_F(tmpfs_hugepage_mount_path, restrictedmem_umount_rmdir_while_file_open) +{ + int ret = -1; + int mfd = -1; + + ret = mount("name", self->mount_path, "tmpfs", 0, "huge=always"); + ASSERT_EQ(0, ret); + + mfd = memfd_restricted(RMFD_TMPFILE, self->mount_path); + ASSERT_NE(-1, mfd); + + ret = umount2(self->mount_path, MNT_FORCE); + ASSERT_EQ(-1, ret); + ASSERT_EQ(EBUSY, errno); + + ret = rmdir(self->mount_path); + ASSERT_EQ(-1, ret); + ASSERT_EQ(EBUSY, errno); + + close(mfd); +} + +TEST_F(tmpfs_hugepage_mount_path, restrictedmem_provide_mount_subdir) +{ + int ret = -1; + int mfd = -1; + struct stat stat; + char subdir_path[PATH_MAX] = {0}; + + ret = mount("name", self->mount_path, "tmpfs", 0, "huge=always"); + ASSERT_EQ(0, ret); + + snprintf(subdir_path, PATH_MAX, "%s/%s", self->mount_path, "subdir"); + ret = mkdir(subdir_path, 0777); + ASSERT_EQ(0, ret); + + /* + * Any subdirectory of a tmpfs mount can be provided to memfd_restricted + * as a reference to a mount + */ + mfd = memfd_restricted(RMFD_TMPFILE, subdir_path); + ASSERT_NE(-1, mfd); + + ret = fstat(mfd, &stat); + ASSERT_EQ(0, ret); + ASSERT_EQ(stat.st_blksize, get_hpage_pmd_size()); + + /* + * shmem file is created at the mount, so the subdirectory can be + * removed without issues. + */ + ret = rmdir(subdir_path); + ASSERT_EQ(0, ret); + + close(mfd); +} + +TEST_HARNESS_MAIN